// app/build.gradle
dependencies {
    implementation 'com.bookovia:telematics-android:1.0.0'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
}

// project/build.gradle
allprojects {
    repositories {
        maven { url 'https://maven.bookovia.com/releases' }
    }
}

npm install @bookovia/react-native-sdk
# iOS additional setup
cd ios && pod install

yarn add @bookovia/react-native-sdk
cd ios && pod install

dependencies:
  bookovia_telematics: ^1.0.0
  geolocator: ^9.0.0
  permission_handler: ^10.0.0

flutter pub get

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Location permissions -->
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    
    <!-- Background location (Android 10+) -->
    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
    
    <!-- Foreground service -->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
    
    <!-- Network access -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    
    <application>
        <!-- Foreground service declaration -->
        <service 
            android:name="com.bookovia.telematics.LocationTrackingService"
            android:foregroundServiceType="location"
            android:exported="false" />
    </application>
</manifest>

import android.Manifest
import androidx.activity.result.contract.ActivityResultContracts
import com.bookovia.telematics.BookoviaSDK

class MainActivity : AppCompatActivity() {
    private val bookovia = BookoviaSDK.getInstance(this)
    
    private val locationPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { permissions ->
        when {
            permissions[Manifest.permission.ACCESS_FINE_LOCATION] == true -> {
                // Fine location granted
                requestBackgroundPermission()
            }
            permissions[Manifest.permission.ACCESS_COARSE_LOCATION] == true -> {
                // Coarse location granted
                requestBackgroundPermission()
            }
            else -> {
                // No location permissions granted
                showPermissionRationale()
            }
        }
    }
    
    private val backgroundLocationLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            bookovia.startBackgroundTracking()
        }
    }
    
    private fun requestLocationPermissions() {
        locationPermissionLauncher.launch(arrayOf(
            Manifest.permission.ACCESS_FINE_LOCATION,
            Manifest.permission.ACCESS_COARSE_LOCATION
        ))
    }
    
    private fun requestBackgroundPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            backgroundLocationLauncher.launch(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
        } else {
            bookovia.startBackgroundTracking()
        }
    }
}

import { request, PERMISSIONS, RESULTS } from 'react-native-permissions';
import { Platform } from 'react-native';
import { BookoviaSDK } from '@bookovia/react-native-sdk';

const requestLocationPermissions = async () => {
  let permission;
  
  if (Platform.OS === 'ios') {
    permission = PERMISSIONS.IOS.LOCATION_WHEN_IN_USE;
  } else {
    permission = PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION;
  }
  
  const result = await request(permission);
  
  switch (result) {
    case RESULTS.GRANTED:
      // Request background permission
      await requestBackgroundPermission();
      break;
    case RESULTS.DENIED:
      // Show rationale dialog
      showPermissionDialog();
      break;
    case RESULTS.BLOCKED:
      // Direct to settings
      showSettingsDialog();
      break;
  }
};

const requestBackgroundPermission = async () => {
  let bgPermission;
  
  if (Platform.OS === 'ios') {
    bgPermission = PERMISSIONS.IOS.LOCATION_ALWAYS;
  } else if (Platform.Version >= 29) {
    bgPermission = PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION;
  }
  
  if (bgPermission) {
    const result = await request(bgPermission);
    if (result === RESULTS.GRANTED) {
      BookoviaSDK.startBackgroundTracking();
    }
  }
};

import 'package:permission_handler/permission_handler.dart';
import 'package:bookovia_telematics/bookovia_telematics.dart';

class PermissionManager {
  static Future<bool> requestLocationPermissions() async {
    // Request location when in use first
    PermissionStatus status = await Permission.locationWhenInUse.request();
    
    if (status.isGranted) {
      // Request always location for background tracking
      status = await Permission.locationAlways.request();
      
      if (status.isGranted) {
        await BookoviaTelematics.startBackgroundTracking();
        return true;
      }
    }
    
    return false;
  }
  
  static Future<void> showPermissionDialog() async {
    // Show custom dialog explaining why permissions are needed
    // Direct user to app settings if permissions are permanently denied
    if (await Permission.location.isPermanentlyDenied) {
      openAppSettings();
    }
  }
}

import com.bookovia.telematics.BookoviaSDK
import com.bookovia.telematics.BookoviaConfig
import com.bookovia.telematics.callbacks.BookoviaCallback

class BookoviaApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        
        val config = BookoviaConfig.Builder()
            .apiKey("bkv_live_your_api_key")
            .environment(BookoviaConfig.Environment.PRODUCTION)
            .enableDebugLogging(BuildConfig.DEBUG)
            .build()
        
        BookoviaSDK.initialize(this, config)
        
        // Set global callback
        BookoviaSDK.getInstance(this).setCallback(object : BookoviaCallback {
            override fun onTripStarted(trip: Trip) {
                Log.d("Bookovia", "Trip started: ${trip.id}")
            }
            
            override fun onLocationUpdate(location: LocationPoint) {
                // Handle location updates
            }
            
            override fun onSafetyEvent(event: SafetyEvent) {
                if (event.severity == SafetyEvent.Severity.CRITICAL) {
                    showSafetyNotification(event)
                }
            }
            
            override fun onError(error: BookoviaError) {
                Log.e("Bookovia", "SDK Error: ${error.message}")
            }
        })
    }
}

import React, { useEffect } from 'react';
import { BookoviaSDK } from '@bookovia/react-native-sdk';

const App = () => {
  useEffect(() => {
    // Initialize SDK
    BookoviaSDK.initialize({
      apiKey: 'bkv_live_your_api_key',
      environment: 'production', // or 'sandbox'
      enableDebugLogging: __DEV__,
    });
    
    // Set up event listeners
    const tripListener = BookoviaSDK.addTripListener((trip) => {
      console.log('Trip started:', trip.id);
    });
    
    const locationListener = BookoviaSDK.addLocationListener((location) => {
      // Handle location updates
      console.log('Location update:', location);
    });
    
    const safetyListener = BookoviaSDK.addSafetyEventListener((event) => {
      if (event.severity === 'critical') {
        showSafetyAlert(event);
      }
    });
    
    // Cleanup listeners
    return () => {
      tripListener.remove();
      locationListener.remove();
      safetyListener.remove();
    };
  }, []);
  
  return (
    <YourAppComponent />
  );
};

import 'package:bookovia_telematics/bookovia_telematics.dart';

class MyApp extends StatefulWidget {
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  StreamSubscription<Trip>? _tripSubscription;
  StreamSubscription<LocationPoint>? _locationSubscription;
  StreamSubscription<SafetyEvent>? _safetySubscription;
  
  @override
  void initState() {
    super.initState();
    _initializeBooKovia();
  }
  
  void _initializeBooKovia() async {
    await BookoviaTelematics.initialize(
      apiKey: 'bkv_live_your_api_key',
      environment: BookoviaEnvironment.production,
      enableDebugLogging: kDebugMode,
    );
    
    // Set up event streams
    _tripSubscription = BookoviaTelematics.tripStream.listen((trip) {
      print('Trip started: ${trip.id}');
    });
    
    _locationSubscription = BookoviaTelematics.locationStream.listen((location) {
      // Handle location updates
      print('Location: ${location.latitude}, ${location.longitude}');
    });
    
    _safetySubscription = BookoviaTelematics.safetyEventStream.listen((event) {
      if (event.severity == SafetySeverity.critical) {
        _showSafetyAlert(event);
      }
    });
  }
  
  @override
  void dispose() {
    _tripSubscription?.cancel();
    _locationSubscription?.cancel();
    _safetySubscription?.cancel();
    super.dispose();
  }
}

class TripManager(private val context: Context) {
    private val bookovia = BookoviaSDK.getInstance(context)
    
    fun startTrip() {
        val metadata = mapOf(
            "driver_name" to "John Doe",
            "vehicle_id" to "vehicle_123", 
            "purpose" to "delivery"
        )
        
        bookovia.startTrip(metadata, object : TripCallback {
            override fun onSuccess(trip: Trip) {
                Log.d("TripManager", "Trip started: ${trip.id}")
                
                // Update UI on main thread
                (context as? Activity)?.runOnUiThread {
                    updateTripUI(trip)
                }
            }
            
            override fun onError(error: BookoviaError) {
                Log.e("TripManager", "Failed to start trip: ${error.message}")
                showErrorDialog(error)
            }
        })
    }
    
    suspend fun startTripAsync(): Trip = suspendCoroutine { continuation ->
        bookovia.startTrip(emptyMap(), object : TripCallback {
            override fun onSuccess(trip: Trip) {
                continuation.resume(trip)
            }
            
            override fun onError(error: BookoviaError) {
                continuation.resumeWithException(error)
            }
        })
    }
    
    fun stopTrip() {
        bookovia.stopTrip(object : TripSummaryCallback {
            override fun onSuccess(summary: TripSummary) {
                Log.d("TripManager", "Trip completed: ${summary.distance} km")
                showTripSummary(summary)
            }
            
            override fun onError(error: BookoviaError) {
                Log.e("TripManager", "Failed to stop trip: ${error.message}")
            }
        })
    }
}

import { BookoviaSDK } from '@bookovia/react-native-sdk';

class TripManager {
  static async startTrip(metadata = {}) {
    try {
      const trip = await BookoviaSDK.startTrip({
        metadata: {
          driver_name: 'John Doe',
          vehicle_id: 'vehicle_123',
          purpose: 'delivery',
          ...metadata
        }
      });
      
      console.log('Trip started:', trip.id);
      return trip;
      
    } catch (error) {
      console.error('Failed to start trip:', error);
      throw error;
    }
  }
  
  static async stopTrip() {
    try {
      const summary = await BookoviaSDK.stopTrip();
      
      console.log(`Trip completed: ${summary.distance} km in ${summary.duration} minutes`);
      return summary;
      
    } catch (error) {
      console.error('Failed to stop trip:', error);
      throw error;
    }
  }
  
  static async getCurrentTrip() {
    try {
      return await BookoviaSDK.getCurrentTrip();
    } catch (error) {
      return null; // No active trip
    }
  }
}

// React Hook for trip management
import { useState, useEffect } from 'react';

export const useTrip = () => {
  const [currentTrip, setCurrentTrip] = useState(null);
  const [isTracking, setIsTracking] = useState(false);
  
  useEffect(() => {
    // Check for existing trip on mount
    TripManager.getCurrentTrip().then(setCurrentTrip);
    
    // Listen for trip events
    const tripListener = BookoviaSDK.addTripListener((trip) => {
      setCurrentTrip(trip);
      setIsTracking(trip.status === 'active');
    });
    
    return () => tripListener.remove();
  }, []);
  
  const startTrip = async (metadata) => {
    const trip = await TripManager.startTrip(metadata);
    setCurrentTrip(trip);
    setIsTracking(true);
    return trip;
  };
  
  const stopTrip = async () => {
    const summary = await TripManager.stopTrip();
    setCurrentTrip(null);
    setIsTracking(false);
    return summary;
  };
  
  return { currentTrip, isTracking, startTrip, stopTrip };
};

import 'package:bookovia_telematics/bookovia_telematics.dart';

class TripManager {
  static Future<Trip> startTrip({Map<String, dynamic>? metadata}) async {
    try {
      final trip = await BookoviaTelematics.startTrip(
        metadata: {
          'driver_name': 'John Doe',
          'vehicle_id': 'vehicle_123', 
          'purpose': 'delivery',
          ...?metadata
        },
      );
      
      print('Trip started: ${trip.id}');
      return trip;
      
    } catch (error) {
      print('Failed to start trip: $error');
      rethrow;
    }
  }
  
  static Future<TripSummary> stopTrip() async {
    try {
      final summary = await BookoviaTelematics.stopTrip();
      
      print('Trip completed: ${summary.distance} km in ${summary.duration} minutes');
      return summary;
      
    } catch (error) {
      print('Failed to stop trip: $error');
      rethrow;
    }
  }
  
  static Future<Trip?> getCurrentTrip() async {
    try {
      return await BookoviaTelematics.getCurrentTrip();
    } catch (error) {
      return null; // No active trip
    }
  }
}

// Flutter provider for trip state management
class TripProvider extends ChangeNotifier {
  Trip? _currentTrip;
  bool _isTracking = false;
  StreamSubscription<Trip>? _tripSubscription;
  
  Trip? get currentTrip => _currentTrip;
  bool get isTracking => _isTracking;
  
  TripProvider() {
    _initializeTrip();
  }
  
  void _initializeTrip() async {
    // Check for existing trip
    _currentTrip = await TripManager.getCurrentTrip();
    _isTracking = _currentTrip?.status == TripStatus.active;
    notifyListeners();
    
    // Listen for trip events
    _tripSubscription = BookoviaTelematics.tripStream.listen((trip) {
      _currentTrip = trip;
      _isTracking = trip.status == TripStatus.active;
      notifyListeners();
    });
  }
  
  Future<Trip> startTrip([Map<String, dynamic>? metadata]) async {
    final trip = await TripManager.startTrip(metadata: metadata);
    _currentTrip = trip;
    _isTracking = true;
    notifyListeners();
    return trip;
  }
  
  Future<TripSummary> stopTrip() async {
    final summary = await TripManager.stopTrip();
    _currentTrip = null;
    _isTracking = false;
    notifyListeners();
    return summary;
  }
  
  @override
  void dispose() {
    _tripSubscription?.cancel();
    super.dispose();
  }
}

import androidx.room.*
import androidx.work.*
import java.util.concurrent.TimeUnit

@Entity(tableName = "cached_locations")
data class CachedLocation(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val latitude: Double,
    val longitude: Double,
    val timestamp: Long,
    val tripId: String,
    val synced: Boolean = false
)

@Dao
interface LocationDao {
    @Insert
    suspend fun insertLocations(locations: List<CachedLocation>)
    
    @Query("SELECT * FROM cached_locations WHERE synced = 0 LIMIT 100")
    suspend fun getUnsyncedLocations(): List<CachedLocation>
    
    @Query("UPDATE cached_locations SET synced = 1 WHERE id IN (:ids)")
    suspend fun markAsSynced(ids: List<Long>)
    
    @Query("DELETE FROM cached_locations WHERE synced = 1 AND timestamp < :cutoff")
    suspend fun cleanupOldData(cutoff: Long)
}

class OfflineDataManager(private val context: Context) {
    private val bookovia = BookoviaSDK.getInstance(context)
    private val database = BookoviaDatabase.getInstance(context)
    
    suspend fun cacheLocationData(locations: List<LocationPoint>) {
        val cachedLocations = locations.map { location ->
            CachedLocation(
                latitude = location.latitude,
                longitude = location.longitude,
                timestamp = location.timestamp,
                tripId = location.tripId
            )
        }
        
        database.locationDao().insertLocations(cachedLocations)
    }
    
    fun scheduleSyncWork() {
        val syncWorkRequest = PeriodicWorkRequestBuilder<SyncWorker>(15, TimeUnit.MINUTES)
            .setConstraints(
                Constraints.Builder()
                    .setRequiredNetworkType(NetworkType.CONNECTED)
                    .build()
            )
            .build()
        
        WorkManager.getInstance(context)
            .enqueueUniquePeriodicWork(
                "location_sync",
                ExistingPeriodicWorkPolicy.KEEP,
                syncWorkRequest
            )
    }
}

class SyncWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {
    override suspend fun doWork(): Result {
        return try {
            val database = BookoviaDatabase.getInstance(applicationContext)
            val unsyncedLocations = database.locationDao().getUnsyncedLocations()
            
            if (unsyncedLocations.isNotEmpty()) {
                val locationData = unsyncedLocations.map { cached ->
                    LocationPoint(
                        latitude = cached.latitude,
                        longitude = cached.longitude,
                        timestamp = cached.timestamp,
                        tripId = cached.tripId
                    )
                }
                
                BookoviaSDK.getInstance(applicationContext).uploadLocationBatch(locationData)
                
                // Mark as synced
                database.locationDao().markAsSynced(unsyncedLocations.map { it.id })
            }
            
            Result.success()
        } catch (e: Exception) {
            Result.retry()
        }
    }
}

import AsyncStorage from '@react-native-async-storage/async-storage';
import NetInfo from '@react-native-community/netinfo';
import { BookoviaSDK } from '@bookovia/react-native-sdk';

class OfflineDataManager {
  static CACHE_KEY = 'bookovia_cached_locations';
  static MAX_CACHE_SIZE = 1000;
  
  static async cacheLocationData(locations) {
    try {
      const existingData = await this.getCachedLocations();
      const newData = [...existingData, ...locations.map(loc => ({
        ...loc,
        cached_at: Date.now(),
        synced: false
      }))];
      
      // Keep only latest data if cache is too large
      const trimmedData = newData.slice(-this.MAX_CACHE_SIZE);
      
      await AsyncStorage.setItem(this.CACHE_KEY, JSON.stringify(trimmedData));
    } catch (error) {
      console.error('Failed to cache location data:', error);
    }
  }
  
  static async getCachedLocations() {
    try {
      const data = await AsyncStorage.getItem(this.CACHE_KEY);
      return data ? JSON.parse(data) : [];
    } catch (error) {
      return [];
    }
  }
  
  static async syncCachedData() {
    const netInfo = await NetInfo.fetch();
    
    if (!netInfo.isConnected) {
      console.log('No network connection, skipping sync');
      return;
    }
    
    try {
      const cachedData = await this.getCachedLocations();
      const unsyncedData = cachedData.filter(item => !item.synced);
      
      if (unsyncedData.length === 0) {
        return;
      }
      
      // Sync in batches of 50
      const batchSize = 50;
      for (let i = 0; i < unsyncedData.length; i += batchSize) {
        const batch = unsyncedData.slice(i, i + batchSize);
        
        try {
          await BookoviaSDK.uploadLocationBatch(batch);
          
          // Mark batch as synced
          const updatedData = cachedData.map(item => {
            if (batch.find(b => b.timestamp === item.timestamp)) {
              return { ...item, synced: true };
            }
            return item;
          });
          
          await AsyncStorage.setItem(this.CACHE_KEY, JSON.stringify(updatedData));
          
        } catch (batchError) {
          console.error('Batch sync failed:', batchError);
          break; // Stop syncing on error
        }
      }
      
    } catch (error) {
      console.error('Sync failed:', error);
    }
  }
  
  static startPeriodicSync() {
    // Sync every 5 minutes when app is active
    return setInterval(() => {
      this.syncCachedData();
    }, 5 * 60 * 1000);
  }
  
  static async cleanupOldData() {
    try {
      const cachedData = await this.getCachedLocations();
      const cutoff = Date.now() - (7 * 24 * 60 * 60 * 1000); // 7 days
      
      const cleanData = cachedData.filter(item => 
        !item.synced || item.cached_at > cutoff
      );
      
      await AsyncStorage.setItem(this.CACHE_KEY, JSON.stringify(cleanData));
    } catch (error) {
      console.error('Cleanup failed:', error);
    }
  }
}

// React Hook for offline support
export const useOfflineSync = () => {
  const [isOnline, setIsOnline] = useState(true);
  const [pendingSync, setPendingSync] = useState(0);
  
  useEffect(() => {
    const unsubscribe = NetInfo.addEventListener(state => {
      setIsOnline(state.isConnected);
      
      if (state.isConnected) {
        // Auto-sync when coming back online
        OfflineDataManager.syncCachedData();
      }
    });
    
    // Periodic sync interval
    const syncInterval = OfflineDataManager.startPeriodicSync();
    
    return () => {
      unsubscribe();
      clearInterval(syncInterval);
    };
  }, []);
  
  const manualSync = async () => {
    await OfflineDataManager.syncCachedData();
  };
  
  return { isOnline, pendingSync, manualSync };
};

import 'package:sqflite/sqflite.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:bookovia_telematics/bookovia_telematics.dart';

class OfflineDataManager {
  static Database? _database;
  static const String tableName = 'cached_locations';
  
  static Future<Database> get database async {
    _database ??= await _initDatabase();
    return _database!;
  }
  
  static Future<Database> _initDatabase() async {
    final db = await openDatabase(
      'bookovia_cache.db',
      version: 1,
      onCreate: (db, version) {
        return db.execute('''
          CREATE TABLE $tableName (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            latitude REAL NOT NULL,
            longitude REAL NOT NULL,
            timestamp INTEGER NOT NULL,
            trip_id TEXT NOT NULL,
            synced INTEGER NOT NULL DEFAULT 0
          )
        ''');
      },
    );
    return db;
  }
  
  static Future<void> cacheLocationData(List<LocationPoint> locations) async {
    final db = await database;
    
    final batch = db.batch();
    for (final location in locations) {
      batch.insert(tableName, {
        'latitude': location.latitude,
        'longitude': location.longitude,
        'timestamp': location.timestamp.millisecondsSinceEpoch,
        'trip_id': location.tripId,
        'synced': 0,
      });
    }
    
    await batch.commit(noResult: true);
  }
  
  static Future<List<Map<String, dynamic>>> getUnsyncedLocations() async {
    final db = await database;
    
    return await db.query(
      tableName,
      where: 'synced = ?',
      whereArgs: [0],
      limit: 100,
      orderBy: 'timestamp ASC',
    );
  }
  
  static Future<void> markAsSynced(List<int> ids) async {
    final db = await database;
    
    final batch = db.batch();
    for (final id in ids) {
      batch.update(
        tableName,
        {'synced': 1},
        where: 'id = ?',
        whereArgs: [id],
      );
    }
    
    await batch.commit(noResult: true);
  }
  
  static Future<void> syncCachedData() async {
    final connectivityResult = await Connectivity().checkConnectivity();
    
    if (connectivityResult == ConnectivityResult.none) {
      print('No network connection, skipping sync');
      return;
    }
    
    try {
      final unsyncedData = await getUnsyncedLocations();
      
      if (unsyncedData.isEmpty) return;
      
      final locationData = unsyncedData.map((row) => LocationPoint(
        latitude: row['latitude'],
        longitude: row['longitude'],
        timestamp: DateTime.fromMillisecondsSinceEpoch(row['timestamp']),
        tripId: row['trip_id'],
      )).toList();
      
      await BookoviaTelematics.uploadLocationBatch(locationData);
      
      // Mark as synced
      final ids = unsyncedData.map((row) => row['id'] as int).toList();
      await markAsSynced(ids);
      
      print('Synced ${locationData.length} cached locations');
      
    } catch (error) {
      print('Sync failed: $error');
    }
  }
  
  static Future<void> startPeriodicSync() async {
    Timer.periodic(Duration(minutes: 5), (timer) {
      syncCachedData();
    });
    
    // Also sync when connectivity changes
    Connectivity().onConnectivityChanged.listen((result) {
      if (result != ConnectivityResult.none) {
        syncCachedData();
      }
    });
  }
  
  static Future<void> cleanupOldData() async {
    final db = await database;
    final cutoff = DateTime.now()
        .subtract(Duration(days: 7))
        .millisecondsSinceEpoch;
    
    await db.delete(
      tableName,
      where: 'synced = 1 AND timestamp < ?',
      whereArgs: [cutoff],
    );
  }
}

import okhttp3.*
import org.json.JSONObject
import java.util.concurrent.TimeUnit

class BookoviaWebSocket(private val apiKey: String) : WebSocketListener() {
    private var webSocket: WebSocket? = null
    private val client = OkHttpClient.Builder()
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS)
        .build()
    
    fun connect() {
        val request = Request.Builder()
            .url("wss://api.bookovia.com/v1/streaming")
            .addHeader("Authorization", "Bearer $apiKey")
            .build()
        
        webSocket = client.newWebSocket(request, this)
    }
    
    fun subscribe(channels: List<String>, filters: Map<String, Any> = emptyMap()) {
        val subscription = JSONObject().apply {
            put("type", "subscribe")
            put("channels", channels)
            put("filters", JSONObject(filters))
        }
        
        webSocket?.send(subscription.toString())
    }
    
    override fun onOpen(webSocket: WebSocket, response: Response) {
        Log.d("WebSocket", "Connected")
        authenticateAndSubscribe()
    }
    
    override fun onMessage(webSocket: WebSocket, text: String) {
        try {
            val json = JSONObject(text)
            val type = json.getString("type")
            
            when (type) {
                "location_update" -> handleLocationUpdate(json)
                "safety_event" -> handleSafetyEvent(json)
                "trip_update" -> handleTripUpdate(json)
            }
        } catch (e: Exception) {
            Log.e("WebSocket", "Message parsing error", e)
        }
    }
    
    override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
        Log.d("WebSocket", "Disconnected: $reason ($code)")
        attemptReconnect()
    }
    
    override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
        Log.e("WebSocket", "Connection failed", t)
        attemptReconnect()
    }
    
    private fun authenticateAndSubscribe() {
        subscribe(listOf("locations", "safety_events", "trip_updates"))
    }
    
    private fun attemptReconnect() {
        // Implement exponential backoff reconnection
        Handler(Looper.getMainLooper()).postDelayed({
            connect()
        }, 5000)
    }
}

import { BookoviaWebSocket } from '@bookovia/react-native-sdk';

class RealtimeManager {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.websocket = null;
    this.isConnected = false;
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 10;
  }
  
  connect() {
    this.websocket = new BookoviaWebSocket({
      apiKey: this.apiKey,
      url: 'wss://api.bookovia.com/v1/streaming',
      onOpen: () => {
        console.log('WebSocket connected');
        this.isConnected = true;
        this.reconnectAttempts = 0;
        this.authenticateAndSubscribe();
      },
      onMessage: (data) => {
        this.handleMessage(data);
      },
      onClose: () => {
        console.log('WebSocket disconnected');
        this.isConnected = false;
        this.attemptReconnect();
      },
      onError: (error) => {
        console.error('WebSocket error:', error);
      }
    });
    
    this.websocket.connect();
  }
  
  subscribe(channels, filters = {}) {
    if (this.isConnected) {
      this.websocket.send({
        type: 'subscribe',
        channels,
        filters
      });
    }
  }
  
  handleMessage(data) {
    switch (data.type) {
      case 'location_update':
        this.handleLocationUpdate(data);
        break;
      case 'safety_event':
        this.handleSafetyEvent(data);
        break;
      case 'trip_update':
        this.handleTripUpdate(data);
        break;
    }
  }
  
  authenticateAndSubscribe() {
    this.subscribe(['locations', 'safety_events', 'trip_updates']);
  }
  
  attemptReconnect() {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      this.reconnectAttempts++;
      const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
      
      setTimeout(() => {
        this.connect();
      }, delay);
    }
  }
  
  disconnect() {
    if (this.websocket) {
      this.websocket.close();
      this.websocket = null;
      this.isConnected = false;
    }
  }
}

// React Hook for real-time data
export const useRealtimeData = (apiKey) => {
  const [realtimeData, setRealtimeData] = useState({
    locations: [],
    safetyEvents: [],
    tripUpdates: []
  });
  
  const [connectionStatus, setConnectionStatus] = useState('disconnected');
  
  useEffect(() => {
    const manager = new RealtimeManager(apiKey);
    
    manager.handleLocationUpdate = (data) => {
      setRealtimeData(prev => ({
        ...prev,
        locations: [...prev.locations.slice(-99), data] // Keep last 100
      }));
    };
    
    manager.handleSafetyEvent = (data) => {
      setRealtimeData(prev => ({
        ...prev,
        safetyEvents: [...prev.safetyEvents.slice(-49), data] // Keep last 50
      }));
    };
    
    manager.connect();
    
    return () => manager.disconnect();
  }, [apiKey]);
  
  return { realtimeData, connectionStatus };
};

import 'package:web_socket_channel/web_socket_channel.dart';
import 'package:bookovia_telematics/bookovia_telematics.dart';

class BookoviaWebSocket {
  final String apiKey;
  WebSocketChannel? _channel;
  StreamController<Map<String, dynamic>>? _messageController;
  Timer? _reconnectTimer;
  int _reconnectAttempts = 0;
  static const int maxReconnectAttempts = 10;
  
  BookoviaWebSocket({required this.apiKey});
  
  Stream<Map<String, dynamic>> get messageStream => 
      _messageController?.stream ?? Stream.empty();
  
  Future<void> connect() async {
    try {
      _messageController ??= StreamController<Map<String, dynamic>>.broadcast();
      
      _channel = WebSocketChannel.connect(
        Uri.parse('wss://api.bookovia.com/v1/streaming'),
        protocols: null,
      );
      
      // Send authentication
      _channel!.sink.add(jsonEncode({
        'type': 'auth',
        'api_key': apiKey,
      }));
      
      // Listen for messages
      _channel!.stream.listen(
        (message) {
          try {
            final data = jsonDecode(message) as Map<String, dynamic>;
            _messageController!.add(data);
            _handleMessage(data);
          } catch (e) {
            print('Message parsing error: $e');
          }
        },
        onDone: () {
          print('WebSocket connection closed');
          _attemptReconnect();
        },
        onError: (error) {
          print('WebSocket error: $error');
          _attemptReconnect();
        },
      );
      
      _reconnectAttempts = 0;
      print('WebSocket connected');
      
      // Subscribe to channels after connection
      await _authenticateAndSubscribe();
      
    } catch (e) {
      print('WebSocket connection failed: $e');
      _attemptReconnect();
    }
  }
  
  void subscribe(List<String> channels, {Map<String, dynamic>? filters}) {
    final subscription = {
      'type': 'subscribe',
      'channels': channels,
      if (filters != null) 'filters': filters,
    };
    
    _channel?.sink.add(jsonEncode(subscription));
  }
  
  void _handleMessage(Map<String, dynamic> data) {
    final type = data['type'] as String?;
    
    switch (type) {
      case 'location_update':
        _handleLocationUpdate(data);
        break;
      case 'safety_event':
        _handleSafetyEvent(data);
        break;
      case 'trip_update':
        _handleTripUpdate(data);
        break;
    }
  }
  
  Future<void> _authenticateAndSubscribe() async {
    subscribe(['locations', 'safety_events', 'trip_updates']);
  }
  
  void _attemptReconnect() {
    if (_reconnectAttempts < maxReconnectAttempts) {
      _reconnectAttempts++;
      final delay = Duration(
        milliseconds: math.min(1000 * math.pow(2, _reconnectAttempts).toInt(), 30000)
      );
      
      _reconnectTimer = Timer(delay, () {
        connect();
      });
    }
  }
  
  void disconnect() {
    _reconnectTimer?.cancel();
    _channel?.sink.close();
    _messageController?.close();
    _channel = null;
    _messageController = null;
  }
}

// Provider for real-time data
class RealtimeProvider extends ChangeNotifier {
  final BookoviaWebSocket _websocket;
  StreamSubscription? _messageSubscription;
  
  List<LocationPoint> _locations = [];
  List<SafetyEvent> _safetyEvents = [];
  List<TripUpdate> _tripUpdates = [];
  
  List<LocationPoint> get locations => _locations;
  List<SafetyEvent> get safetyEvents => _safetyEvents;
  List<TripUpdate> get tripUpdates => _tripUpdates;
  
  RealtimeProvider({required String apiKey}) 
      : _websocket = BookoviaWebSocket(apiKey: apiKey) {
    _initializeWebSocket();
  }
  
  void _initializeWebSocket() {
    _websocket.connect();
    
    _messageSubscription = _websocket.messageStream.listen((data) {
      _handleRealtimeData(data);
      notifyListeners();
    });
  }
  
  void _handleRealtimeData(Map<String, dynamic> data) {
    switch (data['type']) {
      case 'location_update':
        final location = LocationPoint.fromJson(data);
        _locations = [..._locations.take(99), location]; // Keep last 100
        break;
      case 'safety_event':
        final event = SafetyEvent.fromJson(data);
        _safetyEvents = [..._safetyEvents.take(49), event]; // Keep last 50
        break;
      case 'trip_update':
        final update = TripUpdate.fromJson(data);
        _tripUpdates = [..._tripUpdates.take(29), update]; // Keep last 30
        break;
    }
  }
  
  @override
  void dispose() {
    _messageSubscription?.cancel();
    _websocket.disconnect();
    super.dispose();
  }
}