AI Trainer Chat

1import SwiftUI
2import KinesteXAIKit
3
4struct TrainerScreen: View {
5    @State private var isLoading = false
6    @State private var showKinesteX = true
7
8    // KinesteXAIKit is configured per-instance — no global initialize call.
9    private let kit = KinesteXAIKit(
10        apiKey: "<YOUR_API_KEY>",
11        companyName: "<YOUR_COMPANY>",
12        userId: "<USER_ID>"
13    )
14
15    var body: some View {
16        if showKinesteX {
17            kit.createTrainerChatView(
18                user: nil,                       // or your UserDetails — see below
19                style: IStyle(style: "dark"),
20                isLoading: $isLoading,
21                onMessageReceived: handleMessage
22            )
23        }
24    }
25
26    private func handleMessage(_ message: KinestexMessage) { /* see below */ }
27}

import com.kinestex.kinestexsdkkotlin.KinesteXSDK
import com.kinestex.kinestexsdkkotlin.PermissionHandler
import com.kinestex.kinestexsdkkotlin.models.IStyle
import com.kinestex.kinestexsdkkotlin.models.WebViewMessage
import kotlinx.coroutines.flow.MutableStateFlow

// 1. Once at app start (Application.onCreate):
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        KinesteXSDK.initialize(
            context = this,
            apiKey = "<YOUR_API_KEY>",
            companyName = "<YOUR_COMPANY>",
            userId = "<USER_ID>"
        )
    }
}

// 2. In your Activity / Fragment (must implement PermissionHandler):
private val isLoading = MutableStateFlow(false)

private fun mountTrainer() {
    val webView = KinesteXSDK.createTrainerChatView(
        context = this,
        style = IStyle(style = "dark"),
        isLoading = isLoading,
        onMessageReceived = ::handleWebViewMessage,
        permissionHandler = this
    )
    container.addView(webView) // attach to your view hierarchy
}

import KinestexSDK from "kinestex-sdk-react-native";
import { IPostData, IntegrationOption } from "kinestex-sdk-react-native/src/types";

const postData: IPostData = {
  key: "<YOUR_API_KEY>",
  company: "<YOUR_COMPANY>",
  userId: "<USER_ID>",
  style: { style: "dark" },
};

<KinestexSDK
  data={postData}
  integrationOption={IntegrationOption.AI_TRAINER_CHAT}
  handleMessage={handleMessage}
/>

// Once at app start (e.g. in main()):
await KinesteXAIFramework.initialize(
  apiKey: '<YOUR_API_KEY>',
  companyName: '<YOUR_COMPANY>',
  userId: '<USER_ID>',
);

// Then in your widget tree:
final showKinesteX = ValueNotifier<bool>(true);
final isLoading = ValueNotifier<bool>(false);

KinesteXAIFramework.createTrainerChatView(
  style: IStyle(style: 'dark'),
  isShowKinestex: showKinesteX,
  isLoading: isLoading,
  onMessageReceived: handleWebViewMessage,
);

<!-- 1. Iframe container (matches the standard KinesteX install). -->
<div id="webViewContainer" style="position: fixed; inset: 0;">
  <iframe
    id="webView"
    frameborder="0"
    allow="camera; autoplay; accelerometer; gyroscope; magnetometer"
    sandbox="allow-same-origin allow-scripts"
    allowfullscreen="true"
    style="width: 100%; height: 100%;"
  ></iframe>
</div>

