FirebaseMessaging.onMessageOpenedApp.listen never trigered

[NikhilKottarathil]

import 'dart:async';
import 'dart:convert';
import 'package:ev_charge/authentication/location_permission.dart';
import 'package:ev_charge/authentication/splash_screen.dart';
import 'package:ev_charge/blocs/application_bloc.dart';
import 'package:ev_charge/functions/api_calls.dart';
import 'package:ev_charge/my_wallet.dart';
import 'package:ev_charge/providers/FavouriteProvider.dart';
import 'package:ev_charge/providers/basic_provider.dart';
import 'package:ev_charge/providers/booking_provider.dart';
import 'package:ev_charge/providers/staion_and_machine_provider.dart';
import 'package:ev_charge/providers/vehicle_provider.dart';
import 'package:ev_charge/tabs/Ordering/ordering_step_3.dart';
import 'package:ev_charge/tabs/profile.dart';
import 'package:ev_charge/vehicle/vehicle_details_request.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';

import 'package:provider/provider.dart';

Future _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
// If you're going to use other Firebase services in the background, such as Firestore,
// make sure you call initializeApp before using other Firebase services.
await Firebase.initializeApp();
;
}

AndroidNotificationChannel channel = const AndroidNotificationChannel(
'high_importance_channel', // id
'High Importance Notifications', // title
'This channel is used for important notifications.', // description
importance: Importance.high,
);
FlutterLocalNotificationsPlugin flutterLocalNotificationsPlugin =
FlutterLocalNotificationsPlugin();

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

// Set the background messaging handler early on, as a named top-level function
FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);

await flutterLocalNotificationsPlugin
.resolvePlatformSpecificImplementation<
AndroidFlutterLocalNotificationsPlugin>()
?.createNotificationChannel(channel);
runApp(new MyApp());
}

// Future selectNotificationBackGround(String payload) async {
// await Future.delayed(const Duration(milliseconds: 200),
// () => Navigator.pushNamed(MyApp.navigatorKey.currentContext, '/Profile'));
// }

Future selectNotification(String payload) async {
print('selected Notification');
print(payload);
var messageData = json.decode(payload);

var messageType = messageData['type'];
if (messageType == 'wallet') {
await Future.delayed(
const Duration(milliseconds: 200),
() => MyApp.navigatorKey.currentState
.push(MaterialPageRoute(builder: (context) => MyWallet())));
Provider.of(MyApp.navigatorKey.currentContext, listen: false)
.setTabBarInitialIndex(4);
} else if (messageType == 'order') {
await Future.delayed(
const Duration(milliseconds: 200),
() => MyApp.navigatorKey.currentState.push(MaterialPageRoute(
builder: (context) => OrderingStep3(
orderID: messageData['order_id'],
parentPage: 'Main',
))));
} else {
//for machine add section
}
}

class MyApp extends StatefulWidget {
// This widget is the root of your application.
static final navigatorKey = new GlobalKey();

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

class _MyAppState extends State {
String token;

@OverRide
void initState() {
// TODO: implement initState
super.initState();

const AndroidInitializationSettings initializationSettingsAndroid =
    AndroidInitializationSettings('@mipmap/ic_launcher');
final IOSInitializationSettings initializationSettingsIOS =
    IOSInitializationSettings();
final MacOSInitializationSettings initializationSettingsMacOS =
    MacOSInitializationSettings();
final InitializationSettings initializationSettings =
    InitializationSettings(
        android: initializationSettingsAndroid,
        iOS: initializationSettingsIOS,
        macOS: initializationSettingsMacOS);

flutterLocalNotificationsPlugin.initialize(initializationSettings,
    onSelectNotification: selectNotification);

FirebaseMessaging.onMessage.listen((RemoteMessage message) {
  print('message');
  print(message.data);
  print(message.data);
  RemoteNotification notification = message.notification;
  AndroidNotification android = message.notification?.android;
  if (notification != null && android != null && !kIsWeb) {
    flutterLocalNotificationsPlugin.show(
        notification.hashCode,
        notification.title,
        notification.body,
        NotificationDetails(
          android: AndroidNotificationDetails(
            channel.id,
            channel.name,
            channel.description,
            // TODO add a proper drawable resource to android, for now using
            //      one that already exists in example app.
          ),
        ),
        payload: json.encode(message.data));
  }
});

setupInteractedMessage();

getToken();

}

@OverRide
Widget build(BuildContext context) {
SystemChrome.setPreferredOrientations([
DeviceOrientation.portraitUp,
]);
SystemChrome.setSystemUIOverlayStyle(SystemUiOverlayStyle(
statusBarColor: Colors.white,
statusBarIconBrightness: Brightness.dark));

return MultiProvider(
  providers: [
    ChangeNotifierProvider(create: (_) => ApplicationBloc()),
    ChangeNotifierProvider(create: (_) => FavouriteProvider()),
    ChangeNotifierProvider(create: (_) => BasicProvider()),
    ChangeNotifierProvider(create: (_) => BookingProvider()),
    ChangeNotifierProvider(create: (_) => VehicleProvider()),
    ChangeNotifierProvider(create: (_) => StationAndMachineProvider()),
  ],
  child: new MaterialApp(
    navigatorKey: MyApp.navigatorKey,
    title: 'ev-Space',
    theme: new ThemeData(
      fontFamily: 'Inter',
      scaffoldBackgroundColor: Colors.grey.shade50,
      // scaffoldBackgroundColor: AppColors.BackgroundColor,
      primaryColor: const Color(0xFF009060),
      primaryColorBrightness: Brightness.dark,
    ),
    home: SplashScreen(),
    debugShowCheckedModeBanner: false,
  ),
);

}

getToken() async {
token = await FirebaseMessaging.instance.getToken();
setState(() {
token = token;
});
print(token);
}

Future setupInteractedMessage() async {
// Get any messages which caused the application to open from
// a terminated state.
RemoteMessage initialMessage =
await FirebaseMessaging.instance.getInitialMessage();

// If the message also contains a data property with a "type" of "chat",
// navigate to a chat screen
// if (initialMessage != null && initialMessage.data['type'] == 'chat') {
if (initialMessage != null) {
  var messageData = initialMessage.data;

  var messageType = messageData['type'];
  messageType = 'wallet';
  if (messageType == 'wallet') {
    Provider.of<BasicProvider>(MyApp.navigatorKey.currentContext,
            listen: false)
        .setTabBarInitialIndex(4);

    await Future.delayed(
        const Duration(milliseconds: 200),
        () => MyApp.navigatorKey.currentState
            .push(MaterialPageRoute(builder: (context) => MyWallet())));
  } else if (messageType == 'order') {
    Provider.of<BasicProvider>(MyApp.navigatorKey.currentContext,
            listen: false)
        .setTabBarInitialIndex(1);
    await Future.delayed(
        const Duration(milliseconds: 200),
        () => MyApp.navigatorKey.currentState.push(MaterialPageRoute(
            builder: (context) => OrderingStep3(
                  orderID: messageData['order_id'],
                  parentPage: 'Main',
                ))));
  } else {
    //for machine add section
  }

  // Navigator.pushNamed(context, '/LocationPermission',);
}

// Also handle any interaction when the app is in the background via a
// Stream listener
FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
  // if (message.data['type'] == 'chat') {
  print('initial message opened');

  // }
});

}
}