TW-2912 Allow mobile clear cache (#2917)

Author: tddang-linagora

assets/images/data-and-storage.svg

@@ -3141,6 +3141,41 @@
   "leaveChat": "Leave chat",
   "leaveChatDescription": "Messaging history will still be available to the other person.",
   "leaveChatTitle": "Are you sure you want to leave this chat?",
+  "dataAndStorage": "Data and storage",
+  "phoneStorage": "Phone Storage",
+  "@phoneStorage": {},
+  "phoneStorageDescription": "Twake Chat is using {percent} of storage on your phone",
+  "@phoneStorageDescription": {
+    "placeholders": {
+      "percent": {
+        "type": "String"
+      }
+    }
+  },
+  "medias": "Medias",
+  "@medias": {},
+  "videos": "Videos",
+  "@videos": {},
+  "stickersAndEmojis": "Stickers and emojis",
+  "@stickersAndEmojis": {},
+  "clearCacheSize": "Clear cache {size}",
+  "@clearCacheSize": {
+    "placeholders": {
+      "size": {
+        "type": "String"
+      }
+    }
+  },
+  "available": "Available",
+  "@available": {},
+  "clearCacheConfirmTitle": "Clear cache?",
+  "@clearCacheConfirmTitle": {},
+  "clearCacheConfirmMessage": "This will delete all temporary files stored on your device. This action cannot be undone.",
+  "@clearCacheConfirmMessage": {},
+  "cacheClearedSuccessfully": "Cache cleared successfully",
+  "@cacheClearedSuccessfully": {},
+  "cacheIsScanning": "Cache is scanning. Please wait...",
+  "@cacheIsScanning": {},
   "selectYourServer": "Select your server",
   "welcomeBack": "Welcome back",
   "matrixIdOrUsername": "Matrix Id or username"

assets/l10n/intl_en.arb

@@ -5,6 +5,10 @@
 abstract class AppRoutePaths {
   static const matrixId = 'matrixId';
 
+  // Data and Storage routes
+  static const String dataAndStorageSegment = 'dataAndStorage';
+  static const String dataAndStorageFull = '/rooms/dataAndStorage';
+
   // Security routes
   static const String roomsSecurityFull = '/rooms/security';
   static const String contactsVisibilitySegment = 'contactsVisibility';

lib/config/go_routes/app_route_paths.dart

@@ -46,6 +46,7 @@ import 'package:fluffychat/pages/settings_dashboard/settings_emotes/settings_emo
 import 'package:fluffychat/pages/settings_dashboard/settings_notifications/settings_notifications.dart';
 import 'package:fluffychat/pages/settings_dashboard/settings_security/settings_security.dart';
 import 'package:fluffychat/pages/settings_dashboard/settings_stories/settings_stories.dart';
+import 'package:fluffychat/pages/settings_dashboard/settings_data_and_storage/settings_data_and_storage.dart';
 import 'package:fluffychat/pages/settings_dashboard/settings_style/settings_style.dart';
 import 'package:fluffychat/pages/sign_up/signup.dart';
 import 'package:fluffychat/widgets/layouts/agruments/app_adaptive_scaffold_body_args.dart';
@@ -351,6 +352,13 @@ abstract class AppRoutes {
                   defaultPageBuilder(context, const SettingsAppLanguage()),
               redirect: loggedOutRedirect,
             ),
+            if (PlatformInfos.isMobile)
+              GoRoute(
+                path: AppRoutePaths.dataAndStorageSegment,
+                pageBuilder: (context, state) =>
+                    defaultPageBuilder(context, const SettingsDataAndStorage()),
+                redirect: loggedOutRedirect,
+              ),
             GoRoute(
               path: 'chat',
               pageBuilder: (context, state) =>

lib/config/go_routes/go_router.dart

@@ -148,6 +148,8 @@ import 'package:fluffychat/modules/federation_identity_lookup/manager/federation
 import 'package:fluffychat/modules/federation_identity_lookup/manager/identity_lookup_manager.dart';
 import 'package:fluffychat/modules/federation_identity_request_token/manager/federation_identity_request_token_manager.dart';
 import 'package:fluffychat/pages/chat/chat_pinned_events/pinned_events_controller.dart';
+import 'package:fluffychat/pages/settings_dashboard/settings_data_and_storage/isolate_storage_scanner_service.dart';
+import 'package:fluffychat/pages/settings_dashboard/settings_data_and_storage/settings_data_and_storage_scanner_service.dart';
 import 'package:fluffychat/utils/famedlysdk_store.dart';
 import 'package:fluffychat/utils/logging/loggers/console_logger.dart';
 import 'package:fluffychat/utils/logging/loggers/sentry_logger.dart';
@@ -198,6 +200,9 @@ class GetItInitializer {
     NetworkConnectivityDI().bind();
     getIt.registerSingleton(ResponsiveUtils());
     getIt.registerSingleton(TwakeEventDispatcher());
+    getIt.registerLazySingleton<StorageScannerService>(
+      () => const IsolateStorageScannerService(),
+    );
     getIt.registerSingleton(Store());
     getIt.registerFactory<AppConfigLoader>(() => AppConfigLoader());
     bindingCachingManager();

lib/di/global/get_it_initializer.dart

@@ -194,15 +194,7 @@ class SupportedPreviewFileTypes {
 
   static const supportAnotherTypes = ['application/octet-stream'];
 
-  static const docFileTypes = [
-    'docx',
-    'doc',
-    'docx',
-    'docm',
-    'dot',
-    'dotx',
-    'dotm',
-  ];
+  static const docFileTypes = ['doc', 'docx', 'docm', 'dot', 'dotx', 'dotm'];
 
   static const pdfFileTypes = ['pdf'];
 

lib/domain/model/preview_file/supported_preview_file_types.dart

@@ -1,6 +1,7 @@
 import 'dart:async';
 
 import 'package:fluffychat/config/app_config.dart';
+import 'package:fluffychat/config/go_routes/app_route_paths.dart';
 import 'package:fluffychat/di/global/get_it_initializer.dart';
 import 'package:fluffychat/domain/model/extensions/common_settings/common_settings_extensions.dart';
 import 'package:fluffychat/domain/model/extensions/homeserver_summary_extensions.dart';
@@ -57,6 +58,7 @@ class SettingsController extends State<Settings> with ConnectPageMixin {
     SettingEnum.notificationAndSounds,
     SettingEnum.appLanguage,
     SettingEnum.devices,
+    if (PlatformInfos.isMobile) SettingEnum.dataAndStorage,
     SettingEnum.help,
     SettingEnum.about,
     SettingEnum.logout,
@@ -260,6 +262,12 @@ class SettingsController extends State<Settings> with ConnectPageMixin {
           optionsSelectNotifier.value = null;
         }
         break;
+      case SettingEnum.dataAndStorage:
+        final result = await context.push(AppRoutePaths.dataAndStorageFull);
+        if (result == null) {
+          optionsSelectNotifier.value = null;
+        }
+        break;
       case SettingEnum.help:
         UrlLauncher(context, url: AppConfig.supportUrl).openUrlInAppBrowser();
         break;

lib/pages/settings_dashboard/settings/settings.dart

@@ -0,0 +1,60 @@
+import 'dart:io';
+import 'dart:isolate';
+
+import 'package:async/async.dart';
+
+import 'settings_data_and_storage_constants.dart';
+import 'settings_data_and_storage_scanner_service.dart';
+
+void _isolateScannerEntryPoint(SendPort sendPort) async {
+  final receivePort = ReceivePort();
+  sendPort.send(receivePort.sendPort);
+  final String dirPath = await receivePort.first as String;
+  receivePort.close();
+
+  final Map<String, int> result = {
+    for (final c in StorageCategory.values) c.name: 0,
+  };
+
+  try {
+    final dir = Directory(dirPath);
+    await for (final entity in dir.list(recursive: true, followLinks: false)) {
+      if (entity is! File) continue;
+      try {
+        final int size = entity.lengthSync();
+        final StorageCategory category = StorageCategory.fromFile(entity.path);
+        result[category.name] = (result[category.name] ?? 0) + size;
+      } catch (_) {
+        // Swallow: caller catches errors thrown by [scanDirectory] and logs them.
+      }
+    }
+  } catch (_) {
+    // Swallow: caller catches errors thrown by [scanDirectory] and logs them.
+  }
+
+  sendPort.send(result);
+}
+
+Future<Map<StorageCategory, int>> _scanDirectory(String dirPath) async {
+  final receivePort = ReceivePort();
+  await Isolate.spawn(_isolateScannerEntryPoint, receivePort.sendPort);
+
+  final events = StreamQueue(receivePort);
+  final SendPort isolateSendPort = await events.next as SendPort;
+  isolateSendPort.send(dirPath);
+
+  // Convert from wire format (String keys) back to typed enum keys.
+  final Map<String, int> raw = Map<String, int>.from(await events.next as Map);
+  events.cancel();
+  receivePort.close();
+
+  return {for (final c in StorageCategory.values) c: raw[c.name] ?? 0};
+}
+
+class IsolateStorageScannerService implements StorageScannerService {
+  const IsolateStorageScannerService();
+
+  @override
+  Future<Map<StorageCategory, int>> scanDirectory(String dirPath) =>
+      _scanDirectory(dirPath);
+}

lib/pages/settings_dashboard/settings_data_and_storage/isolate_storage_scanner_service.dart

@@ -0,0 +1,147 @@
+import 'dart:io';
+
+import 'package:fluffychat/generated/l10n/app_localizations.dart';
+import 'package:fluffychat/utils/dialog/twake_dialog.dart';
+import 'package:fluffychat/utils/twake_snackbar.dart';
+import 'package:flutter/material.dart';
+import 'package:matrix/matrix.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:storage_space/storage_space.dart';
+
+import 'package:fluffychat/di/global/get_it_initializer.dart';
+
+import 'settings_data_and_storage_calculator.dart';
+import 'settings_data_and_storage_constants.dart';
+import 'settings_data_and_storage_scanner_service.dart';
+import 'settings_data_and_storage_view.dart';
+
+class SettingsDataAndStorage extends StatefulWidget {
+  const SettingsDataAndStorage({super.key});
+
+  @override
+  SettingsDataAndStorageController createState() =>
+      SettingsDataAndStorageController();
+}
+
+class SettingsDataAndStorageController extends State<SettingsDataAndStorage> {
+  final StorageScannerService _scannerService = getIt
+      .get<StorageScannerService>();
+
+  double _totalStorageBytes = 0;
+
+  StorageScanResult _scanResult = const StorageScanResult();
+  bool _isScanning = true;
+
+  bool get isScanning => _isScanning;
+  double get totalCacheBytes => _scanResult.totalBytes.toDouble();
+
+  double get storageUsageRatio =>
+      StorageCalculator.usageRatio(totalCacheBytes, _totalStorageBytes);
+
+  String get storageUsagePercent =>
+      StorageCalculator.usagePercent(totalCacheBytes, _totalStorageBytes);
+
+  String formattedBytesFor(StorageCategory category) =>
+      StorageCalculator.formatBytes(_scanResult.bytesFor(category).toDouble());
+
+  String get formattedTotalCache =>
+      StorageCalculator.formatBytes(totalCacheBytes);
+
+  @override
+  void initState() {
+    super.initState();
+    _initDataAndStorage();
+  }
+
+  Future<void> _initDataAndStorage() async {
+    try {
+      _totalStorageBytes = await _getTotalStorageBytes();
+      _scanResult = await _getCacheCategories();
+    } catch (e, s) {
+      Logs().wtf('SettingsDataAndStorage:_initDataAndStorage', e, s);
+    } finally {
+      _isScanning = false;
+    }
+    if (mounted) setState(() {});
+  }
+
+  Future<double> _getTotalStorageBytes() async {
+    try {
+      final storageSpace = await getStorageSpace(
+        lowOnSpaceThreshold: 0,
+        fractionDigits: 0,
+      );
+      return storageSpace.total.toDouble();
+    } catch (e, s) {
+      Logs().e('SettingsDataAndStorage::_getTotalStorageBytes', e, s);
+      rethrow;
+    }
+  }
+
+  Future<StorageScanResult> _getCacheCategories() async {
+    try {
+      final Directory tempDir = await getTemporaryDirectory();
+      final Map<StorageCategory, int> result = await _scannerService
+          .scanDirectory(tempDir.path);
+      return StorageScanResult(result);
+    } catch (e, s) {
+      Logs().e('SettingsDataAndStorage::_getCacheCategories', e, s);
+      rethrow;
+    }
+  }
+
+  Future<void> onClearCache(BuildContext context) async {
+    final l10n = L10n.of(context)!;
+    if (_isScanning) {
+      TwakeSnackBar.show(context, l10n.cacheIsScanning);
+      return;
+    }
+    final confirmed = await showConfirmAlertDialog(
+      context: context,
+      title: l10n.clearCacheConfirmTitle,
+      message: l10n.clearCacheConfirmMessage,
+      okLabel: l10n.ok,
+      cancelLabel: l10n.cancel,
+    );
+    if (confirmed != ConfirmResult.ok) return;
+
+    await _clearCacheDir(context);
+    await _rescanCache();
+  }
+
+  Future<void> _clearCacheDir(BuildContext context) async {
+    final l10n = L10n.of(context)!;
+    try {
+      final Directory tempDir = await getTemporaryDirectory();
+      if (tempDir.existsSync()) {
+        await for (final entity in tempDir.list()) {
+          await entity.delete(recursive: true);
+        }
+      }
+      if (context.mounted) {
+        TwakeSnackBar.show(context, l10n.cacheClearedSuccessfully);
+      }
+    } catch (e, s) {
+      Logs().e('SettingsDataAndStorage:_clearCacheDir', e, s);
+    }
+
+    if (!context.mounted) return;
+    setState(() {
+      _scanResult = const StorageScanResult();
+      _isScanning = true;
+    });
+  }
+
+  Future<void> _rescanCache() async {
+    try {
+      _scanResult = await _getCacheCategories();
+    } catch (e, s) {
+      Logs().e('SettingsDataAndStorage:_rescanCache', e, s);
+    }
+    _isScanning = false;
+    if (context.mounted) setState(() {});
+  }
+
+  @override
+  Widget build(BuildContext context) => SettingsDataAndStorageView(this);
+}

lib/pages/settings_dashboard/settings_data_and_storage/settings_data_and_storage.dart

@@ -0,0 +1,42 @@
+import 'settings_data_and_storage_constants.dart';
+
+class StorageScanResult {
+  final Map<StorageCategory, int> _bytes;
+
+  const StorageScanResult([this._bytes = const <StorageCategory, int>{}]);
+
+  int bytesFor(StorageCategory category) => _bytes[category] ?? 0;
+
+  int get totalBytes => _bytes.values.fold(0, (sum, v) => sum + v);
+}
+
+class StorageCalculator {
+  const StorageCalculator._();
+
+  static String formatBytes(double bytes) {
+    if (bytes >= 1024 * 1024 * 1024) {
+      return '${(bytes / (1024 * 1024 * 1024)).toStringAsFixed(1)} GB';
+    }
+    if (bytes >= 1024 * 1024) {
+      return '${(bytes / (1024 * 1024)).toStringAsFixed(0)} MB';
+    }
+    if (bytes >= 1024) {
+      return '${(bytes / 1024).toStringAsFixed(0)} KB';
+    }
+    return '${bytes.toStringAsFixed(0)} B';
+  }
+
+  /// Ratio of [cacheBytes] to device [totalStorageBytes], clamped to [0, 1].
+  ///
+  /// Returns 0.0 when [totalStorageBytes] is unknown (≤ 0) to avoid
+  /// division-by-zero or a ratio > 1.
+  static double usageRatio(double cacheBytes, double totalStorageBytes) {
+    if (totalStorageBytes <= 0) return 0.0;
+    return (cacheBytes / totalStorageBytes).clamp(0.0, 1.0);
+  }
+
+  static String usagePercent(double cacheBytes, double totalStorageBytes) {
+    final ratio = usageRatio(cacheBytes, totalStorageBytes);
+    return '${(ratio * 100).toStringAsFixed(1)}%';
+  }
+}