<script>
  const webView = document.getElementById("webView");
  const srcURL = "https://ai.kinestex.com/trainer"; // Dedicated trainer route.

  // 2. Config payload. Add age/height/weight/gender to skip those questions.
  const postData = {
    key: "<YOUR_API_KEY>",
    company: "<YOUR_COMPANY>",
    userId: "<USER_ID>",
    integration: "AI_TRAINER_CHAT",
    style: "dark",
    // Optional pre-fill — see "Pre-filling user data" below.
    // age: 32, height: 178, weight: 76, gender: "male",
  };

  // 3. Retry-aware send: iOS occasionally drops the first postMessage,
  //    so we re-send on `kinestex_loaded` (handled in step 5).
  function sendMessage() {
    if (!webView.contentWindow) return;
    try {
      webView.contentWindow.postMessage(postData, srcURL);
    } catch {
      setTimeout(() => webView.contentWindow.postMessage(postData, srcURL), 100);
    }
  }

  // 4. Load the iframe and send config when ready.
  webView.src = srcURL;
  webView.onload = sendMessage;

  // 5. Listen for events. Messages arrive as JSON strings — validate the
  //    origin before trusting anything, then parse.
  window.addEventListener("message", (event) => {
    if (event.origin !== "https://ai.kinestex.com") return;

    let message;
    try {
      message = JSON.parse(event.data);
    } catch {
      return; // ignore non-JSON messages
    }

    // Re-send config once the iframe confirms it loaded (iOS quirk).
    if (message.type === "kinestex_loaded") {
      sendMessage();
      return;
    }

    handleMessage(message.type, message.data);
  });
</script>

import KinestexSDK, { IntegrationOption } from "kinestex-sdk-react-ts";

export function TrainerChat() {
  return (
    // The component fills its parent — give the wrapper an explicit size.
    <div style={{ width: "100%", height: "100vh" }}>
      <KinestexSDK
        integrationOption={IntegrationOption.AI_TRAINER_CHAT}
        data={{
          key: "<YOUR_API_KEY>",
          company: "<YOUR_COMPANY>",
          userId: "<USER_ID>",
        }}
        handleMessage={handleMessage}
      />
    </div>
  );
}

1// UserDetails on Swift requires ALL five fields — pass the full value when
2// you know everything, otherwise pass `user: nil` and let the trainer ask.
3let user = UserDetails(
4    age: 32,
5    height: 178,         // cm
6    weight: 76,          // kg
7    gender: .Male,
8    lifestyle: .Active   // not used in the trainer UI, but required by the initializer
9)
10
11kit.createTrainerChatView(
12    user: user,
13    style: IStyle(style: "dark"),
14    isLoading: $isLoading,
15    onMessageReceived: handleMessage
16)

import com.kinestex.kinestexsdkkotlin.models.Gender
import com.kinestex.kinestexsdkkotlin.models.Lifestyle
import com.kinestex.kinestexsdkkotlin.models.UserDetails

// UserDetails on Kotlin requires ALL five fields — pass the full object when
// you know everything, otherwise omit `user:` and let the trainer ask.
val user = UserDetails(
    age = 32,
    height = 178,             // cm
    weight = 76,              // kg
    gender = Gender.MALE,
    lifestyle = Lifestyle.ACTIVE   // not used in the trainer UI, but required by the constructor
)

KinesteXSDK.createTrainerChatView(
    context = this,
    user = user,
    style = IStyle(style = "dark"),
    isLoading = isLoading,
    onMessageReceived = ::handleWebViewMessage,
    permissionHandler = this
)

const postData: IPostData = {
  key: "<YOUR_API_KEY>",
  company: "<YOUR_COMPANY>",
  userId: "<USER_ID>",
  age: 32,
  height: 178,   // cm
  weight: 76,    // kg
  gender: "male",
  style: { style: "dark" },
};

// UserDetails on Flutter requires ALL fields — pass the full object when
// you know everything, otherwise omit `user:` and let the trainer ask.
final user = UserDetails(
  age: 32,
  height: 178,                  // cm
  weight: 76,                   // kg
  gender: Gender.Male,
  lifestyle: Lifestyle.Active,  // not used in the trainer UI, but required by the constructor
);

KinesteXAIFramework.createTrainerChatView(
  user: user,
  style: IStyle(style: 'dark'),
  isShowKinestex: showKinesteX,
  isLoading: isLoading,
  onMessageReceived: handleWebViewMessage,
);

// Add the demographic fields to the same postData you already send.
const postData = {
  key: "<YOUR_API_KEY>",
  company: "<YOUR_COMPANY>",
  userId: "<USER_ID>",
  integration: "AI_TRAINER_CHAT",
  age: 32,
  height: 178,   // cm
  weight: 76,    // kg
  gender: "male",
  style: "dark",
};

