1152 lines
41 KiB
Dart
1152 lines
41 KiB
Dart
import 'dart:async';
|
||
import 'dart:convert';
|
||
import 'dart:math';
|
||
import 'package:Intaleq/views/widgets/error_snakbar.dart';
|
||
import 'package:flutter/foundation.dart';
|
||
import 'package:flutter/material.dart';
|
||
import 'package:flutter/services.dart';
|
||
import 'package:geolocator/geolocator.dart';
|
||
import 'package:get/get.dart';
|
||
import 'package:maplibre_gl/maplibre_gl.dart';
|
||
import 'package:http/http.dart' as http;
|
||
import '../../../constant/box_name.dart';
|
||
import '../../../constant/links.dart';
|
||
import '../../../controller/functions/crud.dart';
|
||
import '../../../controller/functions/tts.dart';
|
||
import '../../../controller/home/decode_polyline_isolate.dart';
|
||
import '../../../main.dart';
|
||
import '../../../print.dart';
|
||
import 'dart:ui';
|
||
|
||
import '../../../services/offline_map_service.dart';
|
||
|
||
class NavigationController extends GetxController
|
||
with GetSingleTickerProviderStateMixin {
|
||
// ==========================================================================
|
||
// ── Tunables ──────────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
/// How often we snapshot the current position into the local buffer.
|
||
static const Duration _recordInterval = Duration(seconds: 3);
|
||
|
||
/// How often we flush the buffer and POST it to the server.
|
||
static const Duration _uploadInterval = Duration(minutes: 2);
|
||
|
||
/// Minimum metres the device must move before we bother recording a point.
|
||
static const double _minMoveToRecord = 10.0;
|
||
|
||
/// Minimum metres the device must move between general location ticks.
|
||
static const double _minMoveToProcess = 2.0;
|
||
|
||
/// Metres off-route before the auto-recalculate countdown starts.
|
||
static const double _offRouteThresholdM = 25.0;
|
||
|
||
/// Seconds the user must remain off-route before auto-recalculate fires.
|
||
static const int _offRouteTriggerSeconds = 6;
|
||
|
||
// ==========================================================================
|
||
// ── Map state ─────────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
bool isLoading = false;
|
||
MaplibreMapController? mapController;
|
||
bool isStyleLoaded = false;
|
||
final TextEditingController placeDestinationController =
|
||
TextEditingController();
|
||
|
||
LatLng? myLocation;
|
||
double heading = 0.0;
|
||
|
||
/// Smoothed heading used for the car icon and camera bearing.
|
||
/// Updated every tick via angle-aware lerp to eliminate snap/jitter.
|
||
double _smoothedHeading = 0.0;
|
||
|
||
// Animation for smooth tracking
|
||
AnimationController? _animController;
|
||
LatLng? _oldLoc;
|
||
LatLng? _targetLoc;
|
||
|
||
double currentSpeed = 0.0; // km/h
|
||
double totalDistance = 0.0; // metres accumulated this session
|
||
|
||
// MapLibre objects
|
||
Symbol? carSymbol;
|
||
Symbol? originSymbol;
|
||
Symbol? destinationSymbol;
|
||
Line? remainingRouteLine;
|
||
Line? traveledRouteLine;
|
||
|
||
// General location polling
|
||
Timer? _locationUpdateTimer;
|
||
LatLng? _lastProcessedLocation;
|
||
|
||
// Search
|
||
List<dynamic> placesDestination = [];
|
||
Timer? _debounce;
|
||
|
||
// Route
|
||
LatLng? _finalDestination;
|
||
List<Map<String, dynamic>> routeSteps = [];
|
||
List<LatLng> _fullRouteCoordinates = [];
|
||
int _lastTraveledIndexInFullRoute = 0;
|
||
|
||
// Navigation guidance
|
||
bool _nextInstructionSpoken = false;
|
||
String currentInstruction = "";
|
||
String nextInstruction = "";
|
||
int currentStepIndex = 0;
|
||
String distanceToNextStep = "";
|
||
String totalDistanceRemaining = "";
|
||
String estimatedTimeRemaining = "";
|
||
|
||
// Stored route totals (for ETA re-calculation)
|
||
double _routeTotalDistanceM = 0;
|
||
double _routeTotalDurationS = 0;
|
||
|
||
// Camera
|
||
bool isNavigating = false;
|
||
bool _cameraLockedToUser = true;
|
||
bool _mapReady = false; // true only after layout has settled
|
||
|
||
// ==========================================================================
|
||
// ── Off-route auto-recalculate ────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
/// Wall-clock time when the user first went more than [_offRouteThresholdM]
|
||
/// metres away from the nearest route point. Null means on-route.
|
||
DateTime? _offRouteStartTime;
|
||
|
||
/// True while an auto-recalculate triggered from off-route detection is in
|
||
/// progress — prevents a second trigger from firing.
|
||
bool _autoRecalcInProgress = false;
|
||
|
||
// ==========================================================================
|
||
// ── Batch location tracking ───────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
/// In-memory ring buffer — points accumulate here every 3 s.
|
||
final List<Map<String, dynamic>> _trackBuffer = [];
|
||
|
||
Timer? _recordTimer;
|
||
Timer? _uploadBatchTimer;
|
||
|
||
/// Last position that was written to the buffer (for distance gate).
|
||
LatLng? _lastBufferedLocation;
|
||
DateTime? _lastBufferedTime;
|
||
|
||
/// Last position used to accumulate `totalDistance`.
|
||
LatLng? _lastDistanceLocation;
|
||
|
||
// ==========================================================================
|
||
// ── Speed-adaptive camera ─────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
double get _targetZoom {
|
||
if (currentSpeed < 15) return 19.0;
|
||
if (currentSpeed < 40) return 18.0;
|
||
if (currentSpeed < 70) return 17.0;
|
||
if (currentSpeed < 100) return 16.0;
|
||
return 15.0;
|
||
}
|
||
|
||
double get _targetTilt {
|
||
if (currentSpeed < 10) return 0.0;
|
||
if (currentSpeed < 40) return 40.0;
|
||
return 55.0;
|
||
}
|
||
|
||
static final String _routeApiBaseUrl =
|
||
"${AppLink.routesOsm}/route/v1/driving";
|
||
|
||
// ==========================================================================
|
||
// ── Lifecycle ─────────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
@override
|
||
void onInit() {
|
||
super.onInit();
|
||
_animController = AnimationController(
|
||
vsync: this, duration: const Duration(milliseconds: 1000));
|
||
_animController!.addListener(() {
|
||
if (_oldLoc != null && _targetLoc != null && _mapReady) {
|
||
final t = _animController!.value;
|
||
final lat = lerpDouble(_oldLoc!.latitude, _targetLoc!.latitude, t)!;
|
||
final lng = lerpDouble(_oldLoc!.longitude, _targetLoc!.longitude, t)!;
|
||
myLocation = LatLng(lat, lng);
|
||
|
||
if (isStyleLoaded) {
|
||
_updateCarMarker();
|
||
if (_fullRouteCoordinates.isNotEmpty && _cameraLockedToUser) {
|
||
animateCameraToPosition(myLocation!,
|
||
bearing: _smoothedHeading,
|
||
zoom: _targetZoom,
|
||
tilt: _targetTilt);
|
||
}
|
||
}
|
||
}
|
||
});
|
||
_initialize();
|
||
}
|
||
|
||
Future<void> _initialize() async {
|
||
await _getCurrentLocationAndStartUpdates();
|
||
}
|
||
|
||
@override
|
||
void onClose() {
|
||
_locationUpdateTimer?.cancel();
|
||
_recordTimer?.cancel();
|
||
_uploadBatchTimer?.cancel();
|
||
_debounce?.cancel();
|
||
_animController?.dispose();
|
||
mapController?.dispose();
|
||
placeDestinationController.dispose();
|
||
|
||
// Final flush before closing so no points are lost
|
||
_flushBufferToServer();
|
||
super.onClose();
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Map callbacks ─────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
void onMapCreated(MaplibreMapController controller) {
|
||
mapController = controller;
|
||
}
|
||
|
||
Future<void> onStyleLoaded() async {
|
||
isStyleLoaded = true;
|
||
await _loadCustomIcons();
|
||
|
||
// Wait one full frame for the native MapLibre view to finish layout.
|
||
// Without this, ANY animateCamera call throws std::domain_error on iOS
|
||
// because the view still has zero pixel dimensions at this point.
|
||
WidgetsBinding.instance.addPostFrameCallback((_) async {
|
||
await Future.delayed(const Duration(milliseconds: 300));
|
||
if (!_mapReady) {
|
||
_mapReady = true;
|
||
if (myLocation != null) {
|
||
animateCameraToPosition(myLocation!);
|
||
_updateCarMarker();
|
||
}
|
||
if (_fullRouteCoordinates.isNotEmpty) {
|
||
_updatePolylinesSets([], _fullRouteCoordinates);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
Future<void> onMapLongPressed(Point<double> point, LatLng tappedPoint) async {
|
||
HapticFeedback.mediumImpact();
|
||
Get.dialog(
|
||
AlertDialog(
|
||
shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
|
||
title: const Text('بدء الملاحة؟',
|
||
style: TextStyle(fontWeight: FontWeight.bold)),
|
||
content: const Text('هل تريد الذهاب إلى هذا الموقع؟'),
|
||
actions: [
|
||
TextButton(
|
||
child: const Text('إلغاء', style: TextStyle(color: Colors.grey)),
|
||
onPressed: () => Get.back(),
|
||
),
|
||
ElevatedButton(
|
||
style: ElevatedButton.styleFrom(
|
||
backgroundColor: const Color(0xFF0D47A1),
|
||
shape: RoundedRectangleBorder(
|
||
borderRadius: BorderRadius.circular(12)),
|
||
),
|
||
child:
|
||
const Text('اذهب الآن', style: TextStyle(color: Colors.white)),
|
||
onPressed: () {
|
||
Get.back();
|
||
startNavigationTo(tappedPoint, infoWindowTitle: 'الموقع المحدد');
|
||
},
|
||
),
|
||
],
|
||
),
|
||
);
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Location polling (every second) ──────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
Future<void> _getCurrentLocationAndStartUpdates() async {
|
||
try {
|
||
final position = await Geolocator.getCurrentPosition(
|
||
desiredAccuracy: LocationAccuracy.high);
|
||
myLocation = LatLng(position.latitude, position.longitude);
|
||
_smoothedHeading = position.heading; // seed so first lerp is instant
|
||
update();
|
||
if (isStyleLoaded) animateCameraToPosition(myLocation!);
|
||
_startLocationTimer();
|
||
_startBatchTimers(); // ← start tracking as soon as we have a fix
|
||
} catch (e) {
|
||
Log.print("Error getting initial location: $e");
|
||
}
|
||
}
|
||
|
||
void _startLocationTimer() {
|
||
_locationUpdateTimer?.cancel();
|
||
_locationUpdateTimer =
|
||
Timer.periodic(const Duration(seconds: 1), (_) => _tick());
|
||
}
|
||
|
||
Future<void> _tick() async {
|
||
try {
|
||
final position = await Geolocator.getCurrentPosition(
|
||
desiredAccuracy: LocationAccuracy.high);
|
||
final newLoc = LatLng(position.latitude, position.longitude);
|
||
|
||
// Gate: ignore micro-jitter
|
||
if (_lastProcessedLocation != null) {
|
||
final d = Geolocator.distanceBetween(
|
||
newLoc.latitude,
|
||
newLoc.longitude,
|
||
_lastProcessedLocation!.latitude,
|
||
_lastProcessedLocation!.longitude,
|
||
);
|
||
if (d < _minMoveToProcess) return;
|
||
}
|
||
|
||
// Accumulate session distance
|
||
if (_lastDistanceLocation != null) {
|
||
final d = Geolocator.distanceBetween(
|
||
_lastDistanceLocation!.latitude,
|
||
_lastDistanceLocation!.longitude,
|
||
newLoc.latitude,
|
||
newLoc.longitude,
|
||
);
|
||
if (d > 5.0) totalDistance += d;
|
||
}
|
||
_lastDistanceLocation = newLoc;
|
||
|
||
_oldLoc = myLocation ?? newLoc;
|
||
_targetLoc = newLoc;
|
||
_animController?.forward(from: 0.0);
|
||
|
||
_lastProcessedLocation = newLoc;
|
||
heading = position.heading;
|
||
|
||
// ── Smooth the heading with an angle-aware exponential lerp ──────────
|
||
// Factor 0.25 means ~75 % of the old angle is kept each tick, giving a
|
||
// ~4-tick (≈4 s) settling time — smooth enough to look fluid on screen
|
||
// while still reacting quickly to real turns.
|
||
_smoothedHeading = _lerpAngle(_smoothedHeading, heading, 0.25);
|
||
|
||
currentSpeed = position.speed * 3.6;
|
||
|
||
// Initial visual update if map is fresh
|
||
if (isStyleLoaded && myLocation == null) _updateCarMarker();
|
||
|
||
if (_fullRouteCoordinates.isNotEmpty) {
|
||
_updateTraveledPolylineSmart(newLoc);
|
||
_checkNavigationStep(newLoc);
|
||
_recomputeETA();
|
||
|
||
// ── Off-route auto-recalculate ─────────────────────────────────────
|
||
_checkOffRoute(newLoc);
|
||
}
|
||
|
||
update();
|
||
} catch (e) {
|
||
Log.print("Error occurred: $e");
|
||
}
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Heading utilities ─────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
/// Lerps from [from] to [to] by factor [t], correctly handling the 0/360
|
||
/// wrap-around so we never spin the wrong way (e.g. 350° → 10° goes +20°,
|
||
/// not −340°).
|
||
double _lerpAngle(double from, double to, double t) {
|
||
final double diff = ((to - from + 540.0) % 360.0) - 180.0;
|
||
return (from + diff * t + 360.0) % 360.0;
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Off-route detection ───────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
/// Called every tick while navigating. Measures the distance from [pos] to
|
||
/// the nearest upcoming route coordinate. If the driver stays more than
|
||
/// [_offRouteThresholdM] metres away for at least [_offRouteTriggerSeconds]
|
||
/// seconds, an automatic route recalculation is triggered.
|
||
void _checkOffRoute(LatLng pos) {
|
||
if (_autoRecalcInProgress || isLoading) return;
|
||
if (_fullRouteCoordinates.isEmpty) return;
|
||
|
||
// Search a window ahead of the last tracked index for the nearest point.
|
||
const int searchWindow = 80;
|
||
final int start = _lastTraveledIndexInFullRoute;
|
||
final int end = min(start + searchWindow, _fullRouteCoordinates.length);
|
||
|
||
double minDist = double.infinity;
|
||
for (int i = start; i < end; i++) {
|
||
final d = Geolocator.distanceBetween(
|
||
pos.latitude,
|
||
pos.longitude,
|
||
_fullRouteCoordinates[i].latitude,
|
||
_fullRouteCoordinates[i].longitude,
|
||
);
|
||
if (d < minDist) minDist = d;
|
||
}
|
||
|
||
if (minDist > _offRouteThresholdM) {
|
||
// Driver is off the route.
|
||
if (_offRouteStartTime == null) {
|
||
_offRouteStartTime = DateTime.now();
|
||
Log.print('⚠️ Off-route detected (${minDist.toStringAsFixed(0)} m). '
|
||
'Countdown started.');
|
||
} else {
|
||
final elapsed =
|
||
DateTime.now().difference(_offRouteStartTime!).inSeconds;
|
||
if (elapsed >= _offRouteTriggerSeconds) {
|
||
Log.print('🔄 Auto-recalculate triggered after ${elapsed}s '
|
||
'off-route (${minDist.toStringAsFixed(0)} m).');
|
||
_offRouteStartTime = null;
|
||
_autoRecalcInProgress = true;
|
||
recalculateRoute().then((_) => _autoRecalcInProgress = false);
|
||
}
|
||
}
|
||
} else {
|
||
// Back on (or close enough to) the route — reset the clock.
|
||
if (_offRouteStartTime != null) {
|
||
Log.print('✅ Back on route — off-route timer reset.');
|
||
}
|
||
_offRouteStartTime = null;
|
||
}
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Batch tracking: record every 3 s, upload every 2 min ─────────────────
|
||
// ==========================================================================
|
||
|
||
void _startBatchTimers() {
|
||
_recordTimer?.cancel();
|
||
_uploadBatchTimer?.cancel();
|
||
|
||
_recordTimer = Timer.periodic(_recordInterval, (_) => _recordToBuffer());
|
||
_uploadBatchTimer =
|
||
Timer.periodic(_uploadInterval, (_) => _flushBufferToServer());
|
||
|
||
Log.print('📍 Batch tracking started '
|
||
'(record: ${_recordInterval.inSeconds}s, '
|
||
'upload: ${_uploadInterval.inMinutes}min)');
|
||
}
|
||
|
||
void _stopBatchTimers() {
|
||
_recordTimer?.cancel();
|
||
_uploadBatchTimer?.cancel();
|
||
_recordTimer = null;
|
||
_uploadBatchTimer = null;
|
||
}
|
||
|
||
/// Called every 3 seconds. Adds one point to the buffer if the device
|
||
/// has moved enough OR if 60 s have elapsed since the last record.
|
||
void _recordToBuffer() {
|
||
if (myLocation == null) return;
|
||
if (myLocation!.latitude == 0 && myLocation!.longitude == 0) return;
|
||
|
||
final now = DateTime.now();
|
||
|
||
// Distance gate
|
||
final distFromLast = _lastBufferedLocation == null
|
||
? 999.0
|
||
: Geolocator.distanceBetween(
|
||
_lastBufferedLocation!.latitude,
|
||
_lastBufferedLocation!.longitude,
|
||
myLocation!.latitude,
|
||
myLocation!.longitude,
|
||
);
|
||
|
||
final bool moved = distFromLast > _minMoveToRecord && currentSpeed > 0.5;
|
||
final bool timeForced = _lastBufferedTime == null ||
|
||
now.difference(_lastBufferedTime!).inSeconds >= 60;
|
||
|
||
if (!moved && !timeForced) return;
|
||
|
||
_lastBufferedLocation = myLocation;
|
||
_lastBufferedTime = now;
|
||
|
||
final point = {
|
||
'lat': double.parse(myLocation!.latitude.toStringAsFixed(6)),
|
||
'lng': double.parse(myLocation!.longitude.toStringAsFixed(6)),
|
||
'spd': double.parse(currentSpeed.toStringAsFixed(1)),
|
||
'head': heading.toStringAsFixed(0),
|
||
'dist': double.parse(totalDistance.toStringAsFixed(1)),
|
||
'ts': now.toIso8601String(),
|
||
};
|
||
|
||
_trackBuffer.add(point);
|
||
Log.print('📌 Buffered point #${_trackBuffer.length} '
|
||
'(${point['lat']}, ${point['lng']}) ${point['spd']} km/h');
|
||
}
|
||
|
||
/// Drains the buffer and POSTs the JSON batch to the server.
|
||
/// Called every 2 minutes (and once more on close).
|
||
Future<void> _flushBufferToServer() async {
|
||
if (_trackBuffer.isEmpty) return;
|
||
|
||
final batch = List<Map<String, dynamic>>.from(_trackBuffer);
|
||
_trackBuffer.clear();
|
||
|
||
final String passengerId = (box.read(BoxName.passengerID) ?? '').toString();
|
||
|
||
Log.print('📤 Uploading ${batch.length} tracking points '
|
||
'for passenger $passengerId...');
|
||
|
||
try {
|
||
await CRUD().post(
|
||
link: '${AppLink.locationServerSide}/add_batch.php',
|
||
payload: {
|
||
'driver_id': passengerId,
|
||
'batch_data': jsonEncode(batch),
|
||
'session_dist': totalDistance.toStringAsFixed(1),
|
||
},
|
||
);
|
||
Log.print('✅ Batch uploaded successfully.');
|
||
} catch (e) {
|
||
// Put the points back so they are retried on the next cycle
|
||
_trackBuffer.insertAll(0, batch);
|
||
Log.print('❌ Batch upload failed – points kept for retry: $e');
|
||
}
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Car marker ────────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
Future<void> _updateCarMarker() async {
|
||
if (myLocation == null || mapController == null || !isStyleLoaded) return;
|
||
|
||
if (carSymbol == null) {
|
||
carSymbol = await mapController!.addSymbol(SymbolOptions(
|
||
geometry: myLocation,
|
||
iconImage: 'car_icon',
|
||
iconSize: 1.0,
|
||
iconRotate: _smoothedHeading,
|
||
));
|
||
} else {
|
||
mapController!.updateSymbol(
|
||
carSymbol!,
|
||
SymbolOptions(
|
||
geometry: myLocation,
|
||
iconRotate: _smoothedHeading,
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Camera ────────────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
void animateCameraToPosition(LatLng position,
|
||
{double? zoom, double bearing = 0.0, double tilt = 0.0}) {
|
||
// Guard: skip if the native view is not ready yet
|
||
if (!_mapReady || mapController == null) return;
|
||
|
||
mapController!.animateCamera(
|
||
CameraUpdate.newCameraPosition(
|
||
CameraPosition(
|
||
target: position,
|
||
zoom: zoom ?? (isNavigating ? _targetZoom : 16.0),
|
||
bearing: bearing,
|
||
tilt: tilt,
|
||
),
|
||
),
|
||
);
|
||
}
|
||
|
||
/// Safe wrapper for animateCamera Bounds to prevent native std::domain_error crash on iOS.
|
||
Future<void> _safeAnimateCameraBounds(LatLngBounds? bounds,
|
||
{double left = 60,
|
||
double top = 60,
|
||
double right = 60,
|
||
double bottom = 60}) async {
|
||
if (bounds == null || mapController == null) return;
|
||
|
||
try {
|
||
// Ensure the coordinates are valid (at least a small span)
|
||
final latSpan =
|
||
(bounds.northeast.latitude - bounds.southwest.latitude).abs();
|
||
final lngSpan =
|
||
(bounds.northeast.longitude - bounds.southwest.longitude).abs();
|
||
|
||
if (latSpan < 0.0001 && lngSpan < 0.0001) {
|
||
Log.print(
|
||
'⚠️ _safeAnimateCameraBounds: Point-sized bounds, zooming to center.');
|
||
mapController
|
||
?.animateCamera(CameraUpdate.newLatLngZoom(bounds.northeast, 16));
|
||
return;
|
||
}
|
||
|
||
// Small delay for view stabilization
|
||
await Future.delayed(const Duration(milliseconds: 200));
|
||
|
||
await mapController?.animateCamera(
|
||
CameraUpdate.newLatLngBounds(
|
||
bounds,
|
||
left: left,
|
||
top: top,
|
||
right: right,
|
||
bottom: bottom,
|
||
),
|
||
);
|
||
} catch (e) {
|
||
Log.print('❌ _safeAnimateCameraBounds CRASH PREVENTED in Nav: $e');
|
||
try {
|
||
await mapController
|
||
?.animateCamera(CameraUpdate.newLatLngZoom(bounds.northeast, 14));
|
||
} catch (_) {}
|
||
}
|
||
}
|
||
|
||
void onUserPanned() {
|
||
_cameraLockedToUser = false;
|
||
update();
|
||
}
|
||
|
||
void relockCameraToUser() {
|
||
_cameraLockedToUser = true;
|
||
if (myLocation != null) {
|
||
animateCameraToPosition(myLocation!,
|
||
bearing: _smoothedHeading, // ← use smoothed heading
|
||
zoom: _targetZoom,
|
||
tilt: _targetTilt);
|
||
}
|
||
update();
|
||
}
|
||
|
||
bool get isCameraLocked => _cameraLockedToUser;
|
||
|
||
// ==========================================================================
|
||
// ── Route polylines ───────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
void _updateTraveledPolylineSmart(LatLng currentPos) {
|
||
if (_fullRouteCoordinates.isEmpty) return;
|
||
|
||
const int searchWindow = 60;
|
||
final int startIndex = _lastTraveledIndexInFullRoute;
|
||
final int endIndex =
|
||
min(startIndex + searchWindow, _fullRouteCoordinates.length);
|
||
|
||
double minDist = double.infinity;
|
||
int closestIdx = startIndex;
|
||
bool foundCloser = false;
|
||
|
||
for (int i = startIndex; i < endIndex; i++) {
|
||
final d = Geolocator.distanceBetween(
|
||
currentPos.latitude,
|
||
currentPos.longitude,
|
||
_fullRouteCoordinates[i].latitude,
|
||
_fullRouteCoordinates[i].longitude,
|
||
);
|
||
if (d < minDist) {
|
||
minDist = d;
|
||
closestIdx = i;
|
||
foundCloser = true;
|
||
}
|
||
}
|
||
|
||
if (foundCloser &&
|
||
minDist < 50 &&
|
||
closestIdx > _lastTraveledIndexInFullRoute) {
|
||
_lastTraveledIndexInFullRoute = closestIdx;
|
||
_updatePolylinesSets(
|
||
_fullRouteCoordinates.sublist(0, closestIdx + 1),
|
||
_fullRouteCoordinates.sublist(closestIdx),
|
||
);
|
||
}
|
||
}
|
||
|
||
Future<void> _updatePolylinesSets(
|
||
List<LatLng> traveled, List<LatLng> remaining) async {
|
||
if (mapController == null || !isStyleLoaded) return;
|
||
|
||
if (remainingRouteLine != null)
|
||
await mapController!.removeLine(remainingRouteLine!);
|
||
if (traveledRouteLine != null)
|
||
await mapController!.removeLine(traveledRouteLine!);
|
||
|
||
if (remaining.isNotEmpty) {
|
||
remainingRouteLine = await mapController!.addLine(LineOptions(
|
||
geometry: remaining,
|
||
lineColor: '#1A73E8',
|
||
lineWidth: 7.0,
|
||
lineJoin: 'round',
|
||
));
|
||
}
|
||
|
||
if (traveled.isNotEmpty) {
|
||
traveledRouteLine = await mapController!.addLine(LineOptions(
|
||
geometry: traveled,
|
||
lineColor: '#BDBDBD',
|
||
lineWidth: 5.0,
|
||
lineJoin: 'round',
|
||
lineOpacity: 0.6,
|
||
));
|
||
}
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Routing API ───────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
Future<void> getRoute(LatLng origin, LatLng destination) async {
|
||
// ── Routing Decision: Normal Points -> SaaS, Multi-Stop -> OSRM ──
|
||
// Note: NavigationController usually handles the active trip (normal points).
|
||
final Map<String, String> queryParams = {
|
||
'fromLat': origin.latitude.toString(),
|
||
'fromLng': origin.longitude.toString(),
|
||
'toLat': destination.latitude.toString(),
|
||
'toLng': destination.longitude.toString(),
|
||
};
|
||
final saasUri =
|
||
Uri.parse(AppLink.mapSaasRoute).replace(queryParameters: queryParams);
|
||
|
||
// Fallback OSRM URL
|
||
final coords = "${origin.longitude},${origin.latitude};"
|
||
"${destination.longitude},${destination.latitude}";
|
||
final osrmUrl =
|
||
"$_routeApiBaseUrl/$coords?steps=true&overview=full&geometries=polyline";
|
||
|
||
try {
|
||
// 1. Try SaaS first
|
||
http.Response response = await http.get(saasUri, headers: {
|
||
'x-api-key': 'intaleq_secret_2026',
|
||
});
|
||
bool useSaaS = response.statusCode == 200;
|
||
|
||
if (!useSaaS) {
|
||
Log.print("⚠️ SaaS Route failed. Falling back to OSRM...");
|
||
response = await http.get(Uri.parse(osrmUrl));
|
||
}
|
||
|
||
if (response.statusCode != 200) {
|
||
mySnackbarWarning('تعذر الاتصال بخدمة التوجيه.');
|
||
return;
|
||
}
|
||
|
||
final data = jsonDecode(response.body);
|
||
final bool isSaaS = useSaaS;
|
||
|
||
// ── 2. Data Extraction Logic ──────────────────────────────────
|
||
String pointsString = "";
|
||
dynamic mainRoute;
|
||
|
||
if (isSaaS) {
|
||
pointsString = data['points']?.toString() ?? "";
|
||
mainRoute = data; // SaaS structure is top-level
|
||
} else {
|
||
if (data['code'] != 'Ok' || (data['routes'] as List).isEmpty) {
|
||
mySnackbarWarning('لم يتم العثور على مسار.');
|
||
return;
|
||
}
|
||
mainRoute = data['routes'][0];
|
||
pointsString = mainRoute['geometry']?.toString() ?? "";
|
||
}
|
||
|
||
if (pointsString.isEmpty) {
|
||
mySnackbarWarning('لم يتم العثور على مسار.');
|
||
return;
|
||
}
|
||
|
||
_fullRouteCoordinates = await compute<String, List<LatLng>>(
|
||
decodePolylineIsolate, pointsString);
|
||
|
||
_lastTraveledIndexInFullRoute = 0;
|
||
if (isStyleLoaded) _updatePolylinesSets([], _fullRouteCoordinates);
|
||
|
||
// ── Offline Cache: Ensure destination area is stored in memory/disk ───
|
||
if (_fullRouteCoordinates.isNotEmpty) {
|
||
OfflineMapService.instance
|
||
.downloadRegion(_fullRouteCoordinates.last, radiusKm: 2.0);
|
||
}
|
||
|
||
// Handle legs/steps & totals
|
||
final legs = mainRoute['legs'] as List?;
|
||
if (legs != null && legs.isNotEmpty) {
|
||
routeSteps = List<Map<String, dynamic>>.from(legs[0]['steps'] as List);
|
||
_routeTotalDistanceM = (legs[0]['distance'] as num).toDouble();
|
||
_routeTotalDurationS = (legs[0]['duration'] as num).toDouble();
|
||
} else {
|
||
// Fallback for SaaS which might have top-level distance/duration
|
||
routeSteps = [];
|
||
_routeTotalDistanceM = (mainRoute['distance'] as num).toDouble();
|
||
_routeTotalDurationS = (mainRoute['duration'] as num).toDouble();
|
||
}
|
||
|
||
if (_routeTotalDistanceM > 0) {
|
||
totalDistanceRemaining = _routeTotalDistanceM > 1000
|
||
? "${(_routeTotalDistanceM / 1000).toStringAsFixed(1)} كم"
|
||
: "${_routeTotalDistanceM.toStringAsFixed(0)} م";
|
||
|
||
final minutes = (_routeTotalDurationS / 60).round();
|
||
estimatedTimeRemaining = minutes > 60
|
||
? "${(minutes / 60).floor()} س ${minutes % 60} د"
|
||
: "$minutes د";
|
||
}
|
||
|
||
for (final step in routeSteps) {
|
||
step['instruction_text'] = _createInstructionFromManeuver(step);
|
||
}
|
||
|
||
currentStepIndex = 0;
|
||
_nextInstructionSpoken = false;
|
||
isNavigating = true;
|
||
_cameraLockedToUser = true;
|
||
|
||
// Reset off-route state after a successful recalculation
|
||
_offRouteStartTime = null;
|
||
|
||
if (routeSteps.isNotEmpty) {
|
||
currentInstruction = routeSteps[0]['instruction_text'];
|
||
nextInstruction = routeSteps.length > 1
|
||
? "ثم ${routeSteps[1]['instruction_text']}"
|
||
: "الوجهة النهائية";
|
||
Get.find<TextToSpeechController>().speakText(currentInstruction);
|
||
}
|
||
|
||
// ── 5. Camera Update (Safe) ───────────────────────────────────
|
||
if (_fullRouteCoordinates.length >= 2) {
|
||
final bounds =
|
||
data['bbox'] != null && (data['bbox'] as List).length == 4
|
||
? LatLngBounds(
|
||
southwest: LatLng(data['bbox'][1], data['bbox'][0]),
|
||
northeast: LatLng(data['bbox'][3], data['bbox'][2]),
|
||
)
|
||
: _boundsFromLatLngList(_fullRouteCoordinates);
|
||
|
||
await _safeAnimateCameraBounds(bounds,
|
||
bottom: 220, top: 150, left: 50, right: 50);
|
||
}
|
||
|
||
update();
|
||
} catch (e) {
|
||
Log.print("GetRoute Error: $e");
|
||
}
|
||
}
|
||
|
||
// Crude but fast ETA re-estimate based on fraction of route remaining.
|
||
void _recomputeETA() {
|
||
if (_routeTotalDistanceM == 0 || _fullRouteCoordinates.isEmpty) return;
|
||
|
||
final fraction =
|
||
(_fullRouteCoordinates.length - _lastTraveledIndexInFullRoute) /
|
||
_fullRouteCoordinates.length;
|
||
|
||
final remainingM = _routeTotalDistanceM * fraction;
|
||
final remainingS = _routeTotalDurationS * fraction;
|
||
|
||
totalDistanceRemaining = remainingM > 1000
|
||
? "${(remainingM / 1000).toStringAsFixed(1)} كم"
|
||
: "${remainingM.toStringAsFixed(0)} م";
|
||
|
||
final minutes = (remainingS / 60).round();
|
||
estimatedTimeRemaining = minutes > 60
|
||
? "${(minutes / 60).floor()} س ${minutes % 60} د"
|
||
: "$minutes د";
|
||
}
|
||
|
||
Future<void> startNavigationTo(LatLng destination,
|
||
{String infoWindowTitle = ''}) async {
|
||
isLoading = true;
|
||
update();
|
||
try {
|
||
_finalDestination = destination;
|
||
await clearRoute(isNewRoute: true);
|
||
|
||
if (isStyleLoaded && mapController != null) {
|
||
// Destination Marker (B)
|
||
destinationSymbol = await mapController!.addSymbol(SymbolOptions(
|
||
geometry: destination,
|
||
iconImage: 'dest_icon',
|
||
iconSize: 1.0,
|
||
textField: infoWindowTitle,
|
||
textOffset: const Offset(0, 2),
|
||
));
|
||
|
||
// Start Marker (A)
|
||
if (myLocation != null) {
|
||
originSymbol = await mapController!.addSymbol(SymbolOptions(
|
||
geometry: myLocation,
|
||
iconImage: 'start_icon',
|
||
iconSize: 1.0,
|
||
));
|
||
}
|
||
}
|
||
|
||
if (myLocation != null) await getRoute(myLocation!, destination);
|
||
} finally {
|
||
isLoading = false;
|
||
update();
|
||
}
|
||
}
|
||
|
||
Future<void> recalculateRoute() async {
|
||
if (myLocation == null || _finalDestination == null || isLoading) return;
|
||
isLoading = true;
|
||
update();
|
||
mySnackbarInfo('جاري حساب مسار جديد...');
|
||
await getRoute(myLocation!, _finalDestination!);
|
||
isLoading = false;
|
||
update();
|
||
}
|
||
|
||
Future<void> clearRoute({bool isNewRoute = false}) async {
|
||
// Reset off-route state whenever the route is cleared
|
||
_offRouteStartTime = null;
|
||
_autoRecalcInProgress = false;
|
||
|
||
if (!isNewRoute) {
|
||
if (destinationSymbol != null && mapController != null) {
|
||
await mapController!.removeSymbol(destinationSymbol!);
|
||
destinationSymbol = null;
|
||
}
|
||
if (originSymbol != null && mapController != null) {
|
||
await mapController!.removeSymbol(originSymbol!);
|
||
originSymbol = null;
|
||
}
|
||
if (remainingRouteLine != null && mapController != null) {
|
||
await mapController!.removeLine(remainingRouteLine!);
|
||
remainingRouteLine = null;
|
||
}
|
||
if (traveledRouteLine != null && mapController != null) {
|
||
await mapController!.removeLine(traveledRouteLine!);
|
||
traveledRouteLine = null;
|
||
}
|
||
_finalDestination = null;
|
||
isNavigating = false;
|
||
|
||
// Flush whatever is in the buffer when navigation ends
|
||
await _flushBufferToServer();
|
||
}
|
||
routeSteps.clear();
|
||
_fullRouteCoordinates.clear();
|
||
_lastTraveledIndexInFullRoute = 0;
|
||
currentInstruction = "";
|
||
nextInstruction = "";
|
||
distanceToNextStep = "";
|
||
totalDistanceRemaining = "";
|
||
estimatedTimeRemaining = "";
|
||
_routeTotalDistanceM = 0;
|
||
_routeTotalDurationS = 0;
|
||
update();
|
||
}
|
||
|
||
Future<void> _loadCustomIcons() async {
|
||
if (mapController == null) return;
|
||
final carBytes = await rootBundle.load('assets/images/car.png');
|
||
final startBytes = await rootBundle.load('assets/images/A.png');
|
||
final destBytes = await rootBundle.load('assets/images/b.png');
|
||
|
||
await mapController!.addImage('car_icon', carBytes.buffer.asUint8List());
|
||
await mapController!.addImage('start_icon', startBytes.buffer.asUint8List());
|
||
await mapController!.addImage('dest_icon', destBytes.buffer.asUint8List());
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Step tracking & TTS ───────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
void _checkNavigationStep(LatLng pos) {
|
||
if (routeSteps.isEmpty || currentStepIndex >= routeSteps.length) return;
|
||
|
||
final maneuver = routeSteps[currentStepIndex]['maneuver'];
|
||
final loc = maneuver['location'] as List;
|
||
final endLatLng = LatLng(loc[1] as double, loc[0] as double);
|
||
|
||
final distance = Geolocator.distanceBetween(
|
||
pos.latitude,
|
||
pos.longitude,
|
||
endLatLng.latitude,
|
||
endLatLng.longitude,
|
||
);
|
||
|
||
distanceToNextStep = distance > 1000
|
||
? "${(distance / 1000).toStringAsFixed(1)} كم"
|
||
: "${distance.toStringAsFixed(0)} م";
|
||
|
||
if (distance < 50 &&
|
||
!_nextInstructionSpoken &&
|
||
nextInstruction.isNotEmpty) {
|
||
Get.find<TextToSpeechController>().speakText(nextInstruction);
|
||
_nextInstructionSpoken = true;
|
||
}
|
||
|
||
if (distance < 20) _advanceStep();
|
||
}
|
||
|
||
void _advanceStep() {
|
||
currentStepIndex++;
|
||
if (currentStepIndex < routeSteps.length) {
|
||
currentInstruction = routeSteps[currentStepIndex]['instruction_text'];
|
||
nextInstruction = (currentStepIndex + 1) < routeSteps.length
|
||
? "ثم ${routeSteps[currentStepIndex + 1]['instruction_text']}"
|
||
: "ستصل إلى وجهتك";
|
||
_nextInstructionSpoken = false;
|
||
update();
|
||
} else {
|
||
_finishNavigation();
|
||
}
|
||
}
|
||
|
||
void _finishNavigation() {
|
||
currentInstruction = "لقد وصلت إلى وجهتك";
|
||
nextInstruction = "";
|
||
distanceToNextStep = "";
|
||
isNavigating = false;
|
||
Get.find<TextToSpeechController>().speakText(currentInstruction);
|
||
// Final flush on arrival
|
||
_flushBufferToServer();
|
||
update();
|
||
}
|
||
|
||
String _createInstructionFromManeuver(Map<String, dynamic> step) {
|
||
if (step['maneuver'] == null) return "تابع المسير";
|
||
final type = step['maneuver']['type'] ?? 'continue';
|
||
final modifier = step['maneuver']['modifier'] ?? 'straight';
|
||
final name = step['name'] ?? '';
|
||
|
||
String instruction = type == 'depart'
|
||
? "انطلق"
|
||
: type == 'arrive'
|
||
? "لقد وصلت إلى وجهتك، $name"
|
||
: _getTurnInstruction(modifier);
|
||
|
||
if (name.isNotEmpty && type != 'arrive') instruction += " نحو $name";
|
||
return instruction;
|
||
}
|
||
|
||
String _getTurnInstruction(String modifier) {
|
||
switch (modifier) {
|
||
case 'uturn':
|
||
return "قم بالاستدارة والعودة";
|
||
case 'sharp right':
|
||
return "انعطف يميناً بحدة";
|
||
case 'right':
|
||
return "انعطف يميناً";
|
||
case 'slight right':
|
||
return "انعطف يميناً قليلاً";
|
||
case 'straight':
|
||
return "استمر للأمام";
|
||
case 'slight left':
|
||
return "انعطف يساراً قليلاً";
|
||
case 'left':
|
||
return "انعطف يساراً";
|
||
case 'sharp left':
|
||
return "انعطف يساراً بحدة";
|
||
default:
|
||
return "اتجه";
|
||
}
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Search ────────────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
Future<void> getPlaces() async {
|
||
final q = placeDestinationController.text.trim();
|
||
if (q.length < 3) {
|
||
placesDestination = [];
|
||
update();
|
||
return;
|
||
}
|
||
if (myLocation == null) return;
|
||
|
||
final lat = myLocation!.latitude;
|
||
final lng = myLocation!.longitude;
|
||
const radiusKm = 200.0;
|
||
|
||
final payload = {
|
||
'query': q,
|
||
'lat_min': (lat - _kmToLatDelta(radiusKm)).toString(),
|
||
'lat_max': (lat + _kmToLatDelta(radiusKm)).toString(),
|
||
'lng_min': (lng - _kmToLngDelta(radiusKm, lat)).toString(),
|
||
'lng_max': (lng + _kmToLngDelta(radiusKm, lat)).toString(),
|
||
};
|
||
|
||
try {
|
||
final response =
|
||
await CRUD().post(link: AppLink.getPlacesSyria, payload: payload);
|
||
List list;
|
||
if (response is Map && response['status'] == 'success')
|
||
list = List.from(response['message'] as List);
|
||
else if (response is List)
|
||
list = List.from(response);
|
||
else
|
||
return;
|
||
|
||
for (final p in list) {
|
||
final plat = double.tryParse(p['latitude']?.toString() ?? '0') ?? 0.0;
|
||
final plng = double.tryParse(p['longitude']?.toString() ?? '0') ?? 0.0;
|
||
p['distanceKm'] = _haversineKm(lat, lng, plat, plng);
|
||
}
|
||
|
||
list.sort((a, b) =>
|
||
(a['distanceKm'] as double).compareTo(b['distanceKm'] as double));
|
||
placesDestination = list;
|
||
update();
|
||
} catch (e) {
|
||
Log.print('getPlaces error: $e');
|
||
}
|
||
}
|
||
|
||
Future<void> selectDestination(dynamic place) async {
|
||
placeDestinationController.clear();
|
||
placesDestination = [];
|
||
final lat = double.parse(place['latitude'].toString());
|
||
final lng = double.parse(place['longitude'].toString());
|
||
await startNavigationTo(LatLng(lat, lng),
|
||
infoWindowTitle: place['name'] ?? 'وجهة');
|
||
}
|
||
|
||
void onSearchChanged(String query) {
|
||
if (_debounce?.isActive ?? false) _debounce!.cancel();
|
||
_debounce = Timer(const Duration(milliseconds: 700), () => getPlaces());
|
||
}
|
||
|
||
// ==========================================================================
|
||
// ── Geo utils ─────────────────────────────────────────────────────────────
|
||
// ==========================================================================
|
||
|
||
double _haversineKm(double lat1, double lon1, double lat2, double lon2) {
|
||
const R = 6371.0;
|
||
final dLat = (lat2 - lat1) * (pi / 180.0);
|
||
final dLon = (lon2 - lon1) * (pi / 180.0);
|
||
final a = sin(dLat / 2) * sin(dLat / 2) +
|
||
cos(lat1 * pi / 180) *
|
||
cos(lat2 * pi / 180) *
|
||
sin(dLon / 2) *
|
||
sin(dLon / 2);
|
||
return R * 2 * atan2(sqrt(a), sqrt(1 - a));
|
||
}
|
||
|
||
double _kmToLatDelta(double km) => km / 111.32;
|
||
double _kmToLngDelta(double km, double lat) =>
|
||
km / (111.32 * cos(lat * pi / 180));
|
||
|
||
LatLngBounds _boundsFromLatLngList(List<LatLng> list) {
|
||
double? x0, x1, y0, y1;
|
||
for (final ll in list) {
|
||
if (x0 == null) {
|
||
x0 = x1 = ll.latitude;
|
||
y0 = y1 = ll.longitude;
|
||
} else {
|
||
if (ll.latitude > x1!) x1 = ll.latitude;
|
||
if (ll.latitude < x0) x0 = ll.latitude;
|
||
if (ll.longitude > y1!) y1 = ll.longitude;
|
||
if (ll.longitude < y0!) y0 = ll.longitude;
|
||
}
|
||
}
|
||
return LatLngBounds(
|
||
northeast: LatLng(x1!, y1!), southwest: LatLng(x0!, y0!));
|
||
}
|
||
}
|