Switched to package names as app ids (#69)

* Fixes #14 (although detection is disabled in background processes due to the bug described in #60) * Added App icons and basic installed detection * Real Package Names Used as IDs + App Icons (INCONVENIENT FOR PREVIOUS VERSION USERS) * Switch to using extracted names (no custom names) * Fixes #57 * Fixes #67 * Fixes #64 * Fixes #61 * Commented out APKMirror and added code to remove their Apps * Updated README * Switched to Flutter stable (causes some UI elements to switch back to the old material design style, but this will be fixed in later Flutter releases) * BG task silently retries on network errors * Updated screenshots
2025-08-18 20:49:30 +02:00 · 2022-10-29 13:13:28 -04:00
parent a954a627fd
commit d1a3529036
16 changed files with 575 additions and 432 deletions
--- a/lib/providers/apps_provider.dart
+++ b/lib/providers/apps_provider.dart
@@ -9,9 +9,12 @@ import 'package:device_info_plus/device_info_plus.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:install_plugin_v2/install_plugin_v2.dart';
+import 'package:installed_apps/app_info.dart';
+import 'package:installed_apps/installed_apps.dart';
 import 'package:obtainium/app_sources/github.dart';
 import 'package:obtainium/custom_errors.dart';
 import 'package:obtainium/providers/notifications_provider.dart';
+import 'package:package_archive_info/package_archive_info.dart';
 import 'package:provider/provider.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:flutter_fgbg/flutter_fgbg.dart';
@@ -21,14 +24,15 @@ import 'package:http/http.dart';
 class AppInMemory {
  late App app;
  double? downloadProgress;
+  AppInfo? installedInfo; // Also indicates that an App is installed

-  AppInMemory(this.app, this.downloadProgress);
+  AppInMemory(this.app, this.downloadProgress, this.installedInfo);
 }

-class ApkFile {
+class DownloadedApp {
  String appId;
  File file;
-  ApkFile(this.appId, this.file);
+  DownloadedApp(this.appId, this.file);
 }

 class AppsProvider with ChangeNotifier {
@@ -39,24 +43,24 @@ class AppsProvider with ChangeNotifier {

  // Variables to keep track of the app foreground status (installs can't run in the background)
  bool isForeground = true;
-  late Stream<FGBGType> foregroundStream;
-  late StreamSubscription<FGBGType> foregroundSubscription;
+  late Stream<FGBGType>? foregroundStream;
+  late StreamSubscription<FGBGType>? foregroundSubscription;

  AppsProvider(
      {bool shouldLoadApps = false,
      bool shouldCheckUpdatesAfterLoad = false,
      bool shouldDeleteAPKs = false}) {
-    // Subscribe to changes in the app foreground status
-    foregroundStream = FGBGEvents.stream.asBroadcastStream();
-    foregroundSubscription = foregroundStream.listen((event) async {
-      isForeground = event == FGBGType.foreground;
-      if (isForeground) await loadApps();
-    });
-    if (shouldDeleteAPKs) {
-      deleteSavedAPKs();
-    }
    if (shouldLoadApps) {
+      // Subscribe to changes in the app foreground status
+      foregroundStream = FGBGEvents.stream.asBroadcastStream();
+      foregroundSubscription = foregroundStream?.listen((event) async {
+        isForeground = event == FGBGType.foreground;
+        if (isForeground) await loadApps();
+      });
      loadApps().then((_) {
+        if (shouldDeleteAPKs) {
+          deleteSavedAPKs();
+        }
        if (shouldCheckUpdatesAfterLoad) {
          checkUpdates();
        }
@@ -64,38 +68,85 @@ class AppsProvider with ChangeNotifier {
    }
  }

-  Future<ApkFile> downloadApp(String apkUrl, String appId) async {
-    apkUrl = await SourceProvider()
-        .getSource(apps[appId]!.app.url)
-        .apkUrlPrefetchModifier(apkUrl);
+  downloadApk(String apkUrl, String fileName, Function? onProgress,
+      Function? urlModifier,
+      {bool useExistingIfExists = true}) async {
+    var destDir = (await getExternalStorageDirectory())!.path;
+    if (urlModifier != null) {
+      apkUrl = await urlModifier(apkUrl);
+    }
    StreamedResponse response =
        await Client().send(Request('GET', Uri.parse(apkUrl)));
-    File downloadFile =
-        File('${(await getExternalStorageDirectory())!.path}/$appId.apk');
-    if (downloadFile.existsSync()) {
-      downloadFile.deleteSync();
-    }
-    var length = response.contentLength;
-    var received = 0;
-    var sink = downloadFile.openWrite();
+    File downloadFile = File('$destDir/$fileName.apk');
+    var alreadyExists = downloadFile.existsSync();
+    if (!alreadyExists || !useExistingIfExists) {
+      if (alreadyExists) {
+        downloadFile.deleteSync();
+      }

-    await response.stream.map((s) {
-      received += s.length;
-      apps[appId]!.downloadProgress =
-          (length != null ? received / length * 100 : 30);
+      var length = response.contentLength;
+      var received = 0;
+      double? progress;
+      var sink = downloadFile.openWrite();
+
+      await response.stream.map((s) {
+        received += s.length;
+        progress = (length != null ? received / length * 100 : 30);
+        if (onProgress != null) {
+          onProgress(progress);
+        }
+        return s;
+      }).pipe(sink);
+
+      await sink.close();
+      progress = null;
+      if (onProgress != null) {
+        onProgress(progress);
+      }
+
+      if (response.statusCode != 200) {
+        downloadFile.deleteSync();
+        throw response.reasonPhrase ?? 'Unknown Error';
+      }
+    }
+    return downloadFile;
+  }
+
+  // Downloads the App (preferred URL) and returns an ApkFile object
+  // If the app was already saved, updates it's download progress % in memory
+  // But also works for Apps that are not saved
+  Future<DownloadedApp> downloadApp(App app) async {
+    var fileName = '${app.id}-${app.latestVersion}-${app.preferredApkIndex}';
+    File downloadFile = await downloadApk(app.apkUrls[app.preferredApkIndex],
+        '${app.id}-${app.latestVersion}-${app.preferredApkIndex}',
+        (double? progress) {
+      if (apps[app.id] != null) {
+        apps[app.id]!.downloadProgress = progress;
+      }
      notifyListeners();
-      return s;
-    }).pipe(sink);
-
-    await sink.close();
-    apps[appId]!.downloadProgress = null;
-    notifyListeners();
-
-    if (response.statusCode != 200) {
-      downloadFile.deleteSync();
-      throw response.reasonPhrase ?? 'Unknown Error';
+    }, SourceProvider().getSource(app.url).apkUrlPrefetchModifier);
+    // Delete older versions of the APK if any
+    for (var file in downloadFile.parent.listSync()) {
+      var fn = file.path.split('/').last;
+      if (fn.startsWith('${app.id}-') &&
+          fn.endsWith('.apk') &&
+          fn != '$fileName.apk') {
+        file.delete();
+      }
    }
-    return ApkFile(appId, downloadFile);
+    // If the ID has changed (as it should on first download), replace it
+    var newInfo = await PackageArchiveInfo.fromPath(downloadFile.path);
+    if (app.id != newInfo.packageName) {
+      var originalAppId = app.id;
+      app.id = newInfo.packageName;
+      downloadFile = downloadFile.renameSync(
+          '${downloadFile.parent.path}/${app.id}-${app.latestVersion}-${app.preferredApkIndex}.apk');
+      if (apps[originalAppId] != null) {
+        await removeApps([originalAppId]);
+        await saveApps([app]);
+      }
+    }
+    return DownloadedApp(app.id, downloadFile);
  }

  bool areDownloadsRunning() => apps.values
@@ -106,8 +157,8 @@ class AppsProvider with ChangeNotifier {
    // TODO: This is unreliable - try to get from OS in the future
    var osInfo = await DeviceInfoPlugin().androidInfo;
    return app.installedVersion != null &&
-        osInfo.version.sdkInt! >= 30 &&
-        osInfo.version.release!.compareTo('12') >= 0;
+        osInfo.version.sdkInt >= 30 &&
+        osInfo.version.release.compareTo('12') >= 0;
  }

  Future<void> askUserToReturnToForeground(BuildContext context,
@@ -128,11 +179,62 @@ class AppsProvider with ChangeNotifier {
  // So we only know that the install prompt was shown, but the user could still cancel w/o us knowing
  // If appropriate criteria are met, the update (never a fresh install) happens silently  in the background
  // But even then, we don't know if it actually succeeded
-  Future<void> installApk(ApkFile file) async {
-    await InstallPlugin.installApk(file.file.path, 'dev.imranr.obtainium');
+  Future<void> installApk(DownloadedApp file) async {
+    var newInfo = await PackageArchiveInfo.fromPath(file.file.path);
+    AppInfo? appInfo;
+    try {
+      appInfo = await InstalledApps.getAppInfo(apps[file.appId]!.app.id);
+    } catch (e) {
+      // OK
+    }
+    if (appInfo != null &&
+        int.parse(newInfo.buildNumber) < appInfo.versionCode!) {
+      throw 'Can\'t install an older version';
+    }
+    if (appInfo == null ||
+        int.parse(newInfo.buildNumber) > appInfo.versionCode!) {
+      await InstallPlugin.installApk(file.file.path, 'dev.imranr.obtainium');
+    }
    apps[file.appId]!.app.installedVersion =
        apps[file.appId]!.app.latestVersion;
-    await saveApps([apps[file.appId]!.app]);
+    // Don't correct install status as installation may not be done yet
+    await saveApps([apps[file.appId]!.app], shouldCorrectInstallStatus: false);
+  }
+
+  Future<String?> selectApkUrl(App app, BuildContext? context) async {
+    // If the App has more than one APK, the user should pick one (if context provided)
+    String? apkUrl = app.apkUrls[app.preferredApkIndex];
+    if (app.apkUrls.length > 1 && context != null) {
+      apkUrl = await showDialog(
+          context: context,
+          builder: (BuildContext ctx) {
+            return APKPicker(app: app, initVal: apkUrl);
+          });
+    }
+    // If the picked APK comes from an origin different from the source, get user confirmation (if context provided)
+    if (apkUrl != null &&
+        Uri.parse(apkUrl).origin != Uri.parse(app.url).origin &&
+        context != null) {
+      if (await showDialog(
+              context: context,
+              builder: (BuildContext ctx) {
+                return APKOriginWarningDialog(
+                    sourceUrl: app.url, apkUrl: apkUrl!);
+              }) !=
+          true) {
+        apkUrl = null;
+      }
+    }
+    return apkUrl;
+  }
+
+  Map<String, List<String>> addToErrorMap(
+      Map<String, List<String>> errors, String appId, String error) {
+    var tempIds = errors.remove(error);
+    tempIds ??= [];
+    tempIds.add(appId);
+    errors.putIfAbsent(error, () => tempIds!);
+    return errors;
  }

  // Given a list of AppIds, uses stored info about the apps to download APKs and install them
@@ -140,37 +242,16 @@ class AppsProvider with ChangeNotifier {
  // If no BuildContext is provided, apps that require user interaction are ignored
  // If user input is needed and the App is in the background, a notification is sent to get the user's attention
  // Returns an array of Ids for Apps that were successfully downloaded, regardless of installation result
-  Future<List<String>> downloadAndInstallLatestApp(
+  Future<List<String>> downloadAndInstallLatestApps(
      List<String> appIds, BuildContext? context) async {
-    Map<String, String> appsToInstall = {};
+    List<String> appsToInstall = [];
    for (var id in appIds) {
      if (apps[id] == null) {
        throw 'App not found';
      }

-      // If the App has more than one APK, the user should pick one (if context provided)
-      String? apkUrl = apps[id]!.app.apkUrls[apps[id]!.app.preferredApkIndex];
-      if (apps[id]!.app.apkUrls.length > 1 && context != null) {
-        apkUrl = await showDialog(
-            context: context,
-            builder: (BuildContext ctx) {
-              return APKPicker(app: apps[id]!.app, initVal: apkUrl);
-            });
-      }
-      // If the picked APK comes from an origin different from the source, get user confirmation (if context provided)
-      if (apkUrl != null &&
-          Uri.parse(apkUrl).origin != Uri.parse(apps[id]!.app.url).origin &&
-          context != null) {
-        if (await showDialog(
-                context: context,
-                builder: (BuildContext ctx) {
-                  return APKOriginWarningDialog(
-                      sourceUrl: apps[id]!.app.url, apkUrl: apkUrl!);
-                }) !=
-            true) {
-          apkUrl = null;
-        }
-      }
+      String? apkUrl = await selectApkUrl(apps[id]!.app, context);
+
      if (apkUrl != null) {
        int urlInd = apps[id]!.app.apkUrls.indexOf(apkUrl);
        if (urlInd != apps[id]!.app.preferredApkIndex) {
@@ -180,18 +261,28 @@ class AppsProvider with ChangeNotifier {
        if (context != null ||
            (await canInstallSilently(apps[id]!.app) &&
                apps[id]!.app.apkUrls.length == 1)) {
-          appsToInstall.putIfAbsent(id, () => apkUrl!);
+          appsToInstall.add(id);
        }
      }
    }
+    Map<String, List<String>> errors = {};

-    List<ApkFile> downloadedFiles = await Future.wait(appsToInstall.entries
-        .map((entry) => downloadApp(entry.value, entry.key)));
+    List<DownloadedApp?> downloadedFiles =
+        await Future.wait(appsToInstall.map((id) async {
+      try {
+        return await downloadApp(apps[id]!.app);
+      } catch (e) {
+        addToErrorMap(errors, id, e.toString());
+      }
+      return null;
+    }));
+    downloadedFiles =
+        downloadedFiles.where((element) => element != null).toList();

-    List<ApkFile> silentUpdates = [];
-    List<ApkFile> regularInstalls = [];
+    List<DownloadedApp> silentUpdates = [];
+    List<DownloadedApp> regularInstalls = [];
    for (var f in downloadedFiles) {
-      bool willBeSilent = await canInstallSilently(apps[f.appId]!.app);
+      bool willBeSilent = await canInstallSilently(apps[f!.appId]!.app);
      if (willBeSilent) {
        silentUpdates.add(f);
      } else {
@@ -200,9 +291,9 @@ class AppsProvider with ChangeNotifier {
    }

    // If Obtainium is being installed, it should be the last one
-    List<ApkFile> moveObtainiumToEnd(List<ApkFile> items) {
+    List<DownloadedApp> moveObtainiumToEnd(List<DownloadedApp> items) {
      String obtainiumId = 'imranr98_obtainium_${GitHub().host}';
-      ApkFile? temp;
+      DownloadedApp? temp;
      items.removeWhere((element) {
        bool res = element.appId == obtainiumId;
        if (res) {
@@ -233,11 +324,23 @@ class AppsProvider with ChangeNotifier {
        await askUserToReturnToForeground(context, waitForFG: true);
      }
      for (var i in regularInstalls) {
-        await installApk(i);
+        try {
+          await installApk(i);
+        } catch (e) {
+          addToErrorMap(errors, i.appId, e.toString());
+        }
      }
    }
+    if (errors.isNotEmpty) {
+      String finalError = '';
+      for (var e in errors.keys) {
+        finalError +=
+            '$e ${errors[e]!.map((e) => apps[e]!.app.name).toString()}. ';
+      }
+      throw finalError;
+    }

-    return downloadedFiles.map((e) => e.appId).toList();
+    return downloadedFiles.map((e) => e!.appId).toList();
  }

  Future<Directory> getAppsDir() async {
@@ -249,16 +352,83 @@ class AppsProvider with ChangeNotifier {
    return appsDir;
  }

+  // Delete all stored APKs except those likely to still be needed
  Future<void> deleteSavedAPKs() async {
-    (await getExternalStorageDirectory())
+    List<FileSystemEntity>? apks = (await getExternalStorageDirectory())
        ?.listSync()
        .where((element) => element.path.endsWith('.apk'))
-        .forEach((element) {
-      element.deleteSync();
-    });
+        .toList();
+    if (apks != null && apks.isNotEmpty) {
+      for (var apk in apks) {
+        var shouldDelete = true;
+        var temp = apk.path.split('/').last;
+        temp = temp.substring(0, temp.length - 4);
+        var fn = temp.split('-');
+        if (fn.length == 3) {
+          var possibleId = fn[0];
+          var possibleVersion = fn[1];
+          var possibleApkUrlIndex = fn[2];
+          if (apps[possibleId] != null) {
+            if (apps[possibleId] != null &&
+                apps[possibleId]?.app != null &&
+                apps[possibleId]!.app.installedVersion !=
+                    apps[possibleId]!.app.latestVersion &&
+                apps[possibleId]!.app.latestVersion == possibleVersion &&
+                apps[possibleId]!.app.preferredApkIndex.toString() ==
+                    possibleApkUrlIndex) {
+              shouldDelete = false;
+            }
+          }
+        }
+
+        if (shouldDelete) apk.delete();
+      }
+    }
  }

-  Future<void> loadApps() async {
+  Future<AppInfo?> getInstalledInfo(String? packageName) async {
+    if (packageName != null) {
+      try {
+        return await InstalledApps.getAppInfo(packageName);
+      } catch (e) {
+        // OK
+      }
+    }
+    return null;
+  }
+
+  String standardizeVersionString(String versionString) {
+    return versionString.characters
+        .where((p0) => ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.']
+            .contains(p0))
+        .join('');
+  }
+
+  // If the App says it is installed by installedInfo is null, set it to not installed
+  // If the App says is is not installed but installedInfo exists, try to set it to installed as latest version...
+  // ...if the latestVersion seems to match the version in installedInfo (not guaranteed)
+  App? correctInstallStatus(App app, AppInfo? installedInfo) {
+    var modded = false;
+    if (installedInfo == null && app.installedVersion != null) {
+      app.installedVersion = null;
+      modded = true;
+    }
+    if (installedInfo != null && app.installedVersion == null) {
+      if (standardizeVersionString(app.latestVersion) ==
+          installedInfo.versionName) {
+        app.installedVersion = app.latestVersion;
+      } else {
+        app.installedVersion = installedInfo.versionName;
+      }
+      modded = true;
+    }
+    return modded ? app : null;
+  }
+
+  Future<void> loadApps({shouldCorrectInstallStatus = true}) async {
+    while (loadingApps) {
+      await Future.delayed(const Duration(microseconds: 1));
+    }
    loadingApps = true;
    notifyListeners();
    List<FileSystemEntity> appFiles = (await getAppsDir())
@@ -266,22 +436,54 @@ class AppsProvider with ChangeNotifier {
        .where((item) => item.path.toLowerCase().endsWith('.json'))
        .toList();
    apps.clear();
+    var sp = SourceProvider();
+    List<List<String>> errors = [];
    for (int i = 0; i < appFiles.length; i++) {
      App app =
          App.fromJson(jsonDecode(File(appFiles[i].path).readAsStringSync()));
-      apps.putIfAbsent(app.id, () => AppInMemory(app, null));
+      var info = await getInstalledInfo(app.id);
+      try {
+        sp.getSource(app.url);
+        apps.putIfAbsent(app.id, () => AppInMemory(app, null, info));
+      } catch (e) {
+        errors.add([app.id, app.name, e.toString()]);
+      }
+    }
+    if (errors.isNotEmpty) {
+      removeApps(errors.map((e) => e[0]).toList());
+      NotificationsProvider().notify(
+          AppsRemovedNotification(errors.map((e) => [e[1], e[2]]).toList()));
    }
    loadingApps = false;
    notifyListeners();
+    // For any that are not installed (by ID == package name), set to not installed if needed
+    if (shouldCorrectInstallStatus) {
+      List<App> modifiedApps = [];
+      for (var app in apps.values) {
+        var moddedApp = correctInstallStatus(app.app, app.installedInfo);
+        if (moddedApp != null) {
+          modifiedApps.add(moddedApp);
+        }
+      }
+      if (modifiedApps.isNotEmpty) {
+        await saveApps(modifiedApps, shouldCorrectInstallStatus: false);
+      }
+    }
  }

-  Future<void> saveApps(List<App> apps) async {
+  Future<void> saveApps(List<App> apps,
+      {bool shouldCorrectInstallStatus = true}) async {
    for (var app in apps) {
+      AppInfo? info = await getInstalledInfo(app.id);
+      app.name = info?.name ?? app.name;
+      if (shouldCorrectInstallStatus) {
+        app = correctInstallStatus(app, info) ?? app;
+      }
      File('${(await getAppsDir()).path}/${app.id}.json')
          .writeAsStringSync(jsonEncode(app.toJson()));
      this.apps.update(
-          app.id, (value) => AppInMemory(app, value.downloadProgress),
-          ifAbsent: () => AppInMemory(app, null));
+          app.id, (value) => AppInMemory(app, value.downloadProgress, info),
+          ifAbsent: () => AppInMemory(app, null, info));
    }
    notifyListeners();
  }
@@ -308,61 +510,73 @@ class AppsProvider with ChangeNotifier {
    return app.latestVersion != apps[app.id]?.app.installedVersion;
  }

-  Future<App?> getUpdate(String appId) async {
+  Future<App?> getUpdate(String appId,
+      {bool shouldCorrectInstallStatus = true}) async {
    App? currentApp = apps[appId]!.app;
    SourceProvider sourceProvider = SourceProvider();
    App newApp = await sourceProvider.getApp(
        sourceProvider.getSource(currentApp.url),
        currentApp.url,
        currentApp.additionalData,
-        customName: currentApp.name);
+        name: currentApp.name,
+        id: currentApp.id);
    newApp.installedVersion = currentApp.installedVersion;
    if (currentApp.preferredApkIndex < newApp.apkUrls.length) {
      newApp.preferredApkIndex = currentApp.preferredApkIndex;
    }
-    await saveApps([newApp]);
+    await saveApps([newApp],
+        shouldCorrectInstallStatus: shouldCorrectInstallStatus);
    return newApp.latestVersion != currentApp.latestVersion ? newApp : null;
  }

  Future<List<App>> checkUpdates(
      {DateTime? ignoreAfter,
-      bool immediatelyThrowRateLimitError = false}) async {
+      bool immediatelyThrowRateLimitError = false,
+      bool shouldCorrectInstallStatus = true,
+      bool immediatelyThrowSocketError = false}) async {
    List<App> updates = [];
    Map<String, List<String>> errors = {};
    if (!gettingUpdates) {
      gettingUpdates = true;

-      List<String> appIds = apps.keys.toList();
-      if (ignoreAfter != null) {
-        appIds = appIds
-            .where((id) =>
-                apps[id]!.app.lastUpdateCheck == null ||
-                apps[id]!.app.lastUpdateCheck!.isBefore(ignoreAfter))
-            .toList();
-      }
-      appIds.sort((a, b) => (apps[a]!.app.lastUpdateCheck ??
-              DateTime.fromMicrosecondsSinceEpoch(0))
-          .compareTo(apps[b]!.app.lastUpdateCheck ??
-              DateTime.fromMicrosecondsSinceEpoch(0)));
+      try {
+        List<String> appIds = apps.keys.toList();
+        if (ignoreAfter != null) {
+          appIds = appIds
+              .where((id) =>
+                  apps[id]!.app.lastUpdateCheck == null ||
+                  apps[id]!.app.lastUpdateCheck!.isBefore(ignoreAfter))
+              .toList();
+        }
+        appIds.sort((a, b) => (apps[a]!.app.lastUpdateCheck ??
+                DateTime.fromMicrosecondsSinceEpoch(0))
+            .compareTo(apps[b]!.app.lastUpdateCheck ??
+                DateTime.fromMicrosecondsSinceEpoch(0)));

-      for (int i = 0; i < appIds.length; i++) {
-        App? newApp;
-        try {
-          newApp = await getUpdate(appIds[i]);
-        } catch (e) {
-          if (e is RateLimitError && immediatelyThrowRateLimitError) {
-            rethrow;
+        for (int i = 0; i < appIds.length; i++) {
+          App? newApp;
+          try {
+            newApp = await getUpdate(appIds[i],
+                shouldCorrectInstallStatus: shouldCorrectInstallStatus);
+          } catch (e) {
+            if (e is RateLimitError && immediatelyThrowRateLimitError) {
+              rethrow;
+            }
+            if (e is SocketException && immediatelyThrowSocketError) {
+              rethrow;
+            }
+            var tempIds = errors.remove(e.toString());
+            tempIds ??= [];
+            tempIds.add(appIds[i]);
+            errors.putIfAbsent(e.toString(), () => tempIds!);
+          }
+          if (newApp != null) {
+            updates.add(newApp);
          }
-          var tempIds = errors.remove(e.toString());
-          tempIds ??= [];
-          tempIds.add(appIds[i]);
-          errors.putIfAbsent(e.toString(), () => tempIds!);
-        }
-        if (newApp != null) {
-          updates.add(newApp);
        }
+      } finally {
+        gettingUpdates = false;
      }
-      gettingUpdates = false;
    }
    if (errors.isNotEmpty) {
      String finalError = '';
@@ -413,9 +627,13 @@ class AppsProvider with ChangeNotifier {
    List<App> importedApps = (jsonDecode(appsJSON) as List<dynamic>)
        .map((e) => App.fromJson(e))
        .toList();
+    while (loadingApps) {
+      await Future.delayed(const Duration(microseconds: 1));
+    }
    for (App a in importedApps) {
-      a.installedVersion =
-          apps.containsKey(a.id) ? apps[a]?.app.installedVersion : null;
+      if (apps[a.id]?.app.installedVersion != null) {
+        a.installedVersion = apps[a.id]?.app.installedVersion;
+      }
    }
    await saveApps(importedApps);
    notifyListeners();
@@ -424,7 +642,7 @@ class AppsProvider with ChangeNotifier {

  @override
  void dispose() {
-    foregroundSubscription.cancel();
+    foregroundSubscription?.cancel();
    super.dispose();
  }
 }
--- a/lib/providers/notifications_provider.dart
+++ b/lib/providers/notifications_provider.dart
@@ -61,6 +61,24 @@ class ErrorCheckingUpdatesNotification extends ObtainiumNotification {
            Importance.high);
 }

+class AppsRemovedNotification extends ObtainiumNotification {
+  AppsRemovedNotification(List<List<String>> namedReasons)
+      : super(
+            6,
+            'Apps Removed',
+            '',
+            'APPS_REMOVED',
+            'Apps Removed',
+            'Notifies the user that one or more Apps were removed due to errors while loading them',
+            Importance.max) {
+    message = '';
+    for (var r in namedReasons) {
+      message += '${r[0]} was removed due to this error: ${r[1]}. \n';
+    }
+    message = message.trim();
+  }
+}
+
 final completeInstallationNotification = ObtainiumNotification(
    1,
    'Complete App Installation',
--- a/lib/providers/source_provider.dart
+++ b/lib/providers/source_provider.dart
@@ -4,7 +4,6 @@
 import 'dart:convert';

 import 'package:html/dom.dart';
-import 'package:obtainium/app_sources/apkmirror.dart';
 import 'package:obtainium/app_sources/fdroid.dart';
 import 'package:obtainium/app_sources/github.dart';
 import 'package:obtainium/app_sources/gitlab.dart';
@@ -54,7 +53,7 @@ class App {

  @override
  String toString() {
-    return 'ID: $id URL: $url INSTALLED: $installedVersion LATEST: $latestVersion APK: $apkUrls';
+    return 'ID: $id URL: $url INSTALLED: $installedVersion LATEST: $latestVersion APK: $apkUrls PREFERREDAPK: $preferredApkIndex ADDITIONALDATA: ${additionalData.toString()} LASTCHECK: ${lastUpdateCheck.toString()}';
  }

  factory App.fromJson(Map<String, dynamic> json) => App(
@@ -157,7 +156,7 @@ class SourceProvider {
    Mullvad(),
    Signal(),
    SourceForge(),
-    APKMirror()
+    // APKMirror()
  ];

  // Add more mass source classes here so they are available via the service
@@ -189,18 +188,21 @@ class SourceProvider {
    return false;
  }

+  String generateTempID(AppNames names, AppSource source) =>
+      '${names.author.toLowerCase()}_${names.name.toLowerCase()}_${source.host}';
+
  Future<App> getApp(AppSource source, String url, List<String> additionalData,
-      {String customName = ''}) async {
+      {String name = '', String? id}) async {
    String standardUrl = source.standardizeURL(preStandardizeUrl(url));
    AppNames names = source.getAppNames(standardUrl);
    APKDetails apk =
        await source.getLatestAPKDetails(standardUrl, additionalData);
    return App(
-        '${names.author.toLowerCase()}_${names.name.toLowerCase()}_${source.host}',
+        id ?? generateTempID(names, source),
        standardUrl,
        names.author[0].toUpperCase() + names.author.substring(1),
-        customName.trim().isNotEmpty
-            ? customName
+        name.trim().isNotEmpty
+            ? name
            : names.name[0].toUpperCase() + names.name.substring(1),
        null,
        apk.version,