fluffychat/lib/components/matrix.dart

401 lines
13 KiB
Dart
Raw Normal View History

2020-01-03 17:23:40 +01:00
import 'dart:async';
2020-01-01 19:10:13 +01:00
import 'dart:convert';
2020-01-03 17:23:40 +01:00
import 'dart:io';
import 'package:firebase_messaging/firebase_messaging.dart';
2020-01-01 19:10:13 +01:00
import 'package:famedlysdk/famedlysdk.dart';
2020-01-08 14:19:15 +01:00
import 'package:fluffychat/utils/app_route.dart';
2020-01-01 19:10:13 +01:00
import 'package:fluffychat/utils/sqflite_store.dart';
2020-01-08 14:19:15 +01:00
import 'package:fluffychat/views/chat.dart';
2020-01-01 19:10:13 +01:00
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
2020-01-08 14:19:15 +01:00
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
2020-01-01 19:10:13 +01:00
import 'package:localstorage/localstorage.dart';
2020-01-08 14:19:15 +01:00
import 'package:path_provider/path_provider.dart';
2020-01-01 19:10:13 +01:00
import 'package:toast/toast.dart';
class Matrix extends StatefulWidget {
final Widget child;
final String clientName;
final Client client;
Matrix({this.child, this.clientName, this.client, Key key}) : super(key: key);
@override
MatrixState createState() => MatrixState();
/// Returns the (nearest) Client instance of your application.
static MatrixState of(BuildContext context) {
MatrixState newState =
(context.dependOnInheritedWidgetOfExactType<_InheritedMatrix>()).data;
newState.context = context;
return newState;
}
}
class MatrixState extends State<Matrix> {
Client client;
BuildContext context;
2020-01-03 17:23:40 +01:00
FirebaseMessaging _firebaseMessaging = FirebaseMessaging();
2020-01-08 14:19:15 +01:00
FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
FlutterLocalNotificationsPlugin();
String activeRoomId;
2020-01-03 17:23:40 +01:00
2020-01-01 19:10:13 +01:00
/// Used to load the old account if there is no store available.
void loadAccount() async {
final LocalStorage storage = LocalStorage('LocalStorage');
await storage.ready;
final credentialsStr = storage.getItem(widget.clientName);
if (credentialsStr == null || credentialsStr.isEmpty) {
2020-01-02 15:10:21 +01:00
client.onLoginStateChanged.add(LoginState.loggedOut);
2020-01-01 19:10:13 +01:00
return;
}
print("[Matrix] Restoring account credentials");
final Map<String, dynamic> credentials = json.decode(credentialsStr);
2020-01-02 15:10:21 +01:00
client.connect(
2020-01-01 19:10:13 +01:00
newDeviceID: credentials["deviceID"],
newDeviceName: credentials["deviceName"],
newHomeserver: credentials["homeserver"],
newLazyLoadMembers: credentials["lazyLoadMembers"],
//newMatrixVersions: credentials["matrixVersions"], // FIXME: wrong List type
newToken: credentials["token"],
newUserID: credentials["userID"],
);
}
/// Used to save the current account persistently if there is no store available.
Future<void> saveAccount() async {
if (!kIsWeb) return;
print("[Matrix] Save account credentials in crypted preferences");
final Map<String, dynamic> credentials = {
"deviceID": client.deviceID,
"deviceName": client.deviceName,
"homeserver": client.homeserver,
"lazyLoadMembers": client.lazyLoadMembers,
"matrixVersions": client.matrixVersions,
"token": client.accessToken,
"userID": client.userID,
};
final LocalStorage storage = LocalStorage('LocalStorage');
await storage.ready;
await storage.setItem(widget.clientName, json.encode(credentials));
return;
}
void clean() async {
if (!kIsWeb) return;
print("Clear session...");
final LocalStorage storage = LocalStorage('LocalStorage');
await storage.ready;
2020-01-02 22:31:39 +01:00
await storage.deleteItem(widget.clientName);
2020-01-01 19:10:13 +01:00
}
BuildContext _loadingDialogContext;
Future<dynamic> tryRequestWithLoadingDialog(Future<dynamic> request) async {
showLoadingDialog(context);
final dynamic = await tryRequestWithErrorToast(request);
hideLoadingDialog();
return dynamic;
}
Future<dynamic> tryRequestWithErrorToast(Future<dynamic> request) async {
try {
return await request;
} catch (exception) {
Toast.show(
exception.toString(),
context,
duration: Toast.LENGTH_LONG,
);
return false;
}
}
showLoadingDialog(BuildContext context) {
_loadingDialogContext = context;
showDialog(
context: _loadingDialogContext,
barrierDismissible: false,
builder: (BuildContext context) => AlertDialog(
content: Row(
children: <Widget>[
CircularProgressIndicator(),
SizedBox(width: 16),
Text("Loading... Please wait"),
],
),
),
);
}
hideLoadingDialog() => Navigator.of(_loadingDialogContext)?.pop();
2020-01-08 14:19:15 +01:00
Future<String> downloadAndSaveContent(MxContent content,
{int width, int height, ThumbnailMethod method}) async {
final bool thumbnail = width == null && height == null ? false : true;
final String tempDirectory = (await getTemporaryDirectory()).path;
final String prefix = thumbnail ? "thumbnail" : "";
File file = File('$tempDirectory/${prefix}_${content.mxc.split("/").last}');
if (!file.existsSync()) {
final url = thumbnail
? content.getThumbnail(client,
width: width, height: height, method: method)
: content.getDownloadLink(client);
var request = await HttpClient().getUrl(Uri.parse(url));
var response = await request.close();
var bytes = await consolidateHttpClientResponseBytes(response);
await file.writeAsBytes(bytes);
}
return file.path;
}
2020-01-03 17:23:40 +01:00
2020-01-08 14:19:15 +01:00
Future<void> setupFirebase() async {
2020-01-03 17:23:40 +01:00
if (Platform.isIOS) iOS_Permission();
final String token = await _firebaseMessaging.getToken();
if (token?.isEmpty ?? true) {
return Toast.show(
"Push notifications disabled.",
context,
duration: Toast.LENGTH_LONG,
2020-01-03 17:23:40 +01:00
);
}
await client.setPushers(
token,
"http",
"chat.fluffy.fluffychat",
widget.clientName,
client.deviceName,
"en",
"https://janian.de:7023/",
append: false,
format: "event_id_only",
);
2020-01-03 17:23:40 +01:00
2020-01-08 14:19:15 +01:00
Function goToRoom = (dynamic message) async {
try {
String roomId;
if (message is String) {
roomId = message;
} else if (message is Map) {
roomId = message["data"]["room_id"];
}
if (roomId?.isEmpty ?? true) throw ("Bad roomId");
await Navigator.of(context).pushAndRemoveUntil(
AppRoute.defaultRoute(
context,
Chat(roomId),
),
(r) => r.isFirst);
} catch (_) {
Toast.show("Failed to open chat...", context);
print(_);
}
};
// initialise the plugin. app_icon needs to be a added as a drawable resource to the Android head project
var initializationSettingsAndroid =
AndroidInitializationSettings('notifications_icon');
var initializationSettingsIOS =
IOSInitializationSettings(onDidReceiveLocalNotification: (i, a, b, c) {
print("onDidReceiveLocalNotification: $i $a $b $c");
return null;
});
var initializationSettings = InitializationSettings(
initializationSettingsAndroid, initializationSettingsIOS);
await _flutterLocalNotificationsPlugin.initialize(initializationSettings,
onSelectNotification: goToRoom);
2020-01-03 17:23:40 +01:00
_firebaseMessaging.configure(
2020-01-08 14:19:15 +01:00
onMessage: (Map<String, dynamic> message) async {
try {
final String roomId = message["data"]["room_id"];
final String eventId = message["data"]["event_id"];
final int unread = json.decode(message["data"]["counts"])["unread"];
if ((roomId?.isEmpty ?? true) ||
(eventId?.isEmpty ?? true) ||
unread == 0) {
await _flutterLocalNotificationsPlugin.cancelAll();
return null;
}
if (activeRoomId == roomId) return null;
// Get the room
Room room = client.getRoomById(roomId);
if (room == null) {
await client.onRoomUpdate.stream
.where((u) => u.id == roomId)
.first
.timeout(Duration(seconds: 10));
room = client.getRoomById(roomId);
if (room == null) return null;
}
// Get the event
Event event = await client.store.getEventById(eventId, room);
if (event == null) {
final EventUpdate eventUpdate = await client.onEvent.stream
.where((u) => u.content["event_id"] == eventId)
.first
.timeout(Duration(seconds: 10));
event = Event.fromJson(eventUpdate.content, room);
if (room == null) return null;
}
// Count all unread events
int unreadEvents = 0;
client.rooms
.forEach((Room room) => unreadEvents += room.notificationCount);
// Calculate title
final String title = unread > 1
? "$unreadEvents unread messages in $unread chats"
: "$unreadEvents unread messages";
// Calculate the body
String body;
switch (event.messageType) {
case MessageTypes.Image:
body = "${event.sender.calcDisplayname()} sent a picture";
break;
case MessageTypes.File:
body = "${event.sender.calcDisplayname()} sent a file";
break;
case MessageTypes.Audio:
body = "${event.sender.calcDisplayname()} sent an audio";
break;
case MessageTypes.Video:
body = "${event.sender.calcDisplayname()} sent a video";
break;
default:
body = "${event.sender.calcDisplayname()}: ${event.getBody()}";
break;
}
// The person object for the android message style notification
final person = Person(
name: room.displayname,
icon: room.avatar.mxc.isEmpty
? null
: await downloadAndSaveContent(
room.avatar,
width: 126,
height: 126,
),
iconSource: IconSource.FilePath,
);
// Show notification
var androidPlatformChannelSpecifics = AndroidNotificationDetails(
'fluffychat_push',
'FluffyChat push channel',
'Push notifications for FluffyChat',
style: AndroidNotificationStyle.Messaging,
styleInformation: MessagingStyleInformation(
person,
conversationTitle: title,
messages: [
Message(
body,
event.time,
person,
)
],
),
importance: Importance.Max,
priority: Priority.High,
ticker: 'New message in FluffyChat');
var iOSPlatformChannelSpecifics = IOSNotificationDetails();
var platformChannelSpecifics = NotificationDetails(
androidPlatformChannelSpecifics, iOSPlatformChannelSpecifics);
await _flutterLocalNotificationsPlugin.show(
0, room.displayname, body, platformChannelSpecifics,
payload: roomId);
} catch (exception) {
print("[Push] Error while processing notification: " +
exception.toString());
}
return null;
2020-01-03 17:23:40 +01:00
},
2020-01-08 14:19:15 +01:00
onResume: goToRoom,
// Currently fires unexpectetly... https://github.com/FirebaseExtended/flutterfire/issues/1060
//onLaunch: goToRoom,
2020-01-03 17:23:40 +01:00
);
2020-01-08 14:19:15 +01:00
print("[Push] Firebase initialized");
return;
2020-01-03 17:23:40 +01:00
}
void iOS_Permission() {
_firebaseMessaging.requestNotificationPermissions(
IosNotificationSettings(sound: true, badge: true, alert: true));
_firebaseMessaging.onIosSettingsRegistered
.listen((IosNotificationSettings settings) {
print("Settings registered: $settings");
});
}
2020-01-08 14:19:15 +01:00
void _initWithStore() async {
Future<LoginState> initLoginState = client.onLoginStateChanged.stream.first;
client.store = Store(client);
if (await initLoginState == LoginState.logged) {
await setupFirebase();
}
}
2020-01-01 19:10:13 +01:00
@override
void initState() {
if (widget.client == null) {
client = Client(widget.clientName, debug: false);
2020-01-02 22:31:39 +01:00
if (!kIsWeb) {
2020-01-08 14:19:15 +01:00
_initWithStore();
2020-01-02 22:31:39 +01:00
} else {
2020-01-01 19:10:13 +01:00
loadAccount();
2020-01-02 22:31:39 +01:00
}
2020-01-01 19:10:13 +01:00
} else {
client = widget.client;
}
super.initState();
}
2020-01-03 17:23:40 +01:00
@override
void dispose() {
super.dispose();
}
2020-01-01 19:10:13 +01:00
@override
Widget build(BuildContext context) {
return _InheritedMatrix(
data: this,
child: widget.child,
);
}
}
class _InheritedMatrix extends InheritedWidget {
final MatrixState data;
_InheritedMatrix({Key key, this.data, Widget child})
: super(key: key, child: child);
@override
bool updateShouldNotify(_InheritedMatrix old) {
bool update = old.data.client.accessToken != this.data.client.accessToken ||
old.data.client.userID != this.data.client.userID ||
old.data.client.matrixVersions != this.data.client.matrixVersions ||
old.data.client.lazyLoadMembers != this.data.client.lazyLoadMembers ||
old.data.client.deviceID != this.data.client.deviceID ||
old.data.client.deviceName != this.data.client.deviceName ||
old.data.client.homeserver != this.data.client.homeserver;
return update;
}
}