Google Maps Widget for polyline and live tracking

// Automatic FlutterFlow imports
import '/backend/backend.dart';
import '/backend/schema/structs/index.dart';
import '/backend/schema/enums/enums.dart';
import '/flutter_flow/flutter_flow_theme.dart';
import '/flutter_flow/flutter_flow_util.dart';
import '/custom_code/widgets/index.dart'; // Imports other custom widgets
import '/flutter_flow/custom_functions.dart'; // Imports custom functions
import 'package:flutter/material.dart';
// Begin custom widget code
// DO NOT REMOVE OR MODIFY THE CODE ABOVE!

import 'dart:async';
import 'package:google_maps_flutter/google_maps_flutter.dart' as gmap;
import 'package:location/location.dart';
import 'package:flutter_polyline_points/flutter_polyline_points.dart';

class RouteMaps extends StatefulWidget {
  final gmap.LatLng sourcePosition;
  final gmap.LatLng destinationPosition;

  RouteMaps({
    Key? key,
    required this.sourcePosition,
    required this.destinationPosition,
  }) : super(key: key);

  @override
  _RouteMapsState createState() => _RouteMapsState();
}

class _RouteMapsState extends State<RouteMaps> {
  Location _locationController = new Location();
  final Completer<gmap.GoogleMapController> _mapController =
      Completer<gmap.GoogleMapController>();

  gmap.LatLng? _currentP = null;
  final String Google_Maps_API_Key = "AIzaSyBqKOrEz_V_yQdOQEzi013DJPg6bzD1GXM";

  Map<gmap.PolylineId, gmap.Polyline> polylines = {};

  @override
  void initState() {
    super.initState();
    getLocationUpdates().then(
      (_) => getPolylinePoints().then((coordinates) {
        generatePolylineFromPoints(coordinates);
      }),
    );
  }

  late gmap.GoogleMapController mapController;

  void _onMapCreated(gmap.GoogleMapController controller) {
    _mapController.complete(controller);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: _currentP == null
          ? const Center(
              child: Text("Loading..."),
            ) // Center
          : gmap.GoogleMap(
              onMapCreated: _onMapCreated,
              initialCameraPosition: gmap.CameraPosition(
                target: widget.sourcePosition,
                zoom: 13,
              ),
              markers: {
                gmap.Marker(
                  markerId: gmap.MarkerId("_currentLocation"),
                  icon: gmap.BitmapDescriptor.defaultMarker,
                  position: _currentP!,
                ), // Marker
                gmap.Marker(
                  markerId: gmap.MarkerId("_SourceLocation"),
                  icon: gmap.BitmapDescriptor.defaultMarker,
                  position: widget.sourcePosition,
                ), // Marker

                gmap.Marker(
                  markerId: gmap.MarkerId("_destinationLocation"),
                  icon: gmap.BitmapDescriptor.defaultMarker,
                  position: widget.destinationPosition,
                ), // Marker
              },
              polylines: Set<gmap.Polyline>.of(polylines.values),
            ),
    );
  }

  Future<void> _cameraToPosition(gmap.LatLng pos) async {
    final gmap.GoogleMapController controller = await _mapController.future;
    gmap.CameraPosition _newCameraPosition = gmap.CameraPosition(
      target: pos,
      zoom: 13,
    );
    await controller.animateCamera(
      gmap.CameraUpdate.newCameraPosition(_newCameraPosition),
    );
  }

  Future<void> getLocationUpdates() async {
    bool _serviceEnabled;
    PermissionStatus _permissionGranted;

    _serviceEnabled = await _locationController.serviceEnabled();
    if (!_serviceEnabled) {
      _serviceEnabled = await _locationController.requestService();
      if (!_serviceEnabled) {
        return;
      }
    }

    _permissionGranted = await _locationController.hasPermission();
    if (_permissionGranted == PermissionStatus.denied) {
      _permissionGranted = await _locationController.requestPermission();
      if (_permissionGranted != PermissionStatus.granted) {
        return;
      }
    }

    _locationController.onLocationChanged
        .listen((LocationData _currentLocation) {
      if (_currentLocation.latitude != null &&
          _currentLocation.longitude != null) {
        setState(() {
          _currentP = gmap.LatLng(
              _currentLocation.latitude!, _currentLocation.longitude!);

          _cameraToPosition(_currentP!);
        });
      }
    });
  }

  Future<List<gmap.LatLng>> getPolylinePoints() async {
    List<gmap.LatLng> polylineCoordinates = [];
    PolylinePoints polylinePoints = PolylinePoints();
    PolylineResult result = await polylinePoints.getRouteBetweenCoordinates(
      Google_Maps_API_Key,
      PointLatLng(
          widget.sourcePosition.latitude, widget.sourcePosition.longitude),
      PointLatLng(widget.destinationPosition.latitude,
          widget.destinationPosition.longitude),
      travelMode: TravelMode.driving,
    );
    if (result.points.isNotEmpty) {
      result.points.forEach((PointLatLng point) {
        polylineCoordinates.add(gmap.LatLng(point.latitude, point.longitude));
      });
    } else {
      print(result.errorMessage);
    }
    return polylineCoordinates;
  }

  void generatePolylineFromPoints(List<gmap.LatLng> polylineCoordinates) {
    gmap.PolylineId id = gmap.PolylineId("Poly");
    gmap.Polyline polyline = gmap.Polyline(
        polylineId: id,
        color: Colors.orange,
        points: polylineCoordinates,
        width: 2);
    setState(() {
      polylines[id] = polyline;
    });
  }
}