1// Open main admin dashboard
2kinestex.createAdminWorkoutEditor(
3    organization: "YourOrg",
4    isLoading: $isLoading,
5    onMessageReceived: { message in
6        switch message {
7        case .exit_kinestex(_):
8            showEditor = false
9        default:
10            print("Message received: \(message)")
11        }
12    }
13)
14
15// Open specific workout for editing
16kinestex.createAdminWorkoutEditor(
17    organization: "YourOrg",
18    contentType: .workout,
19    contentId: "workout123",
20    isLoading: $isLoading,
21    onMessageReceived: { message in /* handle messages */ }
22)
23
24// Open specific exercise for editing
25kinestex.createAdminWorkoutEditor(
26    organization: "YourOrg",
27    contentType: .exercise,
28    contentId: "exercise456",
29    customQueries: ["language": "en"],
30    isLoading: $isLoading,
31    onMessageReceived: { message in /* handle messages */ }
32)

KinesteXAIFramework.createAdminWorkoutEditor(
  // Use an organization name to differentiate between different orgs.
  // If you don't plan to use multiple orgs, you can use your company name.
  organization: "your_organization_name",
  isShowKinestex: showKinesteX,
  // OPTIONAL: show/hide content on the admin dashboard
  customQueries: {
    "hidePlansTab": true, // will hide the plans tabs in the dashboard
    "tab": "workouts", // will default to workouts tab. Options: "exercises", "plans"
    "isSelectableMenu": true // show select Button, triggers _selected events
  },
  isLoading: ValueNotifier<bool>(false),
  onMessageReceived: (message) {
    handleWebViewMessage(message);
  },
)

1import SwiftUI
2import KinesteXAIKit
3
4struct AdminEditorView: View {
5    @State private var showEditor = false
6    @State private var isLoading = false
7
8    // Initialize KinesteXAIKit with your credentials
9    let kinestex = KinesteXAIKit(
10        apiKey: "YOUR_API_KEY",
11        companyName: "YOUR_COMPANY_NAME",
12        userId: "YOUR_USER_ID"
13    )
14
15    var body: some View {
16        VStack {
17            Text("Admin Editor")
18                .font(.title)
19                .padding()
20
21            Spacer()
22
23            Button(action: {
24                showEditor.toggle()
25            }) {
26                Text("Open Admin Editor")
27                    .font(.title3)
28                    .foregroundColor(.white)
29                    .bold()
30                    .padding()
31                    .frame(maxWidth: .infinity)
32                    .background(Color.blue.cornerRadius(10))
33                    .padding(.horizontal)
34            }
35
36            Spacer()
37        }
38        .fullScreenCover(isPresented: $showEditor) {
39            kinestex.createAdminWorkoutEditor(
40                organization: "YourOrg",
41                contentType: nil,
42                contentId: nil,
43                customQueries: nil,
44                isLoading: $isLoading,
45                onMessageReceived: { message in
46                    switch message {
47                    case .exit_kinestex(_):
48                        showEditor = false
49                    case .error_occurred(let data):
50                        print("Error: \(data)")
51                    default:
52                        print("Message received: \(message)")
53                    }
54                }
55            )
56        }
57    }
58}
59
60#Preview {
61    AdminEditorView()
62}

import 'package:flutter/material.dart';
import 'package:kinestex_sdk_flutter/kinestex_sdk.dart';
import 'package:permission_handler/permission_handler.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await KinesteXAIFramework.initialize(
    apiKey: "your_api_key",
    companyName: "your_company_name",
    userId: "your_user_id",
  );
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  @override
  void dispose() {
    disposeKinesteXAIFramework();
    super.dispose();
  }

  Future<void> disposeKinesteXAIFramework() async {
    await KinesteXAIFramework.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'KinesteX Admin Editor',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({super.key});

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  ValueNotifier<bool> showKinesteX = ValueNotifier<bool>(false);

  @override
  void initState() {
    super.initState();
    _checkCameraPermission();
  }

  void _checkCameraPermission() async {
    if (await Permission.camera.request() != PermissionStatus.granted) {
      _showCameraAccessDeniedAlert();
    }
  }

  void _showCameraAccessDeniedAlert() {
    showDialog(
      context: context,
      builder: (BuildContext context) {
        return AlertDialog(
          title: const Text("Camera Permission Denied"),
          content: const Text("Camera access is required for this app to function properly."),
          actions: <Widget>[
            TextButton(
              child: const Text("OK"),
              onPressed: () => Navigator.of(context).pop(),
            ),
          ],
        );
      },
    );
  }

  void handleWebViewMessage(WebViewMessage message) {
    if (message is ExitKinestex) {
      setState(() {
        showKinesteX.value = false;
      });
    } else if (message is ErrorOccurred) {
      print('Error: ${message.data["error_message"]}');
    } else {
      // Admin editor events arrive as generic messages — check data['type']
      switch (message.data['type']) {
        case 'workout_saved':
          print('Workout saved: ${message.data["workout_id"]}');
          break;
        case 'exercise_saved':
          print('Exercise saved: ${message.data["exercise_id"]}');
          break;
        case 'workout_selected':
          print('Workout selected: ${message.data["workout_title"]}');
          break;
        case 'exercise_selected':
          print('Exercise selected: ${message.data["exercise_title"]}');
          break;
        case 'plan_saved':
          print('Plan saved: ${message.data["plan_id"]}');
          break;
      }
    }
  }

  Widget createAdminWorkoutEditorView() {
    return Center(
      child: KinesteXAIFramework.createAdminWorkoutEditor(
        organization: "your_organization_name",
        isShowKinestex: showKinesteX,
        customQueries: {
          "hidePlansTab": false,
          "tab": "workouts",
          "isSelectableMenu": true,
        },
        isLoading: ValueNotifier<bool>(false),
        onMessageReceived: handleWebViewMessage,
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return ValueListenableBuilder(
      valueListenable: showKinesteX,
      builder: (context, isShowKinesteX, child) {
        return isShowKinesteX
            ? SafeArea(
                child: createAdminWorkoutEditorView(),
              )
            : Scaffold(
                body: Center(
                  child: ElevatedButton(
                    style: ElevatedButton.styleFrom(
                      padding: const EdgeInsets.symmetric(
                        horizontal: 40,
                        vertical: 20,
                      ),
                      backgroundColor: Colors.green,
                      shape: RoundedRectangleBorder(
                        borderRadius: BorderRadius.circular(10),
                      ),
                    ),
                    onPressed: () {
                      showKinesteX.value = true;
                    },
                    child: const Text(
                      'Open Admin Workout Editor',
                      style: TextStyle(
                        fontSize: 20,
                        fontWeight: FontWeight.bold,
                        color: Colors.white,
                      ),
                    ),
                  ),
                ),
              );
      },
    );
  }
}