660 lines
21 KiB
Dart
660 lines
21 KiB
Dart
/*
|
|
* Famedly
|
|
* Copyright (C) 2020, 2021 Famedly GmbH
|
|
* Copyright (C) 2021 Fluffychat
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
import 'dart:isolate';
|
|
import 'dart:ui';
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import 'package:firebase_messaging/firebase_messaging.dart';
|
|
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
|
|
import 'package:flutter_new_badger/flutter_new_badger.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:matrix/matrix.dart';
|
|
import 'package:unifiedpush/unifiedpush.dart';
|
|
import 'package:unifiedpush_ui/unifiedpush_ui.dart';
|
|
|
|
import 'package:fluffychat/l10n/l10n.dart';
|
|
import 'package:fluffychat/main.dart';
|
|
import 'package:fluffychat/pangea/common/config/environment.dart';
|
|
import 'package:fluffychat/pangea/common/utils/error_handler.dart';
|
|
import 'package:fluffychat/pangea/common/utils/firebase_analytics.dart';
|
|
import 'package:fluffychat/pangea/join_codes/knock_room_extension.dart';
|
|
import 'package:fluffychat/pangea/languages/language_constants.dart';
|
|
import 'package:fluffychat/utils/notification_background_handler.dart';
|
|
import 'package:fluffychat/utils/push_helper.dart';
|
|
import 'package:fluffychat/widgets/fluffy_chat_app.dart';
|
|
import 'package:fluffychat/widgets/local_notifications_extension.dart';
|
|
import '../config/app_config.dart';
|
|
import '../config/setting_keys.dart';
|
|
import '../widgets/matrix.dart';
|
|
import 'platform_infos.dart';
|
|
|
|
//<GOOGLE_SERVICES>import 'package:fcm_shared_isolate/fcm_shared_isolate.dart';
|
|
|
|
class NoTokenException implements Exception {
|
|
String get cause => 'Cannot get firebase token';
|
|
}
|
|
|
|
class BackgroundPush {
|
|
static BackgroundPush? _instance;
|
|
final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
|
|
FlutterLocalNotificationsPlugin();
|
|
Client client;
|
|
MatrixState? matrix;
|
|
String? _fcmToken;
|
|
void Function(String errorMsg, {Uri? link})? onFcmError;
|
|
L10n? l10n;
|
|
|
|
Future<void> loadLocale() async {
|
|
final context = matrix?.context;
|
|
// inspired by _lookupL10n in .dart_tool/flutter_gen/gen_l10n/l10n.dart
|
|
l10n ??=
|
|
(context != null ? L10n.of(context) : null) ??
|
|
(await L10n.delegate.load(PlatformDispatcher.instance.locale));
|
|
}
|
|
|
|
final pendingTests = <String, Completer<void>>{};
|
|
bool firebaseEnabled = false;
|
|
|
|
//<GOOGLE_SERVICES>final firebase = FcmSharedIsolate();
|
|
|
|
DateTime? lastReceivedPush;
|
|
|
|
bool upAction = false;
|
|
|
|
void _init() async {
|
|
//<GOOGLE_SERVICES>firebaseEnabled = true;
|
|
try {
|
|
// #Pangea
|
|
// Handle notifications when app is opened from terminated/background state
|
|
FirebaseMessaging.instance.getInitialMessage().then(_onOpenNotification);
|
|
FirebaseMessaging.onMessageOpenedApp.listen(_onOpenNotification);
|
|
FirebaseMessaging.onBackgroundMessage(firebaseMessagingBackgroundHandler);
|
|
// Pangea#
|
|
mainIsolateReceivePort?.listen((message) async {
|
|
try {
|
|
await notificationTap(
|
|
NotificationResponseJson.fromJsonString(message),
|
|
client: client,
|
|
router: FluffyChatApp.router,
|
|
l10n: l10n,
|
|
);
|
|
} catch (e, s) {
|
|
Logs().wtf('Main Notification Tap crashed', e, s);
|
|
}
|
|
});
|
|
if (PlatformInfos.isAndroid) {
|
|
final port = ReceivePort();
|
|
IsolateNameServer.removePortNameMapping('background_tab_port');
|
|
IsolateNameServer.registerPortWithName(
|
|
port.sendPort,
|
|
'background_tab_port',
|
|
);
|
|
port.listen((message) async {
|
|
try {
|
|
await notificationTap(
|
|
NotificationResponseJson.fromJsonString(message),
|
|
client: client,
|
|
router: FluffyChatApp.router,
|
|
l10n: l10n,
|
|
);
|
|
} catch (e, s) {
|
|
Logs().wtf('Main Notification Tap crashed', e, s);
|
|
}
|
|
});
|
|
}
|
|
await _flutterLocalNotificationsPlugin.initialize(
|
|
const InitializationSettings(
|
|
// #Pangea
|
|
// android: AndroidInitializationSettings('notifications_icon'),
|
|
// iOS: DarwinInitializationSettings(),
|
|
android: AndroidInitializationSettings('@mipmap/ic_launcher'),
|
|
iOS: DarwinInitializationSettings(
|
|
requestAlertPermission: false,
|
|
requestBadgePermission: false,
|
|
requestSoundPermission: false,
|
|
requestProvisionalPermission: false,
|
|
),
|
|
// Pangea#
|
|
),
|
|
onDidReceiveNotificationResponse: (response) => notificationTap(
|
|
response,
|
|
client: client,
|
|
router: FluffyChatApp.router,
|
|
l10n: l10n,
|
|
),
|
|
onDidReceiveBackgroundNotificationResponse: notificationTapBackground,
|
|
);
|
|
|
|
// #Pangea
|
|
// Handle notifications when app is in foreground
|
|
// Pass additionalData to preserve activity session info for local notifications
|
|
FirebaseMessaging.onMessage.listen((RemoteMessage message) {
|
|
pushHelper(
|
|
PushNotification.fromJson(message.data),
|
|
client: client,
|
|
l10n: l10n,
|
|
activeRoomId: matrix?.activeRoomId,
|
|
flutterLocalNotificationsPlugin: _flutterLocalNotificationsPlugin,
|
|
additionalData: message.data,
|
|
);
|
|
});
|
|
// Pangea#
|
|
|
|
Logs().v('Flutter Local Notifications initialized');
|
|
//<GOOGLE_SERVICES>firebase.setListeners(
|
|
//<GOOGLE_SERVICES> onMessage: (message) => pushHelper(
|
|
//<GOOGLE_SERVICES> PushNotification.fromJson(
|
|
//<GOOGLE_SERVICES> Map<String, dynamic>.from(message['data'] ?? message),
|
|
//<GOOGLE_SERVICES> ),
|
|
//<GOOGLE_SERVICES> client: client,
|
|
//<GOOGLE_SERVICES> l10n: l10n,
|
|
//<GOOGLE_SERVICES> activeRoomId: matrix?.activeRoomId,
|
|
//<GOOGLE_SERVICES> flutterLocalNotificationsPlugin: _flutterLocalNotificationsPlugin,
|
|
//<GOOGLE_SERVICES> ),
|
|
//<GOOGLE_SERVICES> // #Pangea
|
|
//<GOOGLE_SERVICES> onNewToken: (token) {
|
|
//<GOOGLE_SERVICES> _fcmToken = token;
|
|
//<GOOGLE_SERVICES> debugPrint('Fcm token $_fcmToken');
|
|
//<GOOGLE_SERVICES> setupPush();
|
|
//<GOOGLE_SERVICES> },
|
|
//<GOOGLE_SERVICES> // Pangea#
|
|
//<GOOGLE_SERVICES>);
|
|
|
|
if (Platform.isAndroid) {
|
|
await UnifiedPush.initialize(
|
|
onNewEndpoint: _newUpEndpoint,
|
|
onRegistrationFailed: (_, i) => _upUnregistered(i),
|
|
onUnregistered: _upUnregistered,
|
|
onMessage: _onUpMessage,
|
|
);
|
|
}
|
|
} catch (e, s) {
|
|
Logs().e('Unable to initialize Flutter local notifications', e, s);
|
|
}
|
|
}
|
|
|
|
BackgroundPush._(this.client) {
|
|
_init();
|
|
}
|
|
|
|
// #Pangea
|
|
// Helper to ensure a room is loaded or synced.
|
|
Future<Room?> _ensureRoomLoaded(String id, {Membership? membership}) async {
|
|
await client.roomsLoading;
|
|
await client.accountDataLoading;
|
|
|
|
var room = client.getRoomById(id);
|
|
if (room == null || (membership != null && room.membership != membership)) {
|
|
await client.waitForRoomInSync(id).timeout(const Duration(seconds: 30));
|
|
room = client.getRoomById(id);
|
|
}
|
|
return room;
|
|
}
|
|
|
|
// Navigate to activity session or fallback to room
|
|
Future<void> _navigateToActivityOrRoom({
|
|
required String roomId,
|
|
String? sessionRoomId,
|
|
String? activityId,
|
|
}) async {
|
|
Room? room = await _ensureRoomLoaded(roomId);
|
|
// Handle session room if provided.
|
|
if (sessionRoomId != null &&
|
|
sessionRoomId.isNotEmpty &&
|
|
activityId != null &&
|
|
activityId.isNotEmpty) {
|
|
try {
|
|
if (room == null) return;
|
|
final session = client.getRoomById(sessionRoomId);
|
|
if (session?.membership == Membership.join) {
|
|
FluffyChatApp.router.go('/rooms/$sessionRoomId');
|
|
return;
|
|
}
|
|
|
|
FluffyChatApp.router.go(
|
|
'/rooms/spaces/$roomId/activity/$activityId?roomid=$sessionRoomId',
|
|
);
|
|
return;
|
|
} catch (err, s) {
|
|
ErrorHandler.logError(e: err, s: s, data: {"roomId": sessionRoomId});
|
|
}
|
|
}
|
|
|
|
// Fallback: just open the original room.
|
|
try {
|
|
final hasKnocked = room?.hasKnocked;
|
|
if (hasKnocked == true) {
|
|
await room!.joinKnockedRoom();
|
|
room = await _ensureRoomLoaded(roomId, membership: Membership.join);
|
|
}
|
|
|
|
if (room == null || room.membership == Membership.invite) {
|
|
FluffyChatApp.router.go('/rooms');
|
|
return;
|
|
}
|
|
|
|
FluffyChatApp.router.go(
|
|
room.isSpace ? '/rooms/spaces/$roomId' : '/rooms/$roomId',
|
|
);
|
|
} catch (err, s) {
|
|
ErrorHandler.logError(e: err, s: s, data: {"roomId": roomId});
|
|
}
|
|
}
|
|
|
|
Future<void> _onOpenNotification(RemoteMessage? message) async {
|
|
const sessionIdKey = "content_pangea.activity.session_room_id";
|
|
const activityIdKey = "content_pangea.activity.id";
|
|
|
|
// Early return if no room_id.
|
|
final roomId = message?.data['room_id'];
|
|
if (roomId is! String || roomId.isEmpty) return;
|
|
|
|
final sessionRoomId = message?.data[sessionIdKey] as String?;
|
|
final activityId = message?.data[activityIdKey] as String?;
|
|
|
|
await _navigateToActivityOrRoom(
|
|
roomId: roomId,
|
|
sessionRoomId: sessionRoomId,
|
|
activityId: activityId,
|
|
);
|
|
}
|
|
// Pangea#
|
|
|
|
factory BackgroundPush.clientOnly(Client client) {
|
|
return _instance ??= BackgroundPush._(client);
|
|
}
|
|
|
|
factory BackgroundPush(
|
|
MatrixState matrix, {
|
|
final void Function(String errorMsg, {Uri? link})? onFcmError,
|
|
}) {
|
|
final instance = BackgroundPush.clientOnly(matrix.client);
|
|
instance.matrix = matrix;
|
|
// ignore: prefer_initializing_formals
|
|
instance.onFcmError = onFcmError;
|
|
return instance;
|
|
}
|
|
|
|
Future<void> cancelNotification(String roomId) async {
|
|
Logs().v('Cancel notification for room', roomId);
|
|
await _flutterLocalNotificationsPlugin.cancel(roomId.hashCode);
|
|
|
|
// Workaround for app icon badge not updating
|
|
if (Platform.isIOS) {
|
|
// #Pangea
|
|
final enabled = await matrix?.notificationsEnabled;
|
|
if (enabled != true) return;
|
|
// Pangea#
|
|
final unreadCount = client.rooms
|
|
.where((room) => room.isUnreadOrInvited && room.id != roomId)
|
|
.length;
|
|
// #Pangea
|
|
try {
|
|
// Pangea#
|
|
if (unreadCount == 0) {
|
|
FlutterNewBadger.removeBadge();
|
|
} else {
|
|
FlutterNewBadger.setBadge(unreadCount);
|
|
}
|
|
// #Pangea
|
|
} catch (e) {
|
|
GoogleAnalytics.failUpdateNotificationBadge();
|
|
}
|
|
// Pangea#
|
|
return;
|
|
}
|
|
}
|
|
|
|
Future<void> setupPusher({
|
|
String? gatewayUrl,
|
|
String? token,
|
|
Set<String?>? oldTokens,
|
|
bool useDeviceSpecificAppId = false,
|
|
}) async {
|
|
// #Pangea
|
|
// if (PlatformInfos.isIOS) {
|
|
// //<GOOGLE_SERVICES>await firebase.requestPermission();
|
|
// }
|
|
// if (PlatformInfos.isAndroid) {
|
|
// _flutterLocalNotificationsPlugin
|
|
// .resolvePlatformSpecificImplementation<
|
|
// AndroidFlutterLocalNotificationsPlugin
|
|
// >()
|
|
// ?.requestNotificationsPermission();
|
|
// }
|
|
// Pangea#
|
|
final clientName = PlatformInfos.clientName;
|
|
oldTokens ??= <String>{};
|
|
final pushers =
|
|
await (client.getPushers().catchError((e) {
|
|
Logs().w('[Push] Unable to request pushers', e);
|
|
return <Pusher>[];
|
|
})) ??
|
|
[];
|
|
var setNewPusher = false;
|
|
// Just the plain app id, we add the .data_message suffix later
|
|
var appId = AppConfig.pushNotificationsAppId;
|
|
// we need the deviceAppId to remove potential legacy UP pusher
|
|
var deviceAppId = '$appId.${client.deviceID}';
|
|
// appId may only be up to 64 chars as per spec
|
|
if (deviceAppId.length > 64) {
|
|
deviceAppId = deviceAppId.substring(0, 64);
|
|
}
|
|
if (!useDeviceSpecificAppId && PlatformInfos.isAndroid) {
|
|
appId += '.data_message';
|
|
}
|
|
final thisAppId = useDeviceSpecificAppId ? deviceAppId : appId;
|
|
if (gatewayUrl != null && token != null) {
|
|
final currentPushers = pushers.where((pusher) => pusher.pushkey == token);
|
|
if (currentPushers.length == 1 &&
|
|
currentPushers.first.kind == 'http' &&
|
|
currentPushers.first.appId == thisAppId &&
|
|
currentPushers.first.appDisplayName == clientName &&
|
|
currentPushers.first.deviceDisplayName == client.deviceName &&
|
|
currentPushers.first.lang == 'en' &&
|
|
// #Pangea
|
|
currentPushers.first.lang == LanguageKeys.defaultLanguage &&
|
|
// Pangea#
|
|
currentPushers.first.data.url.toString() == gatewayUrl &&
|
|
currentPushers.first.data.format ==
|
|
// #Pangea
|
|
// AppSettings.pushNotificationsPusherFormat.value &&
|
|
null &&
|
|
// Pangea#
|
|
mapEquals(currentPushers.single.data.additionalProperties, {
|
|
"data_message": pusherDataMessageFormat,
|
|
})) {
|
|
Logs().i('[Push] Pusher already set');
|
|
} else {
|
|
Logs().i('Need to set new pusher');
|
|
oldTokens.add(token);
|
|
if (client.isLogged()) {
|
|
setNewPusher = true;
|
|
}
|
|
}
|
|
} else {
|
|
Logs().w('[Push] Missing required push credentials');
|
|
}
|
|
for (final pusher in pushers) {
|
|
if ((token != null &&
|
|
pusher.pushkey != token &&
|
|
deviceAppId == pusher.appId) ||
|
|
oldTokens.contains(pusher.pushkey)) {
|
|
try {
|
|
await client.deletePusher(pusher);
|
|
Logs().i('[Push] Removed legacy pusher for this device');
|
|
} catch (err) {
|
|
Logs().w('[Push] Failed to remove old pusher', err);
|
|
}
|
|
}
|
|
}
|
|
if (setNewPusher) {
|
|
try {
|
|
await client.postPusher(
|
|
Pusher(
|
|
pushkey: token!,
|
|
appId: thisAppId,
|
|
appDisplayName: clientName,
|
|
deviceDisplayName: client.deviceName!,
|
|
//#Pangea
|
|
// lang: 'en',
|
|
lang: LanguageKeys.defaultLanguage,
|
|
// Pangea#
|
|
data: PusherData(
|
|
url: Uri.parse(gatewayUrl!),
|
|
// #Pangea
|
|
// format: AppSettings.pushNotificationsPusherFormat.value,
|
|
// Pangea#
|
|
additionalProperties: {"data_message": pusherDataMessageFormat},
|
|
),
|
|
kind: 'http',
|
|
),
|
|
append: false,
|
|
);
|
|
} catch (e, s) {
|
|
Logs().e('[Push] Unable to set pushers', e, s);
|
|
// #Pangea
|
|
ErrorHandler.logError(e: e, s: s, data: {});
|
|
// Pangea#
|
|
}
|
|
}
|
|
}
|
|
|
|
final pusherDataMessageFormat = Platform.isAndroid
|
|
? 'android'
|
|
: Platform.isIOS
|
|
? 'ios'
|
|
: null;
|
|
|
|
static bool _wentToRoomOnStartup = false;
|
|
|
|
Future<void> setupPush() async {
|
|
Logs().d("SetupPush");
|
|
if (client.onLoginStateChanged.value != LoginState.loggedIn ||
|
|
!PlatformInfos.isMobile ||
|
|
matrix == null) {
|
|
return;
|
|
}
|
|
// Do not setup unifiedpush if this has been initialized by
|
|
// an unifiedpush action
|
|
if (upAction) {
|
|
return;
|
|
}
|
|
if (!PlatformInfos.isIOS &&
|
|
(await UnifiedPush.getDistributors()).isNotEmpty) {
|
|
await setupUp();
|
|
} else {
|
|
await setupFirebase();
|
|
}
|
|
|
|
// ignore: unawaited_futures
|
|
_flutterLocalNotificationsPlugin.getNotificationAppLaunchDetails().then((
|
|
details,
|
|
) {
|
|
if (details == null ||
|
|
!details.didNotificationLaunchApp ||
|
|
_wentToRoomOnStartup) {
|
|
return;
|
|
}
|
|
_wentToRoomOnStartup = true;
|
|
final response = details.notificationResponse;
|
|
if (response != null) {
|
|
notificationTap(
|
|
response,
|
|
client: client,
|
|
router: FluffyChatApp.router,
|
|
l10n: l10n,
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
Future<void> _noFcmWarning() async {
|
|
if (matrix == null) {
|
|
return;
|
|
}
|
|
if (AppSettings.showNoGoogle.value) {
|
|
return;
|
|
}
|
|
await loadLocale();
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (PlatformInfos.isAndroid) {
|
|
onFcmError?.call(
|
|
l10n!.noGoogleServicesWarning,
|
|
link: Uri.parse(AppConfig.enablePushTutorial),
|
|
);
|
|
return;
|
|
}
|
|
onFcmError?.call(l10n!.oopsPushError);
|
|
});
|
|
}
|
|
|
|
Future<void> setupFirebase() async {
|
|
Logs().v('Setup firebase');
|
|
if (_fcmToken?.isEmpty ?? true) {
|
|
try {
|
|
//<GOOGLE_SERVICES>_fcmToken = await firebase.getToken();
|
|
if (_fcmToken == null) throw ('PushToken is null');
|
|
} catch (e, s) {
|
|
Logs().w('[Push] cannot get token', e, e is String ? null : s);
|
|
await _noFcmWarning();
|
|
return;
|
|
}
|
|
}
|
|
await setupPusher(
|
|
// #Pangea
|
|
// gatewayUrl: AppSettings.pushNotificationsGatewayUrl.value,
|
|
gatewayUrl: Environment.pushGatewayUrl,
|
|
// Pangea#
|
|
token: _fcmToken,
|
|
);
|
|
}
|
|
|
|
Future<void> setupUp() async {
|
|
await UnifiedPushUi(
|
|
context: matrix!.context,
|
|
instances: ["default"],
|
|
unifiedPushFunctions: UPFunctions(),
|
|
showNoDistribDialog: false,
|
|
onNoDistribDialogDismissed: () {}, // TODO: Implement me
|
|
).registerAppWithDialog();
|
|
}
|
|
|
|
Future<void> _newUpEndpoint(PushEndpoint newPushEndpoint, String i) async {
|
|
final newEndpoint = newPushEndpoint.url;
|
|
upAction = true;
|
|
if (newEndpoint.isEmpty) {
|
|
await _upUnregistered(i);
|
|
return;
|
|
}
|
|
var endpoint =
|
|
'https://matrix.gateway.unifiedpush.org/_matrix/push/v1/notify';
|
|
try {
|
|
final url = Uri.parse(newEndpoint)
|
|
.replace(path: '/_matrix/push/v1/notify', query: '')
|
|
.toString()
|
|
.split('?')
|
|
.first;
|
|
final res = json.decode(
|
|
utf8.decode((await http.get(Uri.parse(url))).bodyBytes),
|
|
);
|
|
if (res['gateway'] == 'matrix' ||
|
|
(res['unifiedpush'] is Map &&
|
|
res['unifiedpush']['gateway'] == 'matrix')) {
|
|
endpoint = url;
|
|
}
|
|
} catch (e) {
|
|
Logs().i(
|
|
'[Push] No self-hosted unified push gateway present: $newEndpoint',
|
|
);
|
|
}
|
|
Logs().i('[Push] UnifiedPush using endpoint $endpoint');
|
|
final oldTokens = <String?>{};
|
|
try {
|
|
//<GOOGLE_SERVICES>final fcmToken = await firebase.getToken();
|
|
//<GOOGLE_SERVICES>oldTokens.add(fcmToken);
|
|
} catch (_) {}
|
|
await setupPusher(
|
|
gatewayUrl: endpoint,
|
|
token: newEndpoint,
|
|
oldTokens: oldTokens,
|
|
useDeviceSpecificAppId: true,
|
|
);
|
|
await AppSettings.unifiedPushEndpoint.setItem(newEndpoint);
|
|
await AppSettings.unifiedPushRegistered.setItem(true);
|
|
}
|
|
|
|
Future<void> _upUnregistered(String i) async {
|
|
upAction = true;
|
|
Logs().i('[Push] Removing UnifiedPush endpoint...');
|
|
final oldEndpoint = AppSettings.unifiedPushEndpoint.value;
|
|
await AppSettings.unifiedPushEndpoint.setItem(
|
|
AppSettings.unifiedPushEndpoint.defaultValue,
|
|
);
|
|
await AppSettings.unifiedPushRegistered.setItem(false);
|
|
if (oldEndpoint.isNotEmpty) {
|
|
// remove the old pusher
|
|
await setupPusher(oldTokens: {oldEndpoint});
|
|
}
|
|
}
|
|
|
|
Future<void> _onUpMessage(PushMessage pushMessage, String i) async {
|
|
Logs().wtf('Push Notification from UP received', pushMessage);
|
|
final message = pushMessage.content;
|
|
upAction = true;
|
|
final data = Map<String, dynamic>.from(
|
|
json.decode(utf8.decode(message))['notification'],
|
|
);
|
|
// UP may strip the devices list
|
|
data['devices'] ??= [];
|
|
await pushHelper(
|
|
PushNotification.fromJson(data),
|
|
client: client,
|
|
l10n: l10n,
|
|
activeRoomId: matrix?.activeRoomId,
|
|
flutterLocalNotificationsPlugin: _flutterLocalNotificationsPlugin,
|
|
useNotificationActions:
|
|
false, // Buggy with UP: https://codeberg.org/UnifiedPush/flutter-connector/issues/34
|
|
);
|
|
}
|
|
}
|
|
|
|
class UPFunctions extends UnifiedPushFunctions {
|
|
final List<String> features = [
|
|
/*list of features*/
|
|
];
|
|
|
|
@override
|
|
Future<String?> getDistributor() async {
|
|
return await UnifiedPush.getDistributor();
|
|
}
|
|
|
|
@override
|
|
Future<List<String>> getDistributors() async {
|
|
return await UnifiedPush.getDistributors(features);
|
|
}
|
|
|
|
@override
|
|
Future<void> registerApp(String instance) async {
|
|
await UnifiedPush.register(instance: instance, features: features);
|
|
}
|
|
|
|
@override
|
|
Future<void> saveDistributor(String distributor) async {
|
|
await UnifiedPush.saveDistributor(distributor);
|
|
}
|
|
}
|
|
|
|
// #Pangea
|
|
@pragma('vm:entry-point')
|
|
Future<void> firebaseMessagingBackgroundHandler(RemoteMessage message) async {
|
|
// Required for background isolate
|
|
WidgetsFlutterBinding.ensureInitialized();
|
|
final instance = BackgroundPush._instance;
|
|
if (instance == null) return;
|
|
await instance._onOpenNotification(message);
|
|
}
|
|
|
|
// Pangea#
|