Upload Single Location

// Continuous GPS tracking for mobile apps
class MobileGPSTracker {
  constructor(client, tripId) {
    this.client = client;
    this.tripId = tripId;
    this.watchId = null;
    this.lastUpload = 0;
    this.uploadInterval = 5000; // 5 seconds
  }
  
  startTracking() {
    if (!navigator.geolocation) {
      throw new Error('Geolocation not supported');
    }
    
    this.watchId = navigator.geolocation.watchPosition(
      (position) => this.handlePosition(position),
      (error) => this.handleError(error),
      {
        enableHighAccuracy: true,
        timeout: 10000,
        maximumAge: 0
      }
    );
  }
  
  async handlePosition(position) {
    const now = Date.now();
    
    // Rate limiting
    if (now - this.lastUpload < this.uploadInterval) {
      return;
    }
    
    try {
      const result = await this.client.locations.uploadSingle(this.tripId, {
        latitude: position.coords.latitude,
        longitude: position.coords.longitude,
        timestamp: new Date().toISOString(),
        speed_kmh: (position.coords.speed || 0) * 3.6,
        heading: position.coords.heading,
        accuracy_meters: position.coords.accuracy,
        altitude_meters: position.coords.altitude,
        device_info: {
          device_id: this.getDeviceId(),
          signal_strength: this.getNetworkStrength()
        }
      });
      
      this.lastUpload = now;
      
      // Update UI with real-time analytics
      this.updateDashboard(result.trip_analytics);
      
      // Handle safety alerts
      result.events_detected.forEach(event => {
        this.showSafetyAlert(event);
      });
      
    } catch (error) {
      console.error('Location upload failed:', error);
    }
  }
  
  stopTracking() {
    if (this.watchId) {
      navigator.geolocation.clearWatch(this.watchId);
      this.watchId = null;
    }
  }
}

# Real-time fleet monitoring system
import asyncio
import json
from datetime import datetime, timedelta

class FleetMonitor:
    def __init__(self, client):
        self.client = client
        self.active_vehicles = {}
        self.alert_thresholds = {
            'speed_limit': 80,  # km/h
            'harsh_event_count': 3,  # per hour
            'low_battery': 20  # percentage
        }
    
    async def process_vehicle_location(self, vehicle_id, trip_id, gps_data):
        """Process incoming GPS data from vehicle"""
        try:
            result = await self.client.locations.upload_single(
                trip_id=trip_id,
                latitude=gps_data['lat'],
                longitude=gps_data['lng'],
                timestamp=datetime.utcnow().isoformat() + 'Z',
                speed_kmh=gps_data['speed'],
                heading=gps_data['heading'],
                battery_level=gps_data.get('battery_level', 100),
                device_info={
                    'device_id': vehicle_id,
                    'signal_strength': gps_data.get('signal_strength', -70)
                }
            )
            
            # Update vehicle status
            self.active_vehicles[vehicle_id] = {
                'last_update': datetime.utcnow(),
                'location': (gps_data['lat'], gps_data['lng']),
                'speed': gps_data['speed'],
                'safety_score': result.trip_analytics.current_safety_score,
                'battery_level': gps_data.get('battery_level', 100)
            }
            
            # Check for alerts
            await self.check_vehicle_alerts(vehicle_id, result)
            
            return result
            
        except Exception as e:
            print(f"Error processing location for vehicle {vehicle_id}: {e}")
    
    async def check_vehicle_alerts(self, vehicle_id, location_result):
        """Check for various alert conditions"""
        vehicle_status = self.active_vehicles[vehicle_id]
        
        # Speed alerts
        if vehicle_status['speed'] > self.alert_thresholds['speed_limit']:
            await self.send_alert('speeding', vehicle_id, {
                'speed': vehicle_status['speed'],
                'limit': self.alert_thresholds['speed_limit']
            })
        
        # Safety event alerts
        for event in location_result.events_detected:
            if event.severity in ['high', 'critical']:
                await self.send_alert('safety_event', vehicle_id, {
                    'event_type': event.event_type,
                    'severity': event.severity,
                    'location': vehicle_status['location']
                })
        
        # Battery alerts
        if vehicle_status['battery_level'] < self.alert_thresholds['low_battery']:
            await self.send_alert('low_battery', vehicle_id, {
                'battery_level': vehicle_status['battery_level']
            })
    
    async def send_alert(self, alert_type, vehicle_id, data):
        """Send alert to fleet manager"""
        alert = {
            'type': alert_type,
            'vehicle_id': vehicle_id,
            'timestamp': datetime.utcnow().isoformat(),
            'data': data
        }
        
        print(f"🚨 FLEET ALERT: {json.dumps(alert, indent=2)}")
        # Integration with notification systems would go here

# Usage
monitor = FleetMonitor(client)

# Simulate incoming vehicle data
vehicle_data = {
    'lat': 40.7128,
    'lng': -74.0060,
    'speed': 85.0,  # Over speed limit
    'heading': 90,
    'battery_level': 15  # Low battery
}

await monitor.process_vehicle_location('vehicle_123', 'trip_456', vehicle_data)

// Emergency response system with location tracking
package main

import (
    "context"
    "fmt"
    "log"
    "time"
    "github.com/bookovia/go-sdk"
)

type EmergencyResponse struct {
    client          *bookovia.Client
    emergencyTrips  map[string]*EmergencyTrip
    alertChannel    chan SafetyAlert
}

type EmergencyTrip struct {
    TripID       string
    VehicleID    string
    StartTime    time.Time
    LastLocation *bookovia.Location
    EventCount   int
}

type SafetyAlert struct {
    TripID    string
    VehicleID string
    EventType string
    Severity  string
    Location  *bookovia.Location
    Timestamp time.Time
}

func NewEmergencyResponse(client *bookovia.Client) *EmergencyResponse {
    return &EmergencyResponse{
        client:         client,
        emergencyTrips: make(map[string]*EmergencyTrip),
        alertChannel:   make(chan SafetyAlert, 100),
    }
}

func (e *EmergencyResponse) TrackEmergencyVehicle(ctx context.Context, tripID, vehicleID string, locations <-chan *bookovia.Location) {
    emergencyTrip := &EmergencyTrip{
        TripID:    tripID,
        VehicleID: vehicleID,
        StartTime: time.Now(),
    }
    
    e.emergencyTrips[tripID] = emergencyTrip
    
    for location := range locations {
        result, err := e.client.Locations.UploadSingle(ctx, &bookovia.UploadSingleRequest{
            TripID:         tripID,
            Latitude:       location.Latitude,
            Longitude:      location.Longitude,
            Timestamp:      location.Timestamp,
            SpeedKmh:       location.SpeedKmh,
            AccuracyMeters: location.AccuracyMeters,
            DeviceInfo: &bookovia.DeviceInfo{
                DeviceID: vehicleID,
            },
        })
        
        if err != nil {
            log.Printf("Failed to upload emergency vehicle location: %v", err)
            continue
        }
        
        emergencyTrip.LastLocation = location
        
        // Monitor for critical safety events
        for _, event := range result.EventsDetected {
            if event.Severity == "critical" {
                alert := SafetyAlert{
                    TripID:    tripID,
                    VehicleID: vehicleID,
                    EventType: event.EventType,
                    Severity:  event.Severity,
                    Location:  location,
                    Timestamp: time.Now(),
                }
                
                select {
                case e.alertChannel <- alert:
                case <-ctx.Done():
                    return
                }
            }
        }
        
        emergencyTrip.EventCount += len(result.EventsDetected)
    }
}

func (e *EmergencyResponse) ProcessAlerts(ctx context.Context) {
    for {
        select {
        case alert := <-e.alertChannel:
            e.handleEmergencyAlert(alert)
        case <-ctx.Done():
            return
        }
    }
}

func (e *EmergencyResponse) handleEmergencyAlert(alert SafetyAlert) {
    log.Printf("🚨 EMERGENCY VEHICLE ALERT: %s - %s at (%.6f, %.6f)",
        alert.VehicleID, alert.EventType, 
        alert.Location.Latitude, alert.Location.Longitude)
    
    // Notify dispatch center
    // Send alerts to supervisors
    // Update incident management system
}

func main() {
    client := bookovia.NewClient("bkv_test_your_api_key")
    emergency := NewEmergencyResponse(client)
    
    ctx := context.Background()
    
    // Start alert processing
    go emergency.ProcessAlerts(ctx)
    
    // Simulate emergency vehicle tracking
    locationChannel := make(chan *bookovia.Location)
    go emergency.TrackEmergencyVehicle(ctx, "emergency_trip_001", "ambulance_01", locationChannel)
    
    // Send test locations
    testLocations := []*bookovia.Location{
        {Latitude: 40.7128, Longitude: -74.0060, SpeedKmh: 80, Timestamp: time.Now()},
        {Latitude: 40.7135, Longitude: -74.0055, SpeedKmh: 90, Timestamp: time.Now().Add(time.Second * 5)},
    }
    
    for _, loc := range testLocations {
        locationChannel <- loc
        time.Sleep(time.Second * 5)
    }
    
    close(locationChannel)
}