25-7-28-2

lib/controller/firebase/access_token.dart

@@ -0,0 +1,53 @@
+import 'dart:convert';
+import 'package:googleapis_auth/auth_io.dart';
+
+import '../../print.dart';
+
+class AccessTokenManager {
+  static final AccessTokenManager _instance = AccessTokenManager._internal();
+  late final String serviceAccountJsonKey;
+  AccessToken? _accessToken;
+  DateTime? _expiryDate;
+
+  AccessTokenManager._internal();
+
+  factory AccessTokenManager(String jsonKey) {
+    if (_instance._isServiceAccountKeyInitialized()) {
+      // Prevent re-initialization
+      return _instance;
+    }
+    _instance.serviceAccountJsonKey = jsonKey;
+    return _instance;
+  }
+
+  bool _isServiceAccountKeyInitialized() {
+    try {
+      serviceAccountJsonKey; // Access to check if initialized
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  Future<String> getAccessToken() async {
+    if (_accessToken != null && DateTime.now().isBefore(_expiryDate!)) {
+      return _accessToken!.data;
+    }
+    try {
+      final serviceAccountCredentials = ServiceAccountCredentials.fromJson(
+          json.decode(serviceAccountJsonKey));
+      final client = await clientViaServiceAccount(
+        serviceAccountCredentials,
+        ['https://www.googleapis.com/auth/firebase.messaging'],
+      );
+
+      _accessToken = client.credentials.accessToken;
+      _expiryDate = client.credentials.accessToken.expiry;
+      client.close();
+      // Log.print('_accessToken!.data: ${_accessToken!.data}');
+      return _accessToken!.data;
+    } catch (e) {
+      throw Exception('Failed to obtain access token');
+    }
+  }
+}

lib/controller/firebase/bring_app_foreground.dart

@@ -0,0 +1,18 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+
+class AppLifecycleManager {
+  static const platform = MethodChannel('com.sefer_driver/app_lifecycle');
+
+  static Future<void> bringAppToForeground() async {
+    try {
+      debugPrint('Attempting to bring app to foreground');
+      await platform.invokeMethod('bringAppToForeground');
+      debugPrint('Method invocation completed');
+    } on PlatformException catch (e) {
+      debugPrint("Failed to bring app to foreground: '${e.message}'.");
+    } catch (e) {
+      debugPrint("Unexpected error: $e");
+    }
+  }
+}

lib/controller/firebase/firbase_messge.dart

@@ -0,0 +1,777 @@
+import 'dart:convert';
+import 'dart:io';
+import 'package:sefer_driver/constant/api_key.dart';
+import 'package:sefer_driver/controller/home/captin/home_captain_controller.dart';
+import 'package:sefer_driver/views/widgets/error_snakbar.dart';
+import 'package:sefer_driver/views/widgets/mydialoug.dart';
+import 'package:firebase_messaging/firebase_messaging.dart';
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+import 'package:http/http.dart' as http;
+import 'package:sefer_driver/views/widgets/elevated_btn.dart';
+
+import '../../constant/box_name.dart';
+import '../../constant/colors.dart';
+import '../../constant/style.dart';
+import '../../env/env.dart';
+import '../../main.dart';
+import '../../print.dart';
+import '../../views/auth/captin/criminal_documents_page.dart';
+import '../../views/home/Captin/home_captain/home_captin.dart';
+import '../../views/home/Captin/orderCaptin/order_speed_request.dart';
+import '../../views/home/Captin/orderCaptin/order_request_page.dart';
+import '../../views/home/Captin/orderCaptin/vip_order_page.dart';
+import '../auth/google_sign.dart';
+import '../functions/encrypt_decrypt.dart';
+import '../functions/face_detect.dart';
+import 'access_token.dart';
+import 'local_notification.dart';
+
+class FirebaseMessagesController extends GetxController {
+  final fcmToken = FirebaseMessaging.instance;
+
+  List<String> tokens = [];
+  List dataTokens = [];
+  late String driverID;
+  late String driverToken;
+  NotificationSettings? notificationSettings;
+  NotificationController notificationController =
+      Get.put(NotificationController());
+  Future<void> getNotificationSettings() async {
+    // Get the current notification settings
+    NotificationSettings? notificationSettings =
+        await FirebaseMessaging.instance.getNotificationSettings();
+    'Notification authorization status: ${notificationSettings.authorizationStatus}';
+
+    // Call the update function if needed
+    update();
+  }
+
+  Future<void> requestFirebaseMessagingPermission() async {
+    FirebaseMessaging messaging = FirebaseMessaging.instance;
+
+    // Check if the platform is Android
+    if (Platform.isAndroid) {
+      // Request permission for Android
+      await messaging.requestPermission();
+    } else if (Platform.isIOS) {
+      // Request permission for iOS
+      NotificationSettings settings = await messaging.requestPermission(
+        alert: true,
+        announcement: true,
+        badge: true,
+        carPlay: true,
+        criticalAlert: true,
+        provisional: false,
+        sound: true,
+      );
+      messaging.setForegroundNotificationPresentationOptions(
+          alert: true, badge: true, sound: true);
+    }
+  }
+
+  Future getToken() async {
+    fcmToken.getToken().then((token) {
+      Log.print('token: ${token}');
+      box.write(BoxName.tokenDriver, (token!));
+    });
+
+    FirebaseMessaging.onMessage.listen((RemoteMessage message) {
+      // If the app is in the background or terminated, show a system tray message
+      RemoteNotification? notification = message.notification;
+      AndroidNotification? android = notification?.android;
+      // if (notification != null && android != null) {
+
+      if (message.data.isNotEmpty && message.notification != null) {
+        fireBaseTitles(message);
+      }
+      if (message.data.isNotEmpty && message.notification != null) {
+        fireBaseTitles(message);
+      }
+    });
+    FirebaseMessaging.onBackgroundMessage((RemoteMessage message) async {});
+
+    FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
+      if (message.data.isNotEmpty && message.notification != null) {
+        fireBaseTitles(message);
+      }
+    });
+  }
+
+  Future<void> fireBaseTitles(RemoteMessage message) async {
+    if (message.notification!.title! == 'Order') {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            message.notification!.title.toString(),
+            message.notification!.body.toString(),
+            'tone1',
+            '');
+      }
+      // await FirebaseMessagesController().showOverlayNotification(message);
+      var myListString = message.data['DriverList'];
+      // var points = message.data['PolylineJson'];
+
+      var myList = jsonDecode(myListString) as List<dynamic>;
+      // var myPoints = jsonDecode(points) as List<dynamic>;
+      driverToken = myList[14].toString();
+      // This is for location using and uploading status
+      Get.put(HomeCaptainController()).changeRideId();
+      update();
+      Get.to(() => OrderRequestPage(), arguments: {
+        // Get.to(() => OrderRequestPage(), arguments: {
+        'myListString': myListString,
+        'DriverList': myList,
+        // 'PolylineJson': myPoints,
+        'body': message.notification!.body
+      });
+    } else if (message.notification!.title == 'OrderVIP') {
+      var myListString = message.data['DriverList'];
+
+      var myList = jsonDecode(myListString) as List<dynamic>;
+
+      // driverToken = myList[10].toString();
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'OrderVIP'.tr, 'OrderVIP'.tr, 'order', '');
+      }
+      Get.to(VipOrderPage(), arguments: {
+        'myListString': myListString,
+        'DriverList': myList,
+        // 'PolylineJson': myPoints,
+        'body': message.notification!.body
+      });
+    } else if (message.notification!.title == 'Cancel Trip'.tr) {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'Cancel Trip'.tr, 'Passenger Cancel Trip'.tr, 'cancel', '');
+      }
+      cancelTripDialog();
+    } else if (message.notification!.title == 'VIP Order') {
+      var myListString = message.data['DriverList'];
+      var driverList = jsonDecode(myListString) as List<dynamic>;
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'VIP Order'.tr, '', 'order', '');
+      }
+      MyDialog().getDialog('VIP Order'.tr, 'midTitle', () {
+        sendNotificationToPassengerToken(
+            'VIP Order Accepted'.tr,
+            'The driver accepted your trip'.tr,
+            driverList[0],
+            [driverList[1]],
+            'order');
+      });
+
+      // Get.to(const VipOrderPage());
+    } else if (message.notification!.title == 'message From passenger') {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'message From passenger'.tr, ''.tr, 'ding', '');
+      }
+      MyDialog().getDialog(
+          'message From passenger'.tr, message.notification!.body!, () {
+        Get.back();
+      });
+    } else if (message.notification!.title == 'Cancel') {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'Cancel'.tr, ''.tr, 'cancel', '');
+      }
+      MyDialog().getDialog(
+          'Passenger Cancel Trip'.tr,
+          'Trip Cancelled. The cost of the trip will be added to your wallet.'
+              .tr, () {
+        box.write(BoxName.rideStatus, 'Cancel');
+        Log.print('rideStatus from 184 : ${box.read(BoxName.rideStatus)}');
+        Get.offAll(HomeCaptain());
+      });
+      // cancelTripDialog1();
+    } else if (message.notification!.title! == 'token change') {
+      // notificationController
+      //     .showNotification('token change'.tr, 'token change', 'cancel');
+      // GoogleSignInHelper.signOut();
+      GoogleSignInHelper.signOut();
+    } else if (message.notification!.title! == 'face detect') {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'face detect'.tr, ''.tr, 'tone2', '');
+      }
+      String result0 = await faceDetector();
+      // Handle the result here, e.g., show a dialog or update the UI
+      var result = jsonDecode(result0);
+      MyDialogContent().getDialog(
+        'Face Detection Result'.tr,
+        Text(
+          result['similar'].toString() == 'true'
+              ? 'similar'.tr
+              : 'not similar'.tr,
+          style: AppStyle.title,
+        ),
+        () {
+          Get.back();
+        },
+      );
+
+      update();
+    } else if (message.notification!.title! == 'Hi ,I will go now') {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'Passenger come to you'.tr, 'Hi ,I will go now'.tr, 'tone2', '');
+      }
+      update();
+    } else if (message.notification!.title! == 'Call Income'.tr) {
+      try {
+        var myListString = message.data['passengerList'];
+        var driverList = jsonDecode(myListString) as List<dynamic>;
+        // if (Platform.isAndroid) {
+        if (Platform.isAndroid) {
+          notificationController.showNotification('Call Income'.tr,
+              message.notification!.body!, 'iphone_ringtone', '');
+        }
+        // }
+        // Assuming GetMaterialApp is initialized and context is valid for navigation
+        // Get.to(() => PassengerCallPage(
+        //       channelName: driverList[1].toString(),
+        //       token: driverList[0].toString(),
+        //       remoteID: driverList[2].toString(),
+        //     ));
+      } catch (e) {}
+    } else if (message.notification!.title! ==
+        'Call Income from Passenger'.tr) {
+      try {
+        var myListString = message.data['passengerList'];
+        var driverList = jsonDecode(myListString) as List<dynamic>;
+        // if (Platform.isAndroid) {
+        if (Platform.isAndroid) {
+          notificationController.showNotification('Call Income'.tr,
+              message.notification!.body!, 'iphone_ringtone', '');
+        }
+        // }
+        // Assuming GetMaterialApp is initialized and context is valid for navigation
+        // Get.to(() => CallPage(
+        //     // channelName: driverList[1].toString(),
+        //     // token: driverList[0].toString(),
+        //     // remoteID: driverList[2].toString(),
+        //     ));
+      } catch (e) {}
+    } else if (message.notification!.title! ==
+        "Criminal Document Required".tr) {
+      if (Platform.isAndroid) {
+        notificationController.showNotification("Criminal Document Required".tr,
+            message.notification!.body!, 'tone2', '');
+      }
+      MyDialog().getDialog(
+          "Criminal Document Required".tr, 'You should have upload it .'.tr,
+          () {
+        Get.to(() => const CriminalDocumemtPage());
+      });
+      Get.to(() => const CriminalDocumemtPage());
+    } else if (message.notification!.title! == 'Call End'.tr) {
+      try {
+        var myListString = message.data['passengerList'];
+        var driverList = jsonDecode(myListString) as List<dynamic>;
+        if (Platform.isAndroid) {
+          notificationController.showNotification(
+              'Call End'.tr, message.notification!.body!, 'tone2', '');
+        }
+        // Assuming GetMaterialApp is initialized and context is valid for navigation
+        // Get.off(const CallPage());
+      } catch (e) {}
+    } else if (message.notification!.title! == 'Order Applied'.tr) {
+      mySnackbarSuccess("The order has been accepted by another driver.".tr);
+    } else if (message.notification!.title! == 'Order') {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            message.notification!.title.toString(),
+            message.notification!.body.toString(),
+            'order',
+            '');
+      }
+      var myListString = message.data['DriverList'];
+      // var points = message.data['PolylineJson'];
+
+      var myList = jsonDecode(myListString) as List<dynamic>;
+      // var myPoints = jsonDecode(points) as List<dynamic>;
+      driverToken = myList[14].toString();
+      Get.put(HomeCaptainController()).changeRideId();
+      update();
+      Get.to(() => OrderSpeedRequest(), arguments: {
+        'myListString': myListString,
+        'DriverList': myList,
+        // 'PolylineJson': myPoints,
+        'body': message.notification!.body
+      });
+    } else if (message.notification!.title! == 'Order Applied'.tr) {
+      if (Platform.isAndroid) {
+        notificationController.showNotification(
+            'The order Accepted by another Driver'.tr,
+            'We regret to inform you that another driver has accepted this order.'
+                .tr,
+            'order',
+            '');
+      }
+    }
+  }
+
+  SnackbarController driverAppliedTripSnakBar() {
+    return Get.snackbar(
+      'Driver Applied the Ride for You'.tr,
+      '',
+      colorText: AppColor.greenColor,
+      duration: const Duration(seconds: 3),
+      snackPosition: SnackPosition.TOP,
+      titleText: Text(
+        'Applied'.tr,
+        style: const TextStyle(color: AppColor.redColor),
+      ),
+      messageText: Text(
+        'Driver Applied the Ride for You'.tr,
+        style: AppStyle.title,
+      ),
+      icon: const Icon(Icons.approval),
+      shouldIconPulse: true,
+      margin: const EdgeInsets.all(16),
+      padding: const EdgeInsets.all(16),
+    );
+  }
+
+  Future<dynamic> cancelTripDialog() {
+    return Get.defaultDialog(
+        barrierDismissible: false,
+        title: 'Passenger Cancel Trip'.tr,
+        middleText: '',
+        confirm: MyElevatedButton(
+            title: 'Ok'.tr,
+            onPressed: () {
+              box.write(BoxName.rideStatus, 'Cancel');
+              Log.print(
+                  'rideStatus from 347 : ${box.read(BoxName.rideStatus)}');
+              Get.offAll(HomeCaptain());
+            }));
+  }
+
+  Future<dynamic> cancelTripDialog1() {
+    return Get.defaultDialog(
+        barrierDismissible: false,
+        title: 'Passenger Cancel Trip'.tr,
+        middleText:
+            'Trip Cancelled. The cost of the trip will be added to your wallet.'
+                .tr,
+        confirm: MyElevatedButton(
+            title: 'Ok'.tr,
+            onPressed: () {
+              box.write(BoxName.rideStatus, 'Cancel');
+              Log.print(
+                  'rideStatus from 364 : ${box.read(BoxName.rideStatus)}');
+              Get.offAll(HomeCaptain());
+            }));
+  }
+
+  // Future<dynamic> driverArrivePassengerDialoge() {
+  //   return Get.defaultDialog(
+  //       barrierDismissible: false,
+  //       title: 'Hi ,I Arrive your site'.tr,
+  //       middleText: 'Please go to Car Driver'.tr,
+  //       confirm: MyElevatedButton(
+  //           title: 'Ok I will go now.'.tr,
+  //           onPressed: () {
+  //             FirebaseMessagesController().sendNotificationToPassengerToken(
+  //                 'Hi ,I will go now'.tr,
+  //                 'I will go now'.tr,
+  //                 Get.find<MapDriverController>().driverToken, []);
+  //             Get.find<MapPassengerController>()
+  //                 .startTimerDriverWaitPassenger5Minute();
+
+  //             Get.back();
+  //           }));
+  // }
+
+  Future<dynamic> passengerDialog(String message) {
+    return Get.defaultDialog(
+        barrierDismissible: false,
+        title: 'message From passenger'.tr,
+        titleStyle: AppStyle.title,
+        middleTextStyle: AppStyle.title,
+        middleText: message.tr,
+        confirm: MyElevatedButton(
+            title: 'Ok'.tr,
+            onPressed: () {
+              //   FirebaseMessagesController().sendNotificationToPassengerToken(
+              //       'Hi ,I will go now'.tr,
+              //       'I will go now'.tr,
+              //       Get.find<MapPassengerController>().driverToken, []);
+              //   Get.find<MapPassengerController>()
+              //       .startTimerDriverWaitPassenger5Minute();
+
+              Get.back();
+            }));
+  }
+
+  late String serviceAccountKeyJson;
+  @override
+  Future<void> onInit() async {
+    super.onInit();
+    try {
+      var encryptedKey = Env.privateKeyFCM;
+      // Log.print('encryptedKey: ${encryptedKey}');
+      serviceAccountKeyJson =
+          EncryptionHelper.instance.decryptData(encryptedKey);
+      // Log.print('serviceAccountKeyJson: ${serviceAccountKeyJson}');
+    } catch (e) {
+      print('🔴 Error decrypting FCM key: $e');
+    }
+  }
+
+  void sendNotificationAll(String title, body, tone) async {
+    // Get the token you want to subtract.
+    String token = box.read(BoxName.tokenFCM);
+    tokens = box.read(BoxName.tokens);
+    // Subtract the token from the list of tokens.
+    tokens.remove(token);
+
+    // Save the list of tokens back to the box.
+    // box.write(BoxName.tokens, tokens);
+    tokens = box.read(BoxName.tokens);
+    for (var i = 0; i < tokens.length; i++) {
+      if (serviceAccountKeyJson.isEmpty) {
+        print("🔴 Error: Service Account Key is empty");
+        return;
+      }
+      // Initialize AccessTokenManager
+      final accessTokenManager = AccessTokenManager(serviceAccountKeyJson);
+
+      // Obtain an OAuth 2.0 access token
+      final accessToken = await accessTokenManager.getAccessToken();
+      // Log.print('accessToken: ${accessToken}');
+
+      // Send the notification
+      final response = await http
+          .post(
+            Uri.parse(
+                'https://fcm.googleapis.com/v1/projects/ride-b1bd8/messages:send'),
+            headers: <String, String>{
+              'Content-Type': 'application/json',
+              'Authorization': 'Bearer $accessToken',
+            },
+            body: jsonEncode({
+              'message': {
+                'token': token,
+                'notification': {
+                  'title': title,
+                  'body': body,
+                },
+                // 'data': {
+                //   'DriverList': jsonEncode(data),
+                // },
+                'android': {
+                  'priority': 'high', // Set priority to high
+                  'notification': {
+                    'sound': tone,
+                  },
+                },
+                'apns': {
+                  'headers': {
+                    'apns-priority': '10', // Set APNs priority to 10
+                  },
+                  'payload': {
+                    'aps': {
+                      'sound': tone,
+                    },
+                  },
+                },
+              },
+            }),
+          )
+          .whenComplete(() {})
+          .catchError((e) {});
+    }
+  }
+
+  void sendNotificationToPassengerToken(
+      String title, body, token, List<String> map, String tone,
+      {int retryCount = 2}) async {
+    try {
+      if (serviceAccountKeyJson.isEmpty) {
+        print("🔴 Error: Service Account Key is empty");
+        return;
+      }
+      // Initialize AccessTokenManager
+      final accessTokenManager = AccessTokenManager(serviceAccountKeyJson);
+
+      // Obtain an OAuth 2.0 access token
+      final accessToken = await accessTokenManager.getAccessToken();
+      // Log.print('accessToken: ${accessToken}');
+
+      // Send the notification
+      final response = await http.post(
+        Uri.parse(
+            'https://fcm.googleapis.com/v1/projects/ride-b1bd8/messages:send'),
+        headers: <String, String>{
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer $accessToken',
+        },
+        body: jsonEncode({
+          'message': {
+            'token': token,
+            'notification': {
+              'title': title,
+              'body': body,
+            },
+            'data': {
+              'passengerList': jsonEncode(map),
+            },
+            'android': {
+              'priority': 'high', // Set priority to high
+              'notification': {
+                'sound': tone,
+              },
+            },
+            'apns': {
+              'headers': {
+                'apns-priority': '10', // Set APNs priority to 10
+              },
+              'payload': {
+                'aps': {
+                  'sound': tone,
+                },
+              },
+            },
+          },
+        }),
+      );
+
+      if (response.statusCode == 200) {
+        print(
+            'Notification sent successfully. Status code: ${response.statusCode}');
+        print('Response body: ${response.body}');
+      } else {
+        print(
+            'Failed to send notification. Status code: ${response.statusCode}');
+
+        print('Response body: ${response.body}');
+        if (retryCount > 0) {
+          print('Retrying... Attempts remaining: $retryCount');
+          await Future.delayed(
+              const Duration(seconds: 2)); // Optional delay before retrying
+          return sendNotificationToPassengerToken(title, body, token, map, tone,
+              retryCount: retryCount - 1);
+        }
+      }
+    } catch (e) {
+      print('Error sending notification: $e');
+      if (retryCount > 0) {
+        print('Retrying... Attempts remaining: $retryCount');
+        await Future.delayed(
+            const Duration(seconds: 2)); // Optional delay before retrying
+        return sendNotificationToPassengerToken(title, body, token, map, tone,
+            retryCount: retryCount - 1);
+      }
+    }
+  }
+
+  void sendNotificationToPassengerTokenCALL(
+      String title, body, token, List<String> map, String tone,
+      {int retryCount = 2}) async {
+    try {
+      if (serviceAccountKeyJson.isEmpty) {
+        print("🔴 Error: Service Account Key is empty");
+        return;
+      }
+      // Initialize AccessTokenManager
+      final accessTokenManager = AccessTokenManager(serviceAccountKeyJson);
+
+      // Obtain an OAuth 2.0 access token
+      final accessToken = await accessTokenManager.getAccessToken();
+      // Log.print('accessToken: ${accessToken}');
+
+      // Send the notification
+      final response = await http.post(
+        Uri.parse(
+            'https://fcm.googleapis.com/v1/projects/ride-b1bd8/messages:send'),
+        headers: <String, String>{
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer $accessToken',
+        },
+        body: jsonEncode({
+          'message': {
+            'token': token,
+            'notification': {
+              'title': title,
+              'body': body,
+            },
+            'data': {
+              'passengerList': jsonEncode(map),
+            },
+            'android': {
+              'priority': 'high', // Set priority to high
+              'notification': {
+                'sound': tone,
+              },
+            },
+            'apns': {
+              'headers': {
+                'apns-priority': '10', // Set APNs priority to 10
+              },
+              'payload': {
+                'aps': {
+                  'sound': tone,
+                },
+              },
+            },
+          },
+        }),
+      );
+
+      if (response.statusCode == 200) {
+        print(
+            'Notification sent successfully. Status code: ${response.statusCode}');
+        print('Response body: ${response.body}');
+      } else {
+        print(
+            'Failed to send notification. Status code: ${response.statusCode}');
+
+        print('Response body: ${response.body}');
+        if (retryCount > 0) {
+          print('Retrying... Attempts remaining: $retryCount');
+          await Future.delayed(
+              const Duration(seconds: 2)); // Optional delay before retrying
+          return sendNotificationToPassengerTokenCALL(
+              title, body, token, map, tone,
+              retryCount: retryCount - 1);
+        }
+      }
+    } catch (e) {
+      print('Error sending notification: $e');
+      if (retryCount > 0) {
+        print('Retrying... Attempts remaining: $retryCount');
+        await Future.delayed(
+            const Duration(seconds: 2)); // Optional delay before retrying
+        return sendNotificationToPassengerTokenCALL(
+            title, body, token, map, tone,
+            retryCount: retryCount - 1);
+      }
+    }
+  }
+
+  Future<void> sendNotificationToDriverMAP(
+      String title, String body, String token, List<String> data, String tone,
+      {int retryCount = 2}) async {
+    try {
+      if (serviceAccountKeyJson.isEmpty) {
+        print("🔴 Error: Service Account Key is empty");
+        return;
+      }
+
+      // Initialize AccessTokenManager
+      final accessTokenManager = AccessTokenManager(serviceAccountKeyJson);
+      Log.print(
+          'accessTokenManager: ${accessTokenManager.serviceAccountJsonKey}');
+
+      // Obtain an OAuth 2.0 access token
+      final accessToken = await accessTokenManager.getAccessToken();
+      // Log.print('accessToken: ${accessToken}');
+
+      // Send the notification
+      final response = await http.post(
+        Uri.parse(
+            'https://fcm.googleapis.com/v1/projects/intaleq-d48a7/messages:send'),
+        headers: <String, String>{
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer $accessToken',
+        },
+        body: jsonEncode({
+          'message': {
+            'token': token,
+            'notification': {
+              'title': title,
+              'body': body,
+            },
+            'data': {
+              'DriverList': jsonEncode(data),
+            },
+            'android': {
+              'priority': 'high', // Set priority to high
+              'notification': {
+                'sound': tone,
+              },
+            },
+            'apns': {
+              'headers': {
+                'apns-priority': '10', // Set APNs priority to 10
+              },
+              'payload': {
+                'aps': {
+                  'sound': tone,
+                },
+              },
+            },
+          },
+        }),
+      );
+
+      if (response.statusCode == 200) {
+        print(
+            'Notification sent successfully. Status code: ${response.statusCode}');
+        // print('Response token: ${token}');
+      } else {
+        print(
+            'Failed to send notification. Status code: ${response.statusCode}');
+        print('Response body: ${response.body}');
+        if (retryCount > 0) {
+          print('Retrying... Attempts remaining: $retryCount');
+          await Future.delayed(
+              Duration(seconds: 2)); // Optional delay before retrying
+          return sendNotificationToDriverMAP(title, body, token, data, tone,
+              retryCount: retryCount - 1);
+        }
+      }
+    } catch (e) {
+      print('Error sending notification: $e');
+      if (retryCount > 0) {
+        print('Retrying... Attempts remaining: $retryCount');
+        await Future.delayed(
+            Duration(seconds: 2)); // Optional delay before retrying
+        return sendNotificationToDriverMAP(title, body, token, data, tone,
+            retryCount: retryCount - 1);
+      }
+    }
+  }
+
+  Future<void> removeInvalidToken(String token) async {
+    // Remove token from your database/storage
+    // This prevents future attempts to send to invalid tokens
+    print('Removing invalid token from database: $token');
+    // Your database cleanup logic here
+  }
+}
+
+class OverlayContent extends StatelessWidget {
+  final String title;
+  final String body;
+
+  OverlayContent(this.title, this.body);
+
+  @override
+  Widget build(BuildContext context) {
+    return Material(
+      child: Container(
+        padding: const EdgeInsets.all(16.0),
+        color: Colors.white,
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Text(
+              title,
+              style: const TextStyle(fontSize: 24, fontWeight: FontWeight.bold),
+            ),
+            const SizedBox(height: 8.0),
+            Text(
+              body,
+              style: const TextStyle(fontSize: 16),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/controller/firebase/local_notification.dart

@@ -0,0 +1,591 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:sefer_driver/constant/colors.dart';
+import 'package:sefer_driver/views/home/Captin/orderCaptin/order_request_page.dart';
+import 'package:sefer_driver/views/home/Captin/orderCaptin/order_speed_request.dart';
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
+import 'package:get/get.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+import 'package:timezone/data/latest.dart' as tz;
+import 'package:timezone/timezone.dart' as tz;
+import '../../constant/box_name.dart';
+import '../../main.dart';
+import '../../print.dart';
+import '../../views/notification/notification_captain.dart';
+import '../home/captin/home_captain_controller.dart';
+
+class NotificationController extends GetxController {
+  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
+      FlutterLocalNotificationsPlugin();
+
+  Future<void> initNotifications() async {
+    const AndroidInitializationSettings android =
+        AndroidInitializationSettings('@mipmap/launcher_icon');
+    DarwinInitializationSettings ios = DarwinInitializationSettings(
+      requestAlertPermission: true,
+      requestBadgePermission: true,
+      requestSoundPermission: true,
+      // onDidReceiveLocalNotification:
+      //     (int id, String? title, String? body, String? payload) async {},
+    );
+    InitializationSettings initializationSettings =
+        InitializationSettings(android: android, iOS: ios);
+    tz.initializeTimeZones();
+    print('Notifications initialized');
+    await _flutterLocalNotificationsPlugin.initialize(
+      initializationSettings,
+      onDidReceiveNotificationResponse: onDidReceiveNotificationResponse,
+      onDidReceiveBackgroundNotificationResponse: notificationTapBackground,
+    );
+
+    // Create a notification channel
+    const AndroidNotificationChannel channel = AndroidNotificationChannel(
+      'high_importance_channel', // Use the same ID as in strings.xml
+      'High Importance Notifications',
+      description: 'This channel is used for important notifications.',
+      importance: Importance.high,
+    );
+
+    // Register the channel with the system
+    await _flutterLocalNotificationsPlugin
+        .resolvePlatformSpecificImplementation<
+            AndroidFlutterLocalNotificationsPlugin>()
+        ?.createNotificationChannel(channel);
+  }
+
+  // Displays a notification with the given title and message
+  void showNotification(
+      String title, String message, String tone, String payLoad) async {
+    BigTextStyleInformation bigTextStyleInformation = BigTextStyleInformation(
+      message,
+      contentTitle: title.tr,
+      htmlFormatContent: true,
+      htmlFormatContentTitle: true,
+    );
+    AndroidNotificationDetails android = AndroidNotificationDetails(
+      'high_importance_channel',
+      'High Importance Notifications',
+      importance: Importance.max,
+      priority: Priority.high,
+      sound: RawResourceAndroidNotificationSound(tone),
+    );
+
+    // AndroidNotificationDetails android = AndroidNotificationDetails(
+    //   'high_importance_channel', // Use the same ID as before
+    //   'High Importance Notifications',
+    //   importance: Importance.high,
+    //   priority: Priority.high,
+    //   styleInformation: bigTextStyleInformation,
+    //   playSound: true,
+    //   sound: RawResourceAndroidNotificationSound(tone),
+    //   // audioAttributesUsage: AudioAttributesUsage.alarm,
+    //   visibility: NotificationVisibility.public,
+    //   autoCancel: false,
+    //   color: AppColor.primaryColor,
+    //   showProgress: true,
+    //   showWhen: true,
+    //   ongoing: true,
+    //   enableVibration: true,
+    //   vibrationPattern: Int64List.fromList([0, 1000, 500, 1000]),
+    //   timeoutAfter: 14500,
+    //   setAsGroupSummary: true,
+    //   subText: message, fullScreenIntent: true,
+    //   actions: [
+    //     AndroidNotificationAction(
+    //       allowGeneratedReplies: true,
+    //       'id',
+    //       title.tr,
+    //       titleColor: AppColor.blueColor,
+    //       showsUserInterface: true,
+    //     )
+    //   ],
+    //   category: AndroidNotificationCategory.message,
+    // );
+
+    DarwinNotificationDetails ios = const DarwinNotificationDetails(
+      sound: 'default',
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+    NotificationDetails details =
+        NotificationDetails(android: android, iOS: ios);
+
+    await _flutterLocalNotificationsPlugin.show(0, title, message, details,
+        payload: jsonEncode({'title': title, 'data': payLoad}));
+  }
+
+  void scheduleNotificationAtSpecificTime(
+      String title, String message, String tone, int hour, int minute) async {
+    // Initialize and set Cairo time zone
+    tz.initializeTimeZones();
+    var cairoLocation;
+    if (box.read(BoxName.countryCode).toString() == 'Egypt') {
+      cairoLocation = tz.getLocation('Africa/Cairo');
+    } else {} // todo get for location country
+
+    final AndroidNotificationDetails android = AndroidNotificationDetails(
+      'high_importance_channel',
+      'High Importance Notifications',
+      importance: Importance.max,
+      priority: Priority.high,
+      showWhen: false,
+      sound: RawResourceAndroidNotificationSound(tone),
+    );
+
+    const DarwinNotificationDetails ios = DarwinNotificationDetails(
+      sound: 'default',
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+
+    final NotificationDetails details =
+        NotificationDetails(android: android, iOS: ios);
+
+    final now =
+        tz.TZDateTime.now(cairoLocation); // Use Cairo timezone for current time
+    tz.TZDateTime scheduledTime = tz.TZDateTime(
+        cairoLocation, now.year, now.month, now.day, hour, minute);
+
+    // If the scheduled time has already passed for today, schedule it for the next day
+    if (scheduledTime.isBefore(now)) {
+      scheduledTime = scheduledTime.add(const Duration(days: 1));
+    }
+
+    if (Platform.isAndroid) {
+      if (await Permission.scheduleExactAlarm.isDenied) {
+        if (await Permission.scheduleExactAlarm.request().isGranted) {
+          print('SCHEDULE_EXACT_ALARM permission granted');
+        } else {
+          print('SCHEDULE_EXACT_ALARM permission denied');
+          return;
+        }
+      }
+    }
+
+    print('Current time: $now');
+    print('Scheduling notification for: $scheduledTime');
+    await _flutterLocalNotificationsPlugin.zonedSchedule(
+      0,
+      title,
+      message,
+      scheduledTime,
+      details,
+      // androidAllowWhileIdle: true,
+      uiLocalNotificationDateInterpretation:
+          UILocalNotificationDateInterpretation.absoluteTime,
+      matchDateTimeComponents: DateTimeComponents.time,
+      androidScheduleMode:
+          AndroidScheduleMode.alarmClock, // Triggers daily at the same time
+    );
+    print('Notification scheduled successfully');
+  }
+
+  void scheduleNotificationAfter1Minute(
+      String title, String message, String tone) async {
+    final AndroidNotificationDetails android = AndroidNotificationDetails(
+      'high_importance_channel',
+      'High Importance Notifications',
+      importance: Importance.max,
+      priority: Priority.high,
+      showWhen: false,
+      sound: RawResourceAndroidNotificationSound(tone),
+    );
+
+    const DarwinNotificationDetails ios = DarwinNotificationDetails(
+      sound: 'default',
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+
+    final NotificationDetails details =
+        NotificationDetails(android: android, iOS: ios);
+
+// Schedule the notification to be shown after 1 minute
+    Timer.periodic(const Duration(seconds: 15), (timer) async {
+      final now = tz.TZDateTime.now(tz.local);
+      final scheduledTime = now.add(const Duration(seconds: 10));
+      Log.print('scheduledTime: ${scheduledTime}');
+      if (Platform.isAndroid) {
+        if (await Permission.scheduleExactAlarm.isDenied) {
+          if (await Permission.scheduleExactAlarm.request().isGranted) {
+            print('SCHEDULE_EXACT_ALARM permission granted');
+          } else {
+            print('SCHEDULE_EXACT_ALARM permission denied');
+            return;
+          }
+        }
+      }
+
+      print('Scheduling notification for: $scheduledTime');
+      await _flutterLocalNotificationsPlugin.zonedSchedule(
+        0,
+        title,
+        message,
+        scheduledTime,
+        details,
+        uiLocalNotificationDateInterpretation:
+            UILocalNotificationDateInterpretation.absoluteTime,
+        matchDateTimeComponents: DateTimeComponents.time,
+        androidScheduleMode: AndroidScheduleMode.alarmClock,
+      );
+      print('Notification scheduled successfully');
+    });
+  }
+
+  void scheduleNotificationsForSevenDays(
+      String title, String message, String tone) async {
+    final AndroidNotificationDetails android = AndroidNotificationDetails(
+      'high_importance_channel',
+      'High Importance Notifications',
+      importance: Importance.max,
+      priority: Priority.high,
+      sound: RawResourceAndroidNotificationSound(tone),
+    );
+
+    const DarwinNotificationDetails ios = DarwinNotificationDetails(
+      sound: 'default',
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+
+    final NotificationDetails details =
+        NotificationDetails(android: android, iOS: ios);
+
+    // Check for the exact alarm permission on Android 12 and above
+    if (Platform.isAndroid) {
+      if (await Permission.scheduleExactAlarm.isDenied) {
+        if (await Permission.scheduleExactAlarm.request().isGranted) {
+          print('SCHEDULE_EXACT_ALARM permission granted');
+        } else {
+          print('SCHEDULE_EXACT_ALARM permission denied');
+          return;
+        }
+      }
+    }
+
+    // Schedule notifications for the next 7 days
+    for (int day = 0; day < 7; day++) {
+      // List of notification times
+      final notificationTimes = [
+        {'hour': 8, 'minute': 0, 'id': day * 1000 + 1}, // 8:00 AM
+        {'hour': 15, 'minute': 0, 'id': day * 1000 + 2}, // 3:00 PM
+        {'hour': 20, 'minute': 0, 'id': day * 1000 + 3}, // 8:00 PM
+      ];
+
+      for (var time in notificationTimes) {
+        final notificationId = time['id'] as int;
+
+        // Check if this notification ID is already stored
+        bool isScheduled = box.read('notification_$notificationId') ?? false;
+
+        if (!isScheduled) {
+          // Schedule the notification if not already scheduled
+          await _scheduleNotificationForTime(
+            day,
+            time['hour'] as int,
+            time['minute'] as int,
+            title,
+            message,
+            details,
+            notificationId,
+          );
+
+          // Mark this notification ID as scheduled in GetStorage
+          box.write('notification_$notificationId', true);
+        } else {
+          print('Notification with ID $notificationId is already scheduled.');
+        }
+      }
+    }
+
+    print('Notifications scheduled successfully for the next 7 days');
+  }
+
+  Future<void> _scheduleNotificationForTime(
+    int dayOffset,
+    int hour,
+    int minute,
+    String title,
+    String message,
+    NotificationDetails details,
+    int notificationId,
+  ) async {
+    // Initialize and set Cairo timezone
+    tz.initializeTimeZones();
+    var cairoLocation = tz.getLocation('Africa/Cairo');
+
+    final now = tz.TZDateTime.now(cairoLocation);
+    tz.TZDateTime scheduledDate = tz.TZDateTime(
+      cairoLocation,
+      now.year,
+      now.month,
+      now.day + dayOffset, // Add offset to schedule for the next days
+      hour,
+      minute,
+    );
+
+    // If the scheduled time is in the past, move it to the next day
+    if (scheduledDate.isBefore(now)) {
+      scheduledDate = scheduledDate.add(Duration(days: 1));
+    }
+
+    print('Current time (Cairo): $now');
+    print('Scheduling notification for: $scheduledDate');
+
+    await _flutterLocalNotificationsPlugin.zonedSchedule(
+      notificationId, // Unique ID for each notification
+      title,
+      message,
+      scheduledDate,
+      details,
+      androidScheduleMode: AndroidScheduleMode.exact,
+      uiLocalNotificationDateInterpretation:
+          UILocalNotificationDateInterpretation.absoluteTime,
+      matchDateTimeComponents:
+          null, // Don't repeat automatically; we handle 7 days manually
+    );
+
+    print('Notification scheduled successfully for: $scheduledDate');
+  }
+
+  void scheduleNotificationEvery10Hours(
+      String title, String message, String tone) async {
+    final AndroidNotificationDetails android = AndroidNotificationDetails(
+      'high_importance_channel',
+      'High Importance Notifications',
+      importance: Importance.max,
+      priority: Priority.high,
+      showWhen: false,
+      sound: RawResourceAndroidNotificationSound(tone),
+    );
+
+    const DarwinNotificationDetails ios = DarwinNotificationDetails(
+      sound: 'default',
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+
+    final NotificationDetails details =
+        NotificationDetails(android: android, iOS: ios);
+
+    if (Platform.isAndroid) {
+      if (await Permission.scheduleExactAlarm.isDenied) {
+        if (await Permission.scheduleExactAlarm.request().isGranted) {
+          print('SCHEDULE_EXACT_ALARM permission granted');
+        } else {
+          print('SCHEDULE_EXACT_ALARM permission denied');
+          return;
+        }
+      }
+    }
+
+    Timer.periodic(const Duration(hours: 10), (timer) async {
+      final now = tz.TZDateTime.now(tz.local);
+      final scheduledTime = now.add(const Duration(minutes: 10));
+
+      print('Scheduling notification for: $scheduledTime');
+      await _flutterLocalNotificationsPlugin.zonedSchedule(
+        0,
+        title.tr,
+        message.tr,
+        scheduledTime,
+        details,
+        // androidAllowWhileIdle: true,
+        uiLocalNotificationDateInterpretation:
+            UILocalNotificationDateInterpretation.absoluteTime,
+        matchDateTimeComponents: DateTimeComponents.time,
+        androidScheduleMode: AndroidScheduleMode.alarmClock,
+      );
+    });
+
+    print('Notifications scheduled every 5 seconds');
+  }
+
+  void showTimerNotification(String title, String message, String tone) async {
+    final FlutterLocalNotificationsPlugin flutterLocalNotificationsPlugin =
+        FlutterLocalNotificationsPlugin();
+
+    // Setup Android notification
+    final AndroidNotificationDetails android = AndroidNotificationDetails(
+      'high_importance_channel',
+      'High Importance Notifications',
+      importance: Importance.max,
+      priority: Priority.high,
+      showWhen: false,
+      sound: RawResourceAndroidNotificationSound(
+          tone), // tone without the file extension
+    );
+
+    // Setup iOS notification
+    const DarwinNotificationDetails ios = DarwinNotificationDetails(
+      sound: 'default',
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+
+    final NotificationDetails details =
+        NotificationDetails(android: android, iOS: ios);
+
+    // Request permission on Android
+    if (Platform.isAndroid) {
+      if (await Permission.scheduleExactAlarm.isDenied) {
+        if (await Permission.scheduleExactAlarm.request().isGranted) {
+          print('SCHEDULE_EXACT_ALARM permission granted');
+        } else {
+          print('SCHEDULE_EXACT_ALARM permission denied');
+          return;
+        }
+      }
+    }
+
+    // Timer duration (e.g., 120 seconds countdown)
+    int countdown = 12;
+
+    // Display the notification initially with the full countdown time
+
+    // Timer to update the notification every second
+    Timer.periodic(const Duration(seconds: 1), (timer) async {
+      // if (countdown > 0) {
+      // Update the existing notification with the updated countdown
+
+      // Decrease the countdown by 1
+      countdown--;
+      // } else {
+      //   // Cancel the timer when the countdown reaches zero
+      //   timer.cancel();
+      // }
+    });
+    await flutterLocalNotificationsPlugin.show(
+      0,
+      title,
+      '$message Remaining: $countdown seconds', // Initial message
+      details,
+    );
+    print('Notification will update every second');
+  }
+
+  // Callback when the notification is tapped
+  void onDidReceiveNotificationResponse(NotificationResponse response) {
+    handleNotificationResponse(response);
+  }
+
+  // Callback when the notification is tapped while the app is in the background
+  void onDidReceiveBackgroundNotificationResponse(
+      NotificationResponse response) {
+    handleNotificationResponse(response);
+  }
+
+  // Handle notification response for both foreground and background
+  void handleNotificationResponse(NotificationResponse response) {
+    print('Notification tapped!');
+    Log.print('response.payload: ${response.payload}');
+    if (response.payload != null) {
+      print('Notification payload: ${response.payload}');
+      var payloadData = jsonDecode(response.payload.toString());
+
+      if (payloadData is Map<String, dynamic>) {
+        String title = payloadData['title'];
+        var data = payloadData['data'];
+
+        switch (title) {
+          case 'Order':
+            _handleOrderNotification(data);
+            break;
+          case 'OrderSpeed':
+            _handleOrderSpeedNotification(data);
+            break;
+          case 'ADS':
+            _handleADSNotification();
+            break;
+          default:
+            Log.print('Unknown notification type');
+        }
+      } else {
+        Log.print('Invalid payload format');
+      }
+    } else {
+      Log.print('Payload is null');
+    }
+  }
+
+  void _handleOrderNotification(dynamic data) {
+    if (data is String) {
+      var orderData = jsonDecode(data);
+      if (orderData is List && orderData.length == 34) {
+        //closeOverLay();
+        Get.put(HomeCaptainController()).changeRideId();
+        Get.to(() => OrderRequestPage(), arguments: {'myListString': data});
+      } else {
+        Log.print('Invalid order data');
+      }
+    } else {
+      Log.print('Invalid order payload');
+    }
+  }
+
+  void _handleOrderSpeedNotification(dynamic data) {
+    if (data is String) {
+      var orderData = jsonDecode(data);
+      if (orderData is List && orderData.length == 34) {
+        //closeOverLay();
+        Get.put(HomeCaptainController()).changeRideId();
+        Get.to(() => OrderRequestPage(), arguments: {'myListString': data});
+      } else {
+        Log.print('Invalid order data');
+      }
+    } else {
+      Log.print('Invalid order payload');
+    }
+  }
+
+  void _handleADSNotification() {
+    // var orderData = jsonDecode(data);
+    //closeOverLay();
+    Get.to(
+      () => const NotificationCaptain(),
+    );
+  }
+
+  void onDidReceiveLocalNotification(
+      int id, String? title, String? body, String? payload) async {
+    // display a dialog with the notification details, tap ok to go to another page
+  }
+}
+
+class NotificationController1 extends GetxController {
+  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
+      FlutterLocalNotificationsPlugin();
+
+  // Initializes the local notifications plugin
+  Future<void> initNotifications() async {
+    const AndroidInitializationSettings android =
+        AndroidInitializationSettings('@mipmap/launcher_icon');
+    const InitializationSettings initializationSettings =
+        InitializationSettings(android: android);
+    await _flutterLocalNotificationsPlugin.initialize(initializationSettings);
+  }
+
+  // Displays a notification with the given title and message
+  void showNotification(
+      String title, String message, String tone, String payLoad) async {
+    AndroidNotificationDetails android = AndroidNotificationDetails(
+        'your channel id', 'your channel name',
+        importance: Importance.max,
+        priority: Priority.high,
+        showWhen: false,
+        sound: RawResourceAndroidNotificationSound(tone));
+
+    NotificationDetails details = NotificationDetails(android: android);
+    await _flutterLocalNotificationsPlugin.show(0, title, message, details);
+  }
+}

lib/controller/firebase/order_lay.dart

@@ -0,0 +1,35 @@
+import 'package:sefer_driver/constant/links.dart';
+import 'package:sefer_driver/controller/functions/crud.dart';
+import 'package:sefer_driver/views/home/Captin/home_captain/home_captin.dart';
+import 'package:sefer_driver/views/widgets/elevated_btn.dart';
+import 'package:flutter/material.dart';
+
+class OverlayContent1 extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Material(
+      child: Container(
+        padding: EdgeInsets.all(16.0),
+        color: Colors.white,
+        child: MyElevatedButton(
+          title: 'go to order',
+          onPressed: () async {
+            var res = await CRUD().post(
+              link: AppLink.addFeedBack,
+              payload: {
+                "passengerId": 'dddddd',
+                "feedBack": "eeeee",
+              },
+            );
+            print(res);
+            if (res != 'failure') {
+              Navigator.push(
+                  context, MaterialPageRoute(builder: (cont) => HomeCaptain()));
+              // Get.to(OrderRequestPage());
+            }
+          },
+        ),
+      ),
+    );
+  }
+}