# Receiving Data

Each platform has a specific pattern for receiving data from KinesteX.

**SDK Platforms (Swift, Kotlin, React Native, React-TS, Flutter):** Use the callback function provided by the SDK with typed message enums.

**HTML/JS:** Set up a message event listener manually since there's no SDK wrapper.

**Platform-Specific Data Handlers**

_Flutter_
```dart
void handleWebViewMessage(WebViewMessage message) {
  if (message is KinestexLaunched) {
    print("KinesteX launched at: ${message}");
  } else if (message is ExitKinestex) {
    print("Exited KinesteX at: ${message} seconds.");
  } else if (message is PlanUnlocked) {
    print("Plan Unlocked: ${message}");
  } else if (message is WorkoutOpened) {
    print("Workout Opened: ${message}");
  } else if (message is WorkoutStarted) {
    print("Workout Started: ${message}");
  } else if (message is ExerciseCompleted) {
    print("Exercise: ${message}");
  } else if (message is TotalActiveSeconds) {
    print("Active seconds: ${message}");
  } else if (message is LeftCameraFrame) {
    print("User left camera frame at time: ${message}");
  } else if (message is ReturnedCameraFrame) {
    print("User returned to camera frame at time: ${message}");
  } else if (message is WorkoutOverview) {
    print("Workout Overview: ${message}");
  } else if (message is ExerciseOverview) {
    print("Exercise Overview: ${message}");
  } else if (message is WorkoutCompleted) {
    print("Workout Completed: ${message}");
  } else {
    print("Other data points: ${message.data}");
  }
}
```

_React Native_
```jsx
const handleMessage = (type: string, data: { [key: string]: any }) => {
  switch (type) {
    case "kinestex_launched":
      console.log('Launched at:', data);
      break;
    case "exit_kinestex":
      console.log('Exited, time spent:', data.time_spent);
      break;
    case "workout_overview":
      console.log('Workout stats:', data);
      break;
    case "exercise_completed":
      console.log('Exercise done:', data.exercise_title);
      break;
    case "workout_completed":
      console.log('Workout finished:', data);
      break;
    case "error_occurred":
      console.error('Error:', data);
      break;
    default:
      console.log('Other message type:', type, data);
      break;
  }
};
```

_React (TypeScript)_
```tsx
const handleMessage = (type: string, data: { [key: string]: any }) => {
  switch (type) {
    case "kinestex_launched":
      console.log('Launched at:', data);
      break;
    case "exit_kinestex":
      console.log('Exited, time spent:', data.time_spent);
      break;
    case "workout_overview":
      console.log('Workout stats:', data);
      break;
    case "exercise_completed":
      console.log('Exercise done:', data.exercise_title);
      break;
    case "workout_completed":
      console.log('Workout finished:', data);
      break;
    case "error_occurred":
      console.error('Error:', data);
      break;
    default:
      console.log('Other message type:', type, data);
      break;
  }
};
```

_Kotlin (Android)_
```kotlin
private fun handleWebViewMessage(message: WebViewMessage) {
    when (message) {
        is WebViewMessage.KinestexLaunched -> {
            println("KinesteX launched at: $message")
        }
        is WebViewMessage.FinishedWorkout -> {
            println("Finished Workout: $message")
        }
        is WebViewMessage.ErrorOccurred -> {
            println("Error Occurred: $message")
        }
        is WebViewMessage.ExerciseCompleted -> {
            println("Exercise Completed: $message")
        }
        is WebViewMessage.ExitKinestex -> {
            println("Exited KinesteX at: $message")
        }
        is WebViewMessage.WorkoutOpened -> {
            println("Workout Opened: $message")
        }
        is WebViewMessage.WorkoutStarted -> {
            println("Workout Started: $message")
        }
        is WebViewMessage.PlanUnlocked -> {
            println("Plan Unlocked: $message")
        }
        is WebViewMessage.WorkoutOverview -> {
            println("Workout Overview: $message")
        }
        is WebViewMessage.ExerciseOverview -> {
            println("Exercise Overview: $message")
        }
        is WebViewMessage.WorkoutCompleted -> {
            println("Workout Completed: $message")
        }
        // Camera Component Specific
        is WebViewMessage.Reps -> {
            println("Reps: $message")
        }
        is WebViewMessage.Mistake -> {
            println("Mistake: $message")
        }
        is WebViewMessage.CustomType -> {
            println("Any other message: $message")
        }
    }
}
```

_Swift (iOS)_
```swift
// onMessageReceived callback passes WebViewMessage enum
// Available message types:

// kinestex_launched([String: Any]) - KinesteX View launched
// finished_workout([String: Any]) - Workout completed
// error_occurred([String: Any]) - Errors (e.g., missing camera)
// exercise_completed([String: Any]) - Exercise finished
// exit_kinestex([String: Any]) - User exits KinesteX view
// workout_opened([String: Any]) - Workout description viewed
// workout_started([String: Any]) - Workout begins
// plan_unlocked([String: Any]) - Workout plan unlocked
// custom_type([String: Any]) - Unrecognized messages
// reps([String: Any]) - Successful repetitions
// mistake([String: Any]) - Detected mistakes
// left_camera_frame([String: Any]) - User left camera frame
// returned_camera_frame([String: Any]) - User returned to frame
// workout_overview([String: Any]) - Workout summary
// exercise_overview([String: Any]) - Exercise summary
// workout_completed([String: Any]) - Workout done, overview exited
```

_HTML / JavaScript_
```html
// HTML/JS requires manual event listener setup
window.addEventListener("message", (event) => {
  // Security: only accept messages from KinesteX
  if (event.origin !== "https://ai.kinestex.com") return;

  try {
    const message = JSON.parse(event.data);

    switch (message.type) {
      case "kinestex_launched":
        console.log("Launched:", message.data);
        break;
      case "exit_kinestex":
        console.log("Exited, time spent:", message.time_spent);
        break;
      case "workout_overview":
        console.log("Workout stats:", message.data);
        break;
      case "exercise_completed":
        console.log("Exercise done:", message.data);
        break;
      case "error_occurred":
        console.error("Error:", message.data || message.message);
        break;
      default:
        console.log("Message:", message.type, message);
    }
  } catch (e) {
    console.error("Failed to parse message:", e);
  }
});
```

---
Source: https://kinestex.com/docs/data-points/receiving-data · Index: https://kinestex.com/llms.txt