<KinestexSDK
  integrationOption={IntegrationOption.AI_TRAINER_CHAT}
  data={{
    key: "<YOUR_API_KEY>",
    company: "<YOUR_COMPANY>",
    userId: "<USER_ID>",
    age: 32,
    height: 178,   // cm
    weight: 76,    // kg
    gender: "male",
  }}
  handleMessage={handleMessage}
/>

1private func handleMessage(_ message: KinestexMessage) {
2    switch message {
3    case .exit_kinestex:
4        // User exited the trainer screen via the back button.
5        showKinesteX = false
6
7    case .error_occurred(let data):
8        print("KinesteX error:", data)
9
10    // `trainer_schedule_next_workout` is not yet a typed case — it
11    // arrives as .custom_type, so check the `type` field on the payload.
12    case .custom_type(let data):
13        guard let type = data["type"] as? String else { return }
14        switch type {
15        case "workout_exit_request":
16            // User exited a workout that was launched from the trainer.
17            break
18        case "trainer_schedule_next_workout":
19            // payload: { type, scheduledFor: "YYYY-MM-DDTHH:MM" }
20            if let scheduledFor = data["scheduledFor"] as? String {
21                scheduleNextWorkoutReminder(scheduledFor: scheduledFor)
22            }
23        default:
24            break
25        }
26
27    default:
28        break
29    }
30}

private fun handleWebViewMessage(message: WebViewMessage) {
    when (message) {
        is WebViewMessage.ExitKinestex -> {
            finish() // or hide your container
        }
        is WebViewMessage.ErrorOccurred -> {
            Log.e("KinesteX", "error: ${message.data}")
        }
        is WebViewMessage.WorkoutExitRequest -> {
            // User exited a workout that was launched from the trainer.
        }

        // `trainer_schedule_next_workout` is not yet a typed subclass — it
        // arrives as CustomType, so check the `type` field on message.data.
        is WebViewMessage.CustomType -> {
            val type = message.data["type"] as? String
            val scheduledFor = message.data["scheduledFor"] as? String
            if (type == "trainer_schedule_next_workout" && scheduledFor != null) {
                scheduleNextWorkoutReminder(this, scheduledFor)
            }
        }

        else -> { /* other events */ }
    }
}

const handleMessage = (type: string, data: { [key: string]: any }) => {
  switch (type) {
    case "exit_kinestex":
      // User exited the trainer screen via the back button.
      break;
    case "workout_exit_request":
      // User exited a workout that was launched from the trainer.
      break;
    case "trainer_schedule_next_workout":
      // NEW — see "Scheduling the next workout" below.
      // data: { type, scheduledFor: "YYYY-MM-DDTHH:MM" }
      scheduleNextWorkoutReminder(data.scheduledFor);
      break;
    case "error_occurred":
      console.warn("KinesteX error", data);
      break;
  }
};

void handleWebViewMessage(WebViewMessage message) {
  if (message is ExitKinestex) {
    showKinesteX.value = false;
    return;
  }
  if (message is ErrorOccurred) {
    debugPrint('KinesteX error: ${message.data}');
    return;
  }

  // `trainer_schedule_next_workout` is not yet a typed subclass — it
  // arrives as CustomType, so check the `type` field on message.data.
  if (message is CustomType) {
    final type = message.data['type'] as String?;
    final scheduledFor = message.data['scheduledFor'] as String?;
    if (type == 'trainer_schedule_next_workout' && scheduledFor != null) {
      scheduleNextWorkoutReminder(scheduledFor);
    }
  }
}

function handleMessage(type, data) {
  switch (type) {
    case "exit_kinestex":
      // User exited the trainer (e.g. close the modal hosting the iframe).
      break;
    case "workout_exit_request":
      // User exited a workout that was launched from the trainer.
      break;
    case "trainer_schedule_next_workout":
      // NEW — see "Scheduling the next workout" below.
      // data: { type, scheduledFor: "YYYY-MM-DDTHH:MM" }
      scheduleNextWorkoutReminder(data.scheduledFor);
      break;
    case "error_occurred":
      console.warn("KinesteX error", data);
      break;
  }
}

const handleMessage = (type: string, payload: Record<string, any>) => {
  switch (type) {
    case "exit_kinestex":
      setShowTrainer(false);
      break;
    case "workout_exit_request":
      // User exited a workout that was launched from the trainer.
      break;
    case "trainer_schedule_next_workout":
      // NEW — see "Scheduling the next workout" below.
      // payload: { type, scheduledFor: "YYYY-MM-DDTHH:MM" }
      scheduleNextWorkoutReminder(payload.scheduledFor);
      break;
    case "error_occurred":
      console.warn("KinesteX error", payload);
      break;
  }
};

1import UserNotifications
2
3private let trainerReminderId = "kinestex.trainer.next_workout" // stable per user
4
5func scheduleNextWorkoutReminder(scheduledFor: String) {
6    // Parse "YYYY-MM-DDTHH:MM" as local time. Don't use ISO8601DateFormatter —
7    // it expects seconds and/or a timezone designator.
8    let formatter = DateFormatter()
9    formatter.dateFormat = "yyyy-MM-dd'T'HH:mm"
10    formatter.timeZone = .current
11    formatter.locale = Locale(identifier: "en_US_POSIX")
12
13    guard let date = formatter.date(from: scheduledFor),
14          date.timeIntervalSinceNow > 5 else { return }
15
16    let center = UNUserNotificationCenter.current()
17    center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, _ in
18        guard granted else { return }
19
20        // Replace the previous reminder so re-schedules don't stack.
21        center.removePendingNotificationRequests(withIdentifiers: [trainerReminderId])
22
23        let content = UNMutableNotificationContent()
24        content.title = "Time for your workout"
25        content.body  = "Your AI Trainer has your next session ready."
26        content.sound = .default
27
28        let components = Calendar.current.dateComponents(
29            [.year, .month, .day, .hour, .minute], from: date
30        )
31        let trigger = UNCalendarNotificationTrigger(
32            dateMatching: components, repeats: false
33        )
34        center.add(UNNotificationRequest(
35            identifier: trainerReminderId,
36            content: content,
37            trigger: trigger
38        ))
39    }
40}

// AndroidManifest.xml:
//   <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
//   <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
//   <receiver android:name=".TrainerReminderReceiver" android:exported="false" />

import android.app.AlarmManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.os.Build
import androidx.core.content.getSystemService
import java.time.LocalDateTime
import java.time.ZoneId

const val TRAINER_REMINDER_ID = 1001 // stable per user

fun scheduleNextWorkoutReminder(context: Context, scheduledFor: String) {
    // Parse "YYYY-MM-DDTHH:MM" as device-local time, then convert to epoch millis.
    val triggerAtMillis = runCatching {
        LocalDateTime.parse(scheduledFor)
            .atZone(ZoneId.systemDefault())
            .toInstant()
            .toEpochMilli()
    }.getOrNull() ?: return
    if (triggerAtMillis - System.currentTimeMillis() < 5_000L) return

    val alarmManager = context.getSystemService<AlarmManager>() ?: return
    val canExact = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
        alarmManager.canScheduleExactAlarms() else true

    val intent = Intent(context, TrainerReminderReceiver::class.java)
    val pi = PendingIntent.getBroadcast(
        context, TRAINER_REMINDER_ID, intent,
        // FLAG_UPDATE_CURRENT replaces any previously scheduled reminder with this id.
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
    )
    alarmManager.cancel(pi) // explicit cancel for safety

    if (canExact) {
        alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAtMillis, pi)
    } else {
        // Fall back to inexact if SCHEDULE_EXACT_ALARM hasn't been granted on Android 12+.
        alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAtMillis, pi)
    }
}

// Receiver that posts the actual notification when the alarm fires.
class TrainerReminderReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val launch = context.packageManager
            .getLaunchIntentForPackage(context.packageName)
            ?.apply { putExtra("openTrainer", true) }
        val contentIntent = PendingIntent.getActivity(
            context, 0, launch,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )
        val notif = NotificationCompat.Builder(context, "trainer_reminders")
            .setSmallIcon(R.drawable.ic_notification) // your icon
            .setContentTitle("Time for your workout")
            .setContentText("Your AI Trainer has your next session ready.")
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setContentIntent(contentIntent)
            .setAutoCancel(true)
            .build()
        context.getSystemService<NotificationManager>()
            ?.notify(TRAINER_REMINDER_ID, notif)
    }
}

import * as Notifications from "expo-notifications";

const TRAINER_REMINDER_ID = "trainer-next-workout";

async function scheduleNextWorkoutReminder(scheduledFor: string) {
  const date = new Date(scheduledFor); // local time, no timezone in the string
  if (Number.isNaN(date.getTime()) || date.getTime() - Date.now() < 5_000) return;

  const { granted } = await Notifications.getPermissionsAsync();
  if (!granted && !(await Notifications.requestPermissionsAsync()).granted) return;

  // Replace the previous reminder so re-schedules don't stack.
  await Notifications.cancelScheduledNotificationAsync(TRAINER_REMINDER_ID).catch(() => {});

  await Notifications.scheduleNotificationAsync({
    identifier: TRAINER_REMINDER_ID,
    content: {
      title: "Time for your workout",
      body: "Your AI Trainer has your next session ready.",
      sound: "default",
    },
    trigger: { type: Notifications.SchedulableTriggerInputTypes.DATE, date },
  });
}

// pubspec.yaml: flutter_local_notifications + timezone
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:timezone/timezone.dart' as tz;

const trainerReminderId = 1001; // stable per user
final notifications = FlutterLocalNotificationsPlugin();

Future<void> scheduleNextWorkoutReminder(String scheduledFor) async {
  final date = DateTime.tryParse(scheduledFor); // local time
  if (date == null || date.difference(DateTime.now()).inSeconds < 5) return;

  // Replace the previous reminder so re-schedules don't stack.
  await notifications.cancel(trainerReminderId);

  await notifications.zonedSchedule(
    trainerReminderId,
    'Time for your workout',
    'Your AI Trainer has your next session ready.',
    tz.TZDateTime.from(date, tz.local),
    const NotificationDetails(
      android: AndroidNotificationDetails(
        'trainer_reminders', 'Trainer reminders',
        importance: Importance.high, priority: Priority.high,
      ),
      iOS: DarwinNotificationDetails(),
    ),
    androidScheduleMode: AndroidScheduleMode.exactAllowWhileIdle,
    uiLocalNotificationDateInterpretation:
        UILocalNotificationDateInterpretation.absoluteTime,
  );
}

// Browser notifications fire only while the page (or a service worker) is alive.
// For reminders that need to wake the user up later, POST to your backend and
// schedule a real push notification (web-push / FCM) instead.

async function scheduleNextWorkoutReminder(scheduledFor) {
  const delay = new Date(scheduledFor).getTime() - Date.now();
  if (Number.isNaN(delay) || delay < 5_000) return;

  if (Notification.permission !== "granted") {
    if ((await Notification.requestPermission()) !== "granted") return;
  }

  // Replace any previously queued in-page reminder.
  clearTimeout(window.__trainerReminderTimer);
  window.__trainerReminderTimer = setTimeout(() => {
    new Notification("Time for your workout", {
      body: "Your AI Trainer has your next session ready.",
      tag: "trainer-next-workout",
    });
  }, delay);
}

// Browser notifications fire only while the page (or a service worker) is alive.
// For reminders that need to wake the user up later, POST to your backend and
// schedule a real push notification (web-push / FCM) instead.

export async function scheduleNextWorkoutReminder(scheduledFor: string) {
  const delay = new Date(scheduledFor).getTime() - Date.now();
  if (Number.isNaN(delay) || delay < 5_000) return;

  if (Notification.permission !== "granted") {
    if ((await Notification.requestPermission()) !== "granted") return;
  }

  const w = window as unknown as { __trainerReminderTimer?: number };
  if (w.__trainerReminderTimer) clearTimeout(w.__trainerReminderTimer);
  w.__trainerReminderTimer = window.setTimeout(() => {
    new Notification("Time for your workout", {
      body: "Your AI Trainer has your next session ready.",
      tag: "trainer-next-workout",
    });
  }, delay);
}