lyrics-grabbr/lib/main.dart

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:android_notification_listener2/android_notification_listener2.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';

final FlutterLocalNotificationsPlugin flutterLocalNotificationsPlugin =
    FlutterLocalNotificationsPlugin();

const spotifyPackage = "com.spotify.music";
const notificationId = 0;

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // TODO: do the preconfiguration for the android notifications.
  // e.g: notification icon
  const AndroidInitializationSettings initializationSettingsAndroid =
      AndroidInitializationSettings('@mipmap/ic_launcher');
  const InitializationSettings initializationSettings = InitializationSettings(
      android: initializationSettingsAndroid
  );
  await flutterLocalNotificationsPlugin.initialize(
      initializationSettings,
      onSelectNotification: onNotificationClick
  );

  runApp(const LyricsGrabbr());
}

void onNotificationClick(String? payload) async {
  if (payload != null) {
    print('notification payload: $payload');
  }
  print('notification pressed');
}

class LyricsGrabbr extends StatelessWidget {
  const LyricsGrabbr({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Lyrics Grabbr',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const HomePage(title: 'Lyrics Grabbr'),
    );
  }
}

class HomePage extends StatefulWidget {
  const HomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<HomePage> createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> with WidgetsBindingObserver {
  late AndroidNotificationListener _notifications;
  late StreamSubscription<NotificationEventV2> _subscription;
  BuildContext? permissionDialogCtx;
  final List<NotificationEventV2> _notifs = [];
  bool running = false;

  @override
  void initState() {
    WidgetsBinding.instance?.addObserver(this);
    initPlatformState();
    super.initState();
  }

  @override
  void dispose() {
    WidgetsBinding.instance?.removeObserver(this);
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) async {
    if (state == AppLifecycleState.resumed) {
      if (permissionDialogCtx == null) {
        return;
      }

      var perm = await AndroidNotificationListener.hasPermission;

      if (perm != null && perm) {
        Navigator.pop(permissionDialogCtx!);
        startListening();
      }
    }
  }

  void showNotificationPermDialog() {
      showDialog(
          context: context,
          barrierDismissible: false,
          builder: (BuildContext buildCtx) {
            permissionDialogCtx = buildCtx;

            return WillPopScope(
              onWillPop: () {
                SystemNavigator.pop();
                return Future.value(false);
              },
              child: Expanded(
                  child: AlertDialog(
                      title: const Text(
                          'Notifications Access Permission',
                          style: TextStyle(
                              fontWeight: FontWeight.bold
                          ),
                      ),
                      content: const Text(
                          'This app requires permission to listen to notifications to function properly. Please grant permission in the next screen.',
                          style: TextStyle(
                              color: Colors.blueGrey
                          ),
                      ),
                      actions: [
                        TextButton(
                            onPressed: () async {
                              await AndroidNotificationListener.openPermissionSettings();
                            },
                            child: const Text("OK")
                        ),
                      ],
                  ),
              ),
            );
          });
  }

  Future<void> initPlatformState() async {
    var perm = await AndroidNotificationListener.hasPermission;

    if (perm != null && perm) {
      startListening();
    } else {
      showNotificationPermDialog();
    }
  }

  void onData(NotificationEventV2 event) {
    if (event.packageName == spotifyPackage) {
      // TODO: if the app is in the background, only update our notif
      // if the app is in the foreground, update the notif, and 
      // fetch the new lyrics and display them.
      var song = event.packageText;
      var artist = event.packageMessage;
      sendNotification(song, artist);
      setState(() {
        _notifs.add(event);
      });
    }
  }

  Future<void> sendNotification(String title, String body) async {
    const AndroidNotificationDetails androidNotification = AndroidNotificationDetails(
        "Lyrics",
        "Lyrics",
        importance: Importance.low,
        priority: Priority.min,
        showWhen: false,
        ongoing: true,
        playSound: false,
    );

    const NotificationDetails notificationDetails = NotificationDetails(
        android: androidNotification
    );

    await flutterLocalNotificationsPlugin.show(
        notificationId,
        title,
        body,
        notificationDetails,
    );
  }

  void startListening() {
    // TODO: make the FAB start and stop a local notification service
    // that keeps track of which song is playing
    // and if pressed will fetch the lyrics and display them.

    _notifications = AndroidNotificationListener();

    _subscription = _notifications.notificationStream.listen(onData);
    setState(() => running = true);
  }

  void stopListening() {
    setState(() => running = false);
    _subscription.cancel();
    flutterLocalNotificationsPlugin.cancel(notificationId);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: ListView.builder(
          itemCount: _notifs.length,
          reverse: true,
          itemBuilder: (BuildContext context, int idx) {
            final entry = _notifs[idx];
            return ListTile(
              leading: Text(entry.packageText),
              trailing: Text(entry.packageMessage),
            );
          }
        ),
      floatingActionButton: FloatingActionButton(
        onPressed: running ? stopListening : startListening,
        tooltip: running ? 'Stop service' : "Start service",
        child: running ? const Icon(Icons.stop) : const Icon(Icons.play_arrow),
      ),
    );
  }
}