How to show a disclosure window before asking for location permission in flutter

here are the current changes that made it happen:

    class MyApp extends StatefulWidget {
  static LocationService? locationService = LocationService();
  const MyApp({
    Key? key,
    required this.homepage,
    required this.isLoggedIn,
    required this.isLightTheme,
  }) : super(key: key);
  final bool? isLoggedIn;
  final String homepage;
  final bool isLightTheme;

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

class _MyAppState extends State<MyApp> {
  //LocationService? locationService;
  @override
  void initState() {
    super.initState();
    PedometerService.instance.init();
    //locationService = LocationService();
    startLocation();
  }

  Future<void> startLocation() async {
    await MyApp.locationService?.getLocationOnchange(context);
    MyApp.locationService?.getListener();
    startLocationStream();
  }
 

 @override
  Widget build(BuildContext context) {
    if (widget.isLoggedIn ?? false) {
      MyApp.locationService ??= LocationService();
      startLocation();
    }

return MaterialApp(
  title: 'Semdatex Patient Portal',
  debugShowCheckedModeBanner: false,
  theme: widget.isLightTheme ? lightMode : darkMode,
  localizationsDelegates: context.localizationDelegates,
  supportedLocales: context.supportedLocales,
  locale: context.locale,
  initialRoute: widget.homepage,
  home: PushMessaging(
    isLoggedIn: widget.isLoggedIn,
    homepage: widget.homepage,
    title: "Semdatex Patient Portal",
  ),
  routes: { ...rest

I removed it from main:

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp();
  await EasyLocalization.ensureInitialized();

  final messaging = FirebaseMessaging.instance;
  final routeFromMessageCompleter = Completer<String>();

  // Request permission for receiving notifications
  await messaging.requestPermission(
    alert: true,
    announcement: false,
    badge: true,
    carPlay: false,
    criticalAlert: false,
    provisional: false,
    sound: true,
  );

  // Get the initial message if available
  messaging.getInitialMessage().then((message) {
    if (message != null) {
      routeFromMessageCompleter.complete("/${message.data['route']}");
    } else {
      routeFromMessageCompleter.complete("");
    }
  });

  // Background message handling
  FirebaseMessaging.onBackgroundMessage(backgroundHandler);

  // Initialize FlutterLocalNotificationsPlugin
  if (!kIsWeb) {
    channel = const AndroidNotificationChannel(
      'high_importance_channel',
      'High Importance Notifications',
      importance: Importance.high,
    );
    flutterLocalNotificationsPlugin = FlutterLocalNotificationsPlugin();
    await flutterLocalNotificationsPlugin
        .resolvePlatformSpecificImplementation<AndroidFlutterLocalNotificationsPlugin>()
        ?.createNotificationChannel(channel);
  }

  // Get FCM token and save it
  final fcmToken = await messaging.getToken();
  SharedPref.saveFCMToken(fcmToken);

  // Check if the user is logged in
  final bool isLoggedIn = await SharedPref.getUserLoginSharedPrefernces() ?? false;
  final String routeFromMessage = await routeFromMessageCompleter.future;
  String route = isLoggedIn && routeFromMessage != '' ? routeFromMessage : (isLoggedIn ? '/' : '/loginScreen');
  runApp(
      MaterialApp(
        home: Builder(
      builder: (context) {
        return EasyLocalization(
          supportedLocales: const [
            Locale('en', 'US'),
            Locale('es', 'ES'),
            Locale('nl', 'NL'),
            Locale('de', 'DE'),
          ],
          path: 'i18n',
          fallbackLocale: const Locale('en', 'US'),
          child: MyApp(
            homepage: route,
            isLoggedIn: isLoggedIn,
            isLightTheme: true,
          ),
        );
      },
    ),
  ),
  );
}

and here is the location service itself:

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:location/location.dart';
import 'package:permission_handler/permission_handler.dart' as perm;

import '../../Datamodel/user_location.dart';

class LocationService {
  static final LocationService _instance = LocationService._internal();
  bool _isStreamInitialized = false;

  factory LocationService() {
    return _instance;
  }

  LocationService._internal({BuildContext? context}) {
    if (context != null) {
      getLocationOnchange(context);
    }
  }

  Location location = Location();
  final StreamController<UserLocation> _locationController =
  StreamController<UserLocation>.broadcast();
  StreamSubscription<LocationData>? listener;

  Stream<UserLocation> get locationStream => _locationController.stream;

  Future<void> getLocationOnchange(BuildContext context) async {
    await showPermissionDialogAndAskPermission(context, perm.Permission.location);
    listener ??= initListener();
  }

  Future<void> showPermissionDialogAndAskPermission(
      BuildContext context, perm.Permission permission) async {
    final perm.PermissionStatus status = await permission.status;
    if (status.isGranted) {
      location.enableBackgroundMode(enable: true);
      location.changeSettings(
        interval: 10000,
        accuracy: LocationAccuracy.high,
      );
      listener = initListener();
    } else if (status.isDenied || status.isPermanentlyDenied) {
      showDialog(
        context: context,
        builder: (BuildContext dialogContext) {
          return AlertDialog(
            shape: RoundedRectangleBorder(
              borderRadius: BorderRadius.circular(2.5),
            ),
            title: Row(
              mainAxisAlignment: MainAxisAlignment.spaceBetween,
              children: [
                const Text("Permission required"),
                GestureDetector(
                  onTap: () {
                    Navigator.pop(dialogContext);
                  },
                  child: const Icon(
                    Icons.close,
                    size: 6.0,
                  ),
                ),
              ],
            ),
            content: const Text(
              "This app collects location data to enable suggesting you to do activities which are beneficiary for your health"
                  "even when the app is closed or not in use."
            ),
            actionsPadding: const EdgeInsets.fromLTRB(5, 0, 5, 5.0),
            actions: [
              Row(
                children: [
                  Expanded(
                    child: GestureDetector(
                      onTap: () {
                        Navigator.of(context).pop();
                      },
                      child: const Center(
                        child: Text("Cancel"),
                      ),
                    ),
                  ),
                  Expanded(
                    child: GestureDetector(
                      onTap: () async {
                        Navigator.of(context).pop();
                        final perm.PermissionStatus newStatus = await permission.request();
                        if (newStatus.isGranted) {
                          location.enableBackgroundMode(enable: true);
                          location.changeSettings(
                            interval: 10000,//
                            accuracy: LocationAccuracy.high,
                          );
                          initListenerIfNeeded();
                          //listener = initListener();
                        } else if (newStatus.isDenied) {
                          // Permission denied
                        } else if (newStatus.isPermanentlyDenied) {
                          // Permission permanently denied
                        }
                      },
                      child: const Center(
                        child: Text("Grant"),
                      ),
                    ),
                  ),
                ],
              ),
            ],
            actionsAlignment: MainAxisAlignment.spaceAround,
          );
        },
      );
    } else {
      // Handle other permission statuses if needed
    }
  }

  StreamSubscription<LocationData>? getListener() {
    return listener;
  }

  void initListenerIfNeeded() {
    if (!_isStreamInitialized) {
      listener = initListener();
      _isStreamInitialized = true;
    }
  }
  StreamSubscription<LocationData> initListener() {
    return location.onLocationChanged.listen((locationData) {
      if (!_locationController.isClosed) {
        _locationController.add(UserLocation(
          locationData.latitude,
          locationData.longitude,
          locationData.altitude,
          locationData.time,
        ));
      }
    });
  }

  void dispose() {
    _locationController.close();
    listener?.cancel();
    listener = null;

  }
}