Cutlery/immich
1
0
Fork 1
mirror of https://github.com/immich-app/immich.git synced 2025-05-31 12:15:47 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix(mobile): better app state handling (#4989)

Browse Source 
* fix(mobile): better app state handling

* watch -> read

---------

Co-authored-by: Alex Tran <alex.tran1502@gmail.com>
This commit is contained in:
Fynn Petersen-Frey 2023-11-13 20:51:16 +01:00 committed by GitHub
parent 291159e7fc
commit 38983838fd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 63 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mobile/lib/modules/backup/providers/manual_upload.provider.dart
View File

@ -274,7 +274,7 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
// The app is currently in background. Perform the necessary cleanups which // The app is currently in background. Perform the necessary cleanups which
// are on-hold for upload completion // are on-hold for upload completion
if (appState != AppStateEnum.active && appState != AppStateEnum.resumed) { if (appState != AppStateEnum.active && appState != AppStateEnum.resumed) {
ref.read(appStateProvider.notifier).handleAppInactivity(); ref.read(backupProvider.notifier).cancelBackup();
} }
} }

70
mobile/lib/shared/providers/app_state.provider.dart
View File

@ -28,13 +28,10 @@ enum AppStateEnum {
} }
class AppStateNotiifer extends StateNotifier<AppStateEnum> { class AppStateNotiifer extends StateNotifier<AppStateEnum> {
final Ref ref; final Ref _ref;
bool _wasPaused = false;
AppStateNotiifer(this.ref) : super(AppStateEnum.active); AppStateNotiifer(this._ref) : super(AppStateEnum.active);
void updateAppState(AppStateEnum appState) {
state = appState;
}
AppStateEnum getAppState() { AppStateEnum getAppState() {
return state; return state;
@ -43,65 +40,72 @@ class AppStateNotiifer extends StateNotifier<AppStateEnum> {
void handleAppResume() { void handleAppResume() {
state = AppStateEnum.resumed; state = AppStateEnum.resumed;
var isAuthenticated = ref.watch(authenticationProvider).isAuthenticated; // no need to resume because app was never really paused
final permission = ref.watch(galleryPermissionNotifier); if (!_wasPaused) return;
_wasPaused = false;
final isAuthenticated = _ref.read(authenticationProvider).isAuthenticated;
final permission = _ref.read(galleryPermissionNotifier);
// Needs to be logged in and have gallery permissions // Needs to be logged in and have gallery permissions
if (isAuthenticated && (permission.isGranted || permission.isLimited)) { if (isAuthenticated && (permission.isGranted || permission.isLimited)) {
ref.read(backupProvider.notifier).resumeBackup(); _ref.read(backupProvider.notifier).resumeBackup();
ref.read(backgroundServiceProvider).resumeServiceIfEnabled(); _ref.read(backgroundServiceProvider).resumeServiceIfEnabled();
ref.read(serverInfoProvider.notifier).getServerVersion(); _ref.read(serverInfoProvider.notifier).getServerVersion();
switch (ref.read(tabProvider)) { switch (_ref.read(tabProvider)) {
case TabEnum.home: case TabEnum.home:
ref.read(assetProvider.notifier).getAllAsset(); _ref.read(assetProvider.notifier).getAllAsset();
ref.read(assetProvider.notifier).getPartnerAssets(); _ref.read(assetProvider.notifier).getPartnerAssets();
case TabEnum.search: case TabEnum.search:
// nothing to do // nothing to do
case TabEnum.sharing: case TabEnum.sharing:
ref.read(assetProvider.notifier).getPartnerAssets(); _ref.read(assetProvider.notifier).getPartnerAssets();
ref.read(sharedAlbumProvider.notifier).getAllSharedAlbums(); _ref.read(sharedAlbumProvider.notifier).getAllSharedAlbums();
case TabEnum.library: case TabEnum.library:
ref.read(albumProvider.notifier).getAllAlbums(); _ref.read(albumProvider.notifier).getAllAlbums();
} }
} }
ref.watch(websocketProvider.notifier).connect(); _ref.read(websocketProvider.notifier).connect();
ref.watch(releaseInfoProvider.notifier).checkGithubReleaseInfo(); _ref.read(releaseInfoProvider.notifier).checkGithubReleaseInfo();
ref _ref
.watch(notificationPermissionProvider.notifier) .read(notificationPermissionProvider.notifier)
.getNotificationPermission(); .getNotificationPermission();
ref.watch(galleryPermissionNotifier.notifier).getGalleryPermissionStatus(); _ref.read(galleryPermissionNotifier.notifier).getGalleryPermissionStatus();
ref.read(iOSBackgroundSettingsProvider.notifier).refresh(); _ref.read(iOSBackgroundSettingsProvider.notifier).refresh();
ref.invalidate(memoryFutureProvider); _ref.invalidate(memoryFutureProvider);
} }
void handleAppInactivity() { void handleAppInactivity() {
state = AppStateEnum.inactive; state = AppStateEnum.inactive;
// do not stop/clean up anything on inactivity: issued on every orientation change
// Do not handle inactivity if manual upload is in progress
if (ref.watch(backupProvider.notifier).backupProgress !=
BackUpProgressEnum.manualInProgress) {
ImmichLogger().flush();
ref.read(websocketProvider.notifier).disconnect();
ref.read(backupProvider.notifier).cancelBackup();
}
} }
void handleAppPause() { void handleAppPause() {
state = AppStateEnum.paused; state = AppStateEnum.paused;
_wasPaused = true;
// Do not cancel backup if manual upload is in progress
if (_ref.read(backupProvider.notifier).backupProgress !=
BackUpProgressEnum.manualInProgress) {
_ref.read(backupProvider.notifier).cancelBackup();
}
_ref.read(websocketProvider.notifier).disconnect();
ImmichLogger().flush();
} }
void handleAppDetached() { void handleAppDetached() {
state = AppStateEnum.detached; state = AppStateEnum.detached;
ref.watch(manualUploadProvider.notifier).cancelBackup(); // no guarantee this is called at all
_ref.read(manualUploadProvider.notifier).cancelBackup();
} }
void handleAppHidden() { void handleAppHidden() {
state = AppStateEnum.hidden; state = AppStateEnum.hidden;
// do not stop/clean up anything on inactivity: issued on every orientation change
} }
} }

50
mobile/lib/shared/providers/websocket.provider.dart
View File

@ -63,21 +63,19 @@ class WebsocketState {
} }
class WebsocketNotifier extends StateNotifier<WebsocketState> { class WebsocketNotifier extends StateNotifier<WebsocketState> {
WebsocketNotifier(this.ref) WebsocketNotifier(this._ref)
: super( : super(
WebsocketState(socket: null, isConnected: false, pendingChanges: []), WebsocketState(socket: null, isConnected: false, pendingChanges: []),
) {
debounce = Debounce(
const Duration(milliseconds: 500),
); );
}
final log = Logger('WebsocketNotifier'); final _log = Logger('WebsocketNotifier');
final Ref ref; final Ref _ref;
late final Debounce debounce; final Debounce _debounce = Debounce(const Duration(milliseconds: 500));
connect() { /// Connects websocket to server unless already connected
var authenticationState = ref.read(authenticationProvider); void connect() {
if (state.isConnected) return;
final authenticationState = _ref.read(authenticationProvider);
if (authenticationState.isAuthenticated) { if (authenticationState.isAuthenticated) {
final accessToken = Store.get(StoreKey.accessToken); final accessToken = Store.get(StoreKey.accessToken);
@ -118,7 +116,7 @@ class WebsocketNotifier extends StateNotifier<WebsocketState> {
}); });
socket.on('error', (errorMessage) { socket.on('error', (errorMessage) {
log.severe("Websocket Error - $errorMessage"); _log.severe("Websocket Error - $errorMessage");
state = WebsocketState( state = WebsocketState(
isConnected: false, isConnected: false,
socket: null, socket: null,
@ -138,7 +136,7 @@ class WebsocketNotifier extends StateNotifier<WebsocketState> {
} }
} }
disconnect() { void disconnect() {
debugPrint("Attempting to disconnect from websocket"); debugPrint("Attempting to disconnect from websocket");
var socket = state.socket?.disconnect(); var socket = state.socket?.disconnect();
@ -152,30 +150,30 @@ class WebsocketNotifier extends StateNotifier<WebsocketState> {
} }
} }
stopListenToEvent(String eventName) { void stopListenToEvent(String eventName) {
debugPrint("Stop listening to event $eventName"); debugPrint("Stop listening to event $eventName");
state.socket?.off(eventName); state.socket?.off(eventName);
} }
listenUploadEvent() { void listenUploadEvent() {
debugPrint("Start listening to event on_upload_success"); debugPrint("Start listening to event on_upload_success");
state.socket?.on('on_upload_success', _handleOnUploadSuccess); state.socket?.on('on_upload_success', _handleOnUploadSuccess);
} }
addPendingChange(PendingAction action, dynamic value) { void addPendingChange(PendingAction action, dynamic value) {
state = state.copyWith( state = state.copyWith(
pendingChanges: [...state.pendingChanges, PendingChange(action, value)], pendingChanges: [...state.pendingChanges, PendingChange(action, value)],
); );
} }
handlePendingChanges() { void handlePendingChanges() {
final deleteChanges = state.pendingChanges final deleteChanges = state.pendingChanges
.where((c) => c.action == PendingAction.assetDelete) .where((c) => c.action == PendingAction.assetDelete)
.toList(); .toList();
if (deleteChanges.isNotEmpty) { if (deleteChanges.isNotEmpty) {
List<String> remoteIds = List<String> remoteIds =
deleteChanges.map((a) => a.value.toString()).toList(); deleteChanges.map((a) => a.value.toString()).toList();
ref.read(syncServiceProvider).handleRemoteAssetRemoval(remoteIds); _ref.read(syncServiceProvider).handleRemoteAssetRemoval(remoteIds);
state = state.copyWith( state = state.copyWith(
pendingChanges: state.pendingChanges pendingChanges: state.pendingChanges
.where((c) => c.action != PendingAction.assetDelete) .where((c) => c.action != PendingAction.assetDelete)
@ -184,27 +182,27 @@ class WebsocketNotifier extends StateNotifier<WebsocketState> {
} }
} }
_handleOnUploadSuccess(dynamic data) { void _handleOnUploadSuccess(dynamic data) {
final dto = AssetResponseDto.fromJson(data); final dto = AssetResponseDto.fromJson(data);
if (dto != null) { if (dto != null) {
final newAsset = Asset.remote(dto); final newAsset = Asset.remote(dto);
ref.watch(assetProvider.notifier).onNewAssetUploaded(newAsset); _ref.watch(assetProvider.notifier).onNewAssetUploaded(newAsset);
} }
} }
_handleOnConfigUpdate(dynamic _) { void _handleOnConfigUpdate(dynamic _) {
ref.read(serverInfoProvider.notifier).getServerFeatures(); _ref.read(serverInfoProvider.notifier).getServerFeatures();
ref.read(serverInfoProvider.notifier).getServerConfig(); _ref.read(serverInfoProvider.notifier).getServerConfig();
} }
// Refresh updated assets // Refresh updated assets
_handleServerUpdates(dynamic _) { void _handleServerUpdates(dynamic _) {
ref.read(assetProvider.notifier).getAllAsset(); _ref.read(assetProvider.notifier).getAllAsset();
} }
_handleOnAssetDelete(dynamic data) { void _handleOnAssetDelete(dynamic data) {
addPendingChange(PendingAction.assetDelete, data); addPendingChange(PendingAction.assetDelete, data);
debounce(handlePendingChanges); _debounce(handlePendingChanges);
} }
} }