Updated some plugins

Still no auto retry for rate-limit. Instead, rate-limit errors are ignored and the unchecked Apps have to wait until the next cycle. Even this needs more testing before release.

README.md

@@ -1,21 +1,27 @@
-# ![](./android/app/src/main/res/drawable/ic_notification.png) Obtainium
+# ![Obtainium Icon](./android/app/src/main/res/drawable/ic_notification.png) Obtainium
 
 Get Android App Updates Directly From the Source.
 
 Obtainium allows you to install and update Open-Source Apps directly from their releases pages, and receive notifications when new releases are made available.
 
-Currently supported App sources:
-- GitHub
-- GitLab
-
 Motivation: [Side Of Burritos - You should use this instead of F-Droid | How to use app RSS feed](https://youtu.be/FFz57zNR_M0)
 
+Currently supported App sources:
+- [GitHub](https://github.com/)
+- [GitLab](https://gitlab.com/)
+- [F-Droid](https://f-droid.org/)
+- [IzzyOnDroid](https://android.izzysoft.de/)
+- [Mullvad](https://mullvad.net/en/)
+- [Signal](https://signal.org/)
+- [APKMirror](https://apkmirror.com/)
+
 ## Limitations
 - App installs are assumed to have succeeded; failures and cancelled installs cannot be detected.
 - Auto (unattended) updates are unsupported due to a lack of any capable Flutter plugin.
+- For some sources, data is gathered using Web scraping and can easily break due to changes in website design. In such cases, more reliable methods may be unavailable.
 
 ## Screenshots
 
-| <img src="./screenshots/1.apps.png" alt="Apps Page" /> | <img src="./screenshots/2.dark_theme.png" alt="Dark Theme" />           | <img src="./screenshots/3.material_you.png" alt="Material You" />    |
+| <img src="./assets/screenshots/1.apps.png" alt="Apps Page" /> | <img src="./assets/screenshots/2.dark_theme.png" alt="Dark Theme" />           | <img src="./assets/screenshots/3.material_you.png" alt="Material You" />    |
 | ------------------------------------------------------ | ----------------------------------------------------------------------- | -------------------------------------------------------------------- |
-| <img src="./screenshots/4.app.png" alt="App Page" />   | <img src="./screenshots/5.apk_picker.png" alt="Multiple APK Support" /> | <img src="./screenshots/6.apk_install.png" alt="App Installation" /> |
+| <img src="./assets/screenshots/4.app.png" alt="App Page" />   | <img src="./assets/screenshots/5.apk_picker.png" alt="Multiple APK Support" /> | <img src="./assets/screenshots/6.apk_install.png" alt="App Installation" /> |

android/app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <external-path path="Android/data/dev.imranr.obtainium/" name="files_root" />
+    <external-path path="." name="external_storage_root" />
+</paths>

lib/app_sources/apkmirror.dart

@@ -0,0 +1,112 @@
+import 'package:html/parser.dart';
+import 'package:http/http.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class APKMirror implements AppSource {
+  @override
+  late String host = 'apkmirror.com';
+
+  @override
+  String standardizeURL(String url) {
+    RegExp standardUrlRegEx = RegExp('^https?://$host/apk/[^/]+/[^/]+');
+    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
+    if (match == null) {
+      throw notValidURL(runtimeType.toString());
+    }
+    return url.substring(0, match.end);
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) =>
+      '$standardUrl#whatsnew';
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async {
+    var originalUri = Uri.parse(apkUrl);
+    var res = await get(originalUri);
+    if (res.statusCode != 200) {
+      throw false;
+    }
+    var href =
+        parse(res.body).querySelector('.downloadButton')?.attributes['href'];
+    if (href == null) {
+      throw false;
+    }
+    var res2 = await get(Uri.parse('${originalUri.origin}$href'), headers: {
+      'User-Agent':
+          'Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0'
+    });
+    if (res2.statusCode != 200) {
+      throw false;
+    }
+    var links = parse(res2.body)
+        .querySelectorAll('a')
+        .where((element) => element.innerHtml == 'here')
+        .map((e) => e.attributes['href'])
+        .where((element) => element != null)
+        .toList();
+    if (links.isEmpty) {
+      throw false;
+    }
+    return '${originalUri.origin}${links[0]}';
+  }
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    Response res = await get(Uri.parse('$standardUrl/feed'));
+    if (res.statusCode != 200) {
+      throw couldNotFindReleases;
+    }
+    var nextUrl = parse(res.body)
+        .querySelector('item')
+        ?.querySelector('link')
+        ?.nextElementSibling
+        ?.innerHtml;
+    if (nextUrl == null) {
+      throw couldNotFindReleases;
+    }
+    Response res2 = await get(Uri.parse(nextUrl), headers: {
+      'User-Agent':
+          'Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0'
+    });
+    if (res2.statusCode != 200) {
+      throw couldNotFindReleases;
+    }
+    var html2 = parse(res2.body);
+    var origin = Uri.parse(standardUrl).origin;
+    List<String> apkUrls = html2
+        .querySelectorAll('.apkm-badge')
+        .map((e) => e.innerHtml != 'APK'
+            ? ''
+            : e.previousElementSibling?.attributes['href'] ?? '')
+        .where((element) => element.isNotEmpty)
+        .map((e) => '$origin$e')
+        .toList();
+    if (apkUrls.isEmpty) {
+      throw noAPKFound;
+    }
+    var version = html2.querySelector('span.active.accent_color')?.innerHtml;
+    if (version == null) {
+      throw couldNotFindLatestVersion;
+    }
+    return APKDetails(version, apkUrls);
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) {
+    String temp = standardUrl.substring(standardUrl.indexOf('://') + 3);
+    List<String> names = temp.substring(temp.indexOf('/') + 1).split('/');
+    return AppNames(names[1], names[2]);
+  }
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [];
+
+  @override
+  List<String> additionalDataDefaults = [];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [];
+}

lib/app_sources/fdroid.dart

@@ -0,0 +1,72 @@
+import 'package:html/parser.dart';
+import 'package:http/http.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class FDroid implements AppSource {
+  @override
+  late String host = 'f-droid.org';
+
+  @override
+  String standardizeURL(String url) {
+    RegExp standardUrlRegExB =
+        RegExp('^https?://$host/+[^/]+/+packages/+[^/]+');
+    RegExpMatch? match = standardUrlRegExB.firstMatch(url.toLowerCase());
+    if (match != null) {
+      url = 'https://$host/packages/${Uri.parse(url).pathSegments.last}';
+    }
+    RegExp standardUrlRegExA = RegExp('^https?://$host/+packages/+[^/]+');
+    match = standardUrlRegExA.firstMatch(url.toLowerCase());
+    if (match == null) {
+      throw notValidURL(runtimeType.toString());
+    }
+    return url.substring(0, match.end);
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) => null;
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async => apkUrl;
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    Response res = await get(Uri.parse(standardUrl));
+    if (res.statusCode == 200) {
+      var latestReleaseDiv =
+          parse(res.body).querySelector('#latest.package-version');
+      var apkUrl = latestReleaseDiv
+          ?.querySelector('.package-version-download a')
+          ?.attributes['href'];
+      if (apkUrl == null) {
+        throw noAPKFound;
+      }
+      var version = latestReleaseDiv
+          ?.querySelector('.package-version-header b')
+          ?.innerHtml
+          .split(' ')
+          .last;
+      if (version == null) {
+        throw couldNotFindLatestVersion;
+      }
+      return APKDetails(version, [apkUrl]);
+    } else {
+      throw couldNotFindReleases;
+    }
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) {
+    return AppNames('F-Droid', Uri.parse(standardUrl).pathSegments.last);
+  }
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [];
+
+  @override
+  List<String> additionalDataDefaults = [];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [];
+}

lib/app_sources/github.dart

@@ -0,0 +1,184 @@
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/custom_errors.dart';
+import 'package:obtainium/providers/settings_provider.dart';
+import 'package:obtainium/providers/source_provider.dart';
+import 'package:url_launcher/url_launcher_string.dart';
+
+class GitHub implements AppSource {
+  @override
+  late String host = 'github.com';
+
+  @override
+  String standardizeURL(String url) {
+    RegExp standardUrlRegEx = RegExp('^https?://$host/[^/]+/[^/]+');
+    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
+    if (match == null) {
+      throw notValidURL(runtimeType.toString());
+    }
+    return url.substring(0, match.end);
+  }
+
+  Future<String> getCredentialPrefixIfAny() async {
+    SettingsProvider settingsProvider = SettingsProvider();
+    await settingsProvider.initializeSettings();
+    String? creds =
+        settingsProvider.getSettingString(moreSourceSettingsFormItems[0].id);
+    return creds != null && creds.isNotEmpty ? '$creds@' : '';
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) =>
+      '$standardUrl/releases';
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async => apkUrl;
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    var includePrereleases =
+        additionalData.isNotEmpty && additionalData[0] == 'true';
+    var fallbackToOlderReleases =
+        additionalData.length >= 2 && additionalData[1] == 'true';
+    var regexFilter = additionalData.length >= 3 && additionalData[2].isNotEmpty
+        ? additionalData[2]
+        : null;
+    Response res = await get(Uri.parse(
+        'https://${await getCredentialPrefixIfAny()}api.$host/repos${standardUrl.substring('https://$host'.length)}/releases'));
+    if (res.statusCode == 200) {
+      var releases = jsonDecode(res.body) as List<dynamic>;
+
+      List<String> getReleaseAPKUrls(dynamic release) =>
+          (release['assets'] as List<dynamic>?)
+              ?.map((e) {
+                return e['browser_download_url'] != null
+                    ? e['browser_download_url'] as String
+                    : '';
+              })
+              .where((element) => element.toLowerCase().endsWith('.apk'))
+              .toList() ??
+          [];
+
+      dynamic targetRelease;
+
+      for (int i = 0; i < releases.length; i++) {
+        if (!fallbackToOlderReleases && i > 0) break;
+        if (!includePrereleases && releases[i]['prerelease'] == true) {
+          continue;
+        }
+        if (regexFilter != null &&
+            !RegExp(regexFilter)
+                .hasMatch((releases[i]['name'] as String).trim())) {
+          continue;
+        }
+        var apkUrls = getReleaseAPKUrls(releases[i]);
+        if (apkUrls.isEmpty) {
+          continue;
+        }
+        targetRelease = releases[i];
+        targetRelease['apkUrls'] = apkUrls;
+        break;
+      }
+      if (targetRelease == null) {
+        throw couldNotFindReleases;
+      }
+      if ((targetRelease['apkUrls'] as List<String>).isEmpty) {
+        throw noAPKFound;
+      }
+      String? version = targetRelease['tag_name'];
+      if (version == null) {
+        throw couldNotFindLatestVersion;
+      }
+      return APKDetails(version, targetRelease['apkUrls']);
+    } else {
+      if (res.headers['x-ratelimit-remaining'] == '0') {
+        throw RateLimitError(
+            (int.parse(res.headers['x-ratelimit-reset'] ?? '1800000000') /
+                    60000000)
+                .round());
+      }
+
+      throw couldNotFindReleases;
+    }
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) {
+    String temp = standardUrl.substring(standardUrl.indexOf('://') + 3);
+    List<String> names = temp.substring(temp.indexOf('/') + 1).split('/');
+    return AppNames(names[0], names[1]);
+  }
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [
+    [GeneratedFormItem(label: 'Include prereleases', type: FormItemType.bool)],
+    [
+      GeneratedFormItem(
+          label: 'Fallback to older releases', type: FormItemType.bool)
+    ],
+    [
+      GeneratedFormItem(
+          label: 'Filter Release Titles by Regular Expression',
+          type: FormItemType.string,
+          required: false,
+          additionalValidators: [
+            (value) {
+              if (value == null || value.isEmpty) {
+                return null;
+              }
+              try {
+                RegExp(value);
+              } catch (e) {
+                return 'Invalid regular expression';
+              }
+              return null;
+            }
+          ])
+    ]
+  ];
+
+  @override
+  List<String> additionalDataDefaults = ['true', 'true', ''];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [
+    GeneratedFormItem(
+        label: 'GitHub Personal Access Token (Increases Rate Limit)',
+        id: 'github-creds',
+        required: false,
+        additionalValidators: [
+          (value) {
+            if (value != null && value.trim().isNotEmpty) {
+              if (value
+                      .split(':')
+                      .where((element) => element.trim().isNotEmpty)
+                      .length !=
+                  2) {
+                return 'PAT must be in this format: username:token';
+              }
+            }
+            return null;
+          }
+        ],
+        hint: 'username:token',
+        belowWidgets: [
+          const SizedBox(
+            height: 8,
+          ),
+          GestureDetector(
+              onTap: () {
+                launchUrlString(
+                    'https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token',
+                    mode: LaunchMode.externalApplication);
+              },
+              child: const Text(
+                'About GitHub PATs',
+                style: TextStyle(
+                    decoration: TextDecoration.underline, fontSize: 12),
+              ))
+        ])
+  ];
+}

lib/app_sources/gitlab.dart

@@ -0,0 +1,81 @@
+import 'package:html/parser.dart';
+import 'package:http/http.dart';
+import 'package:obtainium/app_sources/github.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class GitLab implements AppSource {
+  @override
+  late String host = 'gitlab.com';
+
+  @override
+  String standardizeURL(String url) {
+    RegExp standardUrlRegEx = RegExp('^https?://$host/[^/]+/[^/]+');
+    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
+    if (match == null) {
+      throw notValidURL(runtimeType.toString());
+    }
+    return url.substring(0, match.end);
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) =>
+      '$standardUrl/-/releases';
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async => apkUrl;
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    Response res = await get(Uri.parse('$standardUrl/-/tags?format=atom'));
+    if (res.statusCode == 200) {
+      var standardUri = Uri.parse(standardUrl);
+      var parsedHtml = parse(res.body);
+      var entry = parsedHtml.querySelector('entry');
+      var entryContent =
+          parse(parseFragment(entry?.querySelector('content')!.innerHtml).text);
+      var apkUrlList = [
+        ...getLinksFromParsedHTML(
+            entryContent,
+            RegExp(
+                '^${escapeRegEx(standardUri.path)}/uploads/[^/]+/[^/]+\\.apk\$',
+                caseSensitive: false),
+            standardUri.origin),
+        // GitLab releases may contain links to externally hosted APKs
+        ...getLinksFromParsedHTML(entryContent,
+                RegExp('/[^/]+\\.apk\$', caseSensitive: false), '')
+            .where((element) => Uri.parse(element).host != '')
+            .toList()
+      ];
+      if (apkUrlList.isEmpty) {
+        throw noAPKFound;
+      }
+
+      var entryId = entry?.querySelector('id')?.innerHtml;
+      var version =
+          entryId == null ? null : Uri.parse(entryId).pathSegments.last;
+      if (version == null) {
+        throw couldNotFindLatestVersion;
+      }
+      return APKDetails(version, apkUrlList);
+    } else {
+      throw couldNotFindReleases;
+    }
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) {
+    // Same as GitHub
+    return GitHub().getAppNames(standardUrl);
+  }
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [];
+
+  @override
+  List<String> additionalDataDefaults = [];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [];
+}

lib/app_sources/izzyondroid.dart

@@ -0,0 +1,74 @@
+import 'package:html/parser.dart';
+import 'package:http/http.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class IzzyOnDroid implements AppSource {
+  @override
+  late String host = 'android.izzysoft.de';
+
+  @override
+  String standardizeURL(String url) {
+    RegExp standardUrlRegEx = RegExp('^https?://$host/repo/apk/[^/]+');
+    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
+    if (match == null) {
+      throw notValidURL(runtimeType.toString());
+    }
+    return url.substring(0, match.end);
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) => null;
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async => apkUrl;
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    Response res = await get(Uri.parse(standardUrl));
+    if (res.statusCode == 200) {
+      var parsedHtml = parse(res.body);
+      var multipleVersionApkUrls = parsedHtml
+          .querySelectorAll('a')
+          .where((element) =>
+              element.attributes['href']?.toLowerCase().endsWith('.apk') ??
+              false)
+          .map((e) => 'https://$host${e.attributes['href'] ?? ''}')
+          .toList();
+      if (multipleVersionApkUrls.isEmpty) {
+        throw noAPKFound;
+      }
+      var version = parsedHtml
+          .querySelector('#keydata')
+          ?.querySelectorAll('b')
+          .where(
+              (element) => element.innerHtml.toLowerCase().contains('version'))
+          .toList()[0]
+          .parentNode
+          ?.parentNode
+          ?.children[1]
+          .innerHtml;
+      if (version == null) {
+        throw couldNotFindLatestVersion;
+      }
+      return APKDetails(version, [multipleVersionApkUrls[0]]);
+    } else {
+      throw couldNotFindReleases;
+    }
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) {
+    return AppNames('IzzyOnDroid', Uri.parse(standardUrl).pathSegments.last);
+  }
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [];
+
+  @override
+  List<String> additionalDataDefaults = [];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [];
+}

lib/app_sources/mullvad.dart

@@ -0,0 +1,61 @@
+import 'package:html/parser.dart';
+import 'package:http/http.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class Mullvad implements AppSource {
+  @override
+  late String host = 'mullvad.net';
+
+  @override
+  String standardizeURL(String url) {
+    RegExp standardUrlRegEx = RegExp('^https?://$host');
+    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
+    if (match == null) {
+      throw notValidURL(runtimeType.toString());
+    }
+    return url.substring(0, match.end);
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) =>
+      'https://github.com/mullvad/mullvadvpn-app/blob/master/CHANGELOG.md';
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async => apkUrl;
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    Response res = await get(Uri.parse('$standardUrl/en/download/android'));
+    if (res.statusCode == 200) {
+      var version = parse(res.body)
+          .querySelector('p.subtitle.is-6')
+          ?.querySelector('a')
+          ?.attributes['href']
+          ?.split('/')
+          .last;
+      if (version == null) {
+        throw couldNotFindLatestVersion;
+      }
+      return APKDetails(
+          version, ['https://mullvad.net/download/app/apk/latest']);
+    } else {
+      throw couldNotFindReleases;
+    }
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) {
+    return AppNames('Mullvad-VPN', 'Mullvad-VPN');
+  }
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [];
+
+  @override
+  List<String> additionalDataDefaults = [];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [];
+}

lib/app_sources/signal.dart

@@ -0,0 +1,53 @@
+import 'dart:convert';
+import 'package:http/http.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class Signal implements AppSource {
+  @override
+  late String host = 'signal.org';
+
+  @override
+  String standardizeURL(String url) {
+    return 'https://$host';
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) => null;
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async => apkUrl;
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    Response res =
+        await get(Uri.parse('https://updates.$host/android/latest.json'));
+    if (res.statusCode == 200) {
+      var json = jsonDecode(res.body);
+      String? apkUrl = json['url'];
+      if (apkUrl == null) {
+        throw noAPKFound;
+      }
+      String? version = json['versionName'];
+      if (version == null) {
+        throw couldNotFindLatestVersion;
+      }
+      return APKDetails(version, [apkUrl]);
+    } else {
+      throw couldNotFindReleases;
+    }
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) => AppNames('Signal', 'Signal');
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [];
+
+  @override
+  List<String> additionalDataDefaults = [];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [];
+}

lib/app_sources/sourceforge.dart

@@ -0,0 +1,77 @@
+import 'package:html/parser.dart';
+import 'package:http/http.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class SourceForge implements AppSource {
+  @override
+  late String host = 'sourceforge.net';
+
+  @override
+  String standardizeURL(String url) {
+    RegExp standardUrlRegEx = RegExp('^https?://$host/projects/[^/]+');
+    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
+    if (match == null) {
+      throw notValidURL(runtimeType.toString());
+    }
+    return url.substring(0, match.end);
+  }
+
+  @override
+  String? changeLogPageFromStandardUrl(String standardUrl) => null;
+
+  @override
+  Future<String> apkUrlPrefetchModifier(String apkUrl) async => apkUrl;
+
+  @override
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData) async {
+    Response res = await get(Uri.parse('$standardUrl/rss?path=/'));
+    if (res.statusCode == 200) {
+      var parsedHtml = parse(res.body);
+      var allDownloadLinks =
+          parsedHtml.querySelectorAll('guid').map((e) => e.innerHtml).toList();
+      getVersion(String url) {
+        try {
+          var tokens = url.split('/');
+          return tokens[tokens.length - 3];
+        } catch (e) {
+          return null;
+        }
+      }
+
+      String? version = getVersion(allDownloadLinks[0]);
+      if (version == null) {
+        throw couldNotFindLatestVersion;
+      }
+      var apkUrlListAllReleases = allDownloadLinks
+          .where((element) => element.toLowerCase().endsWith('.apk/download'))
+          .toList();
+      var apkUrlList =
+          apkUrlListAllReleases // This can be used skipped for fallback support later
+              .where((element) => getVersion(element) == version)
+              .toList();
+      if (apkUrlList.isEmpty) {
+        throw noAPKFound;
+      }
+      return APKDetails(version, apkUrlList);
+    } else {
+      throw couldNotFindReleases;
+    }
+  }
+
+  @override
+  AppNames getAppNames(String standardUrl) {
+    return AppNames(runtimeType.toString(),
+        standardUrl.substring(standardUrl.lastIndexOf('/') + 1));
+  }
+
+  @override
+  List<List<GeneratedFormItem>> additionalDataFormItems = [];
+
+  @override
+  List<String> additionalDataDefaults = [];
+
+  @override
+  List<GeneratedFormItem> moreSourceSettingsFormItems = [];
+}

lib/components/custom_app_bar.dart

@@ -0,0 +1,29 @@
+import 'package:flutter/material.dart';
+
+class CustomAppBar extends StatefulWidget {
+  const CustomAppBar({super.key, required this.title});
+
+  final String title;
+
+  @override
+  State<CustomAppBar> createState() => _CustomAppBarState();
+}
+
+class _CustomAppBarState extends State<CustomAppBar> {
+  @override
+  Widget build(BuildContext context) {
+    return SliverAppBar(
+      pinned: true,
+      automaticallyImplyLeading: false,
+      expandedHeight: 100,
+      flexibleSpace: FlexibleSpaceBar(
+        titlePadding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
+        title: Text(
+          widget.title,
+          style:
+              TextStyle(color: Theme.of(context).textTheme.bodyMedium!.color),
+        ),
+      ),
+    );
+  }
+}

lib/components/generated_form.dart

@@ -0,0 +1,188 @@
+import 'package:flutter/material.dart';
+
+enum FormItemType { string, bool }
+
+typedef OnValueChanges = void Function(List<String> values, bool valid);
+
+class GeneratedFormItem {
+  late String label;
+  late FormItemType type;
+  late bool required;
+  late int max;
+  late List<String? Function(String? value)> additionalValidators;
+  late String id;
+  late List<Widget> belowWidgets;
+  late String? hint;
+
+  GeneratedFormItem(
+      {this.label = 'Input',
+      this.type = FormItemType.string,
+      this.required = true,
+      this.max = 1,
+      this.additionalValidators = const [],
+      this.id = 'input',
+      this.belowWidgets = const [],
+      this.hint});
+}
+
+class GeneratedForm extends StatefulWidget {
+  const GeneratedForm(
+      {super.key,
+      required this.items,
+      required this.onValueChanges,
+      required this.defaultValues});
+
+  final List<List<GeneratedFormItem>> items;
+  final OnValueChanges onValueChanges;
+  final List<String> defaultValues;
+
+  @override
+  State<GeneratedForm> createState() => _GeneratedFormState();
+}
+
+class _GeneratedFormState extends State<GeneratedForm> {
+  final _formKey = GlobalKey<FormState>();
+  late List<List<String>> values;
+  late List<List<Widget>> formInputs;
+  List<List<Widget>> rows = [];
+
+  // If any value changes, call this to update the parent with value and validity
+  void someValueChanged() {
+    List<String> returnValues = [];
+    var valid = true;
+    for (int r = 0; r < values.length; r++) {
+      for (int i = 0; i < values[r].length; i++) {
+        returnValues.add(values[r][i]);
+        if (formInputs[r][i] is TextFormField) {
+          valid = valid &&
+              ((formInputs[r][i].key as GlobalKey<FormFieldState>)
+                      .currentState
+                      ?.isValid ??
+                  false);
+        }
+      }
+    }
+    widget.onValueChanges(returnValues, valid);
+  }
+
+  @override
+  void initState() {
+    super.initState();
+
+    // Initialize form values as all empty
+    int j = 0;
+    values = widget.items
+        .map((row) => row.map((e) {
+              return j < widget.defaultValues.length
+                  ? widget.defaultValues[j++]
+                  : '';
+            }).toList())
+        .toList();
+
+    // Dynamically create form inputs
+    formInputs = widget.items.asMap().entries.map((row) {
+      return row.value.asMap().entries.map((e) {
+        if (e.value.type == FormItemType.string) {
+          final formFieldKey = GlobalKey<FormFieldState>();
+          return TextFormField(
+            key: formFieldKey,
+            initialValue: values[row.key][e.key],
+            autovalidateMode: AutovalidateMode.onUserInteraction,
+            onChanged: (value) {
+              setState(() {
+                values[row.key][e.key] = value;
+                someValueChanged();
+              });
+            },
+            decoration: InputDecoration(
+                helperText: e.value.label + (e.value.required ? ' *' : ''),
+                hintText: e.value.hint),
+            minLines: e.value.max <= 1 ? null : e.value.max,
+            maxLines: e.value.max <= 1 ? 1 : e.value.max,
+            validator: (value) {
+              if (e.value.required && (value == null || value.trim().isEmpty)) {
+                return '${e.value.label} (required)';
+              }
+              for (var validator in e.value.additionalValidators) {
+                String? result = validator(value);
+                if (result != null) {
+                  return result;
+                }
+              }
+              return null;
+            },
+          );
+        } else {
+          return Container(); // Some input types added in build
+        }
+      }).toList();
+    }).toList();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    for (var r = 0; r < formInputs.length; r++) {
+      for (var e = 0; e < formInputs[r].length; e++) {
+        if (widget.items[r][e].type == FormItemType.bool) {
+          formInputs[r][e] = Row(
+            mainAxisAlignment: MainAxisAlignment.spaceBetween,
+            children: [
+              Text(widget.items[r][e].label),
+              Switch(
+                  value: values[r][e] == 'true',
+                  onChanged: (value) {
+                    setState(() {
+                      values[r][e] = value ? 'true' : '';
+                      someValueChanged();
+                    });
+                  })
+            ],
+          );
+        }
+      }
+    }
+
+    rows.clear();
+    formInputs.asMap().entries.forEach((rowInputs) {
+      if (rowInputs.key > 0) {
+        rows.add([
+          SizedBox(
+            height: widget.items[rowInputs.key][0].type == FormItemType.bool &&
+                    widget.items[rowInputs.key - 1][0].type ==
+                        FormItemType.string
+                ? 25
+                : 8,
+          )
+        ]);
+      }
+      List<Widget> rowItems = [];
+      rowInputs.value.asMap().entries.forEach((rowInput) {
+        if (rowInput.key > 0) {
+          rowItems.add(const SizedBox(
+            width: 20,
+          ));
+        }
+        rowItems.add(Expanded(
+            child: Column(
+                crossAxisAlignment: CrossAxisAlignment.stretch,
+                children: [
+              rowInput.value,
+              ...widget.items[rowInputs.key][rowInput.key].belowWidgets
+            ])));
+      });
+      rows.add(rowItems);
+    });
+
+    return Form(
+        key: _formKey,
+        child: Column(
+          children: [
+            ...rows.map((row) => Row(
+                  mainAxisAlignment: MainAxisAlignment.start,
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [...row.map((e) => e)],
+                ))
+          ],
+        ));
+  }
+}

lib/components/generated_form_modal.dart

@@ -0,0 +1,75 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:obtainium/components/generated_form.dart';
+
+class GeneratedFormModal extends StatefulWidget {
+  const GeneratedFormModal(
+      {super.key,
+      required this.title,
+      required this.items,
+      required this.defaultValues,
+      this.initValid = false,
+      this.message = ''});
+
+  final String title;
+  final String message;
+  final List<List<GeneratedFormItem>> items;
+  final List<String> defaultValues;
+  final bool initValid;
+
+  @override
+  State<GeneratedFormModal> createState() => _GeneratedFormModalState();
+}
+
+class _GeneratedFormModalState extends State<GeneratedFormModal> {
+  List<String> values = [];
+  bool valid = false;
+
+  @override
+  void initState() {
+    super.initState();
+    valid = widget.initValid;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AlertDialog(
+      scrollable: true,
+      title: Text(widget.title),
+      content:
+          Column(crossAxisAlignment: CrossAxisAlignment.stretch, children: [
+        if (widget.message.isNotEmpty) Text(widget.message),
+        if (widget.message.isNotEmpty)
+          const SizedBox(
+            height: 16,
+          ),
+        GeneratedForm(
+            items: widget.items,
+            onValueChanges: (values, valid) {
+              setState(() {
+                this.values = values;
+                this.valid = valid;
+              });
+            },
+            defaultValues: widget.defaultValues)
+      ]),
+      actions: [
+        TextButton(
+            onPressed: () {
+              Navigator.of(context).pop(null);
+            },
+            child: const Text('Cancel')),
+        TextButton(
+            onPressed: !valid
+                ? null
+                : () {
+                    if (valid) {
+                      HapticFeedback.selectionClick();
+                      Navigator.of(context).pop(values);
+                    }
+                  },
+            child: const Text('Continue'))
+      ],
+    );
+  }
+}

lib/custom_errors.dart

@@ -0,0 +1,8 @@
+class RateLimitError {
+  late int remainingMinutes;
+  RateLimitError(this.remainingMinutes);
+
+  @override
+  String toString() =>
+      'Too many requests (rate limited) - try again in $remainingMinutes minutes';
+}

lib/main.dart

@@ -1,5 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
+import 'package:obtainium/app_sources/github.dart';
+import 'package:obtainium/custom_errors.dart';
 import 'package:obtainium/pages/home.dart';
 import 'package:obtainium/providers/apps_provider.dart';
 import 'package:obtainium/providers/notifications_provider.dart';
@@ -9,59 +11,118 @@ import 'package:permission_handler/permission_handler.dart';
 import 'package:provider/provider.dart';
 import 'package:workmanager/workmanager.dart';
 import 'package:dynamic_color/dynamic_color.dart';
+import 'package:device_info_plus/device_info_plus.dart';
 
 const String currentReleaseTag =
-    'v0.1.3-beta'; // KEEP THIS IN SYNC WITH GITHUB RELEASES
+    'v0.5.5-beta'; // KEEP THIS IN SYNC WITH GITHUB RELEASES
+
+const String bgUpdateCheckTaskName = 'bg-update-check';
+
+bgUpdateCheck(int? ignoreAfterMicroseconds) async {
+  DateTime? ignoreAfter = ignoreAfterMicroseconds != null
+      ? DateTime.fromMicrosecondsSinceEpoch(ignoreAfterMicroseconds)
+      : null;
+  var notificationsProvider = NotificationsProvider();
+  await notificationsProvider.notify(checkingUpdatesNotification);
+  try {
+    var appsProvider = AppsProvider();
+    await notificationsProvider.cancel(ErrorCheckingUpdatesNotification('').id);
+    await appsProvider.loadApps();
+    List<String> existingUpdateIds =
+        appsProvider.getExistingUpdates(installedOnly: true);
+    DateTime nextIgnoreAfter = DateTime.now();
+    try {
+      await appsProvider.checkUpdates(ignoreAfter: ignoreAfter);
+    } catch (e) {
+      if (e is RateLimitError) {
+        String nextTaskName =
+            '$bgUpdateCheckTaskName-${nextIgnoreAfter.microsecondsSinceEpoch.toString()}';
+        Workmanager().registerOneOffTask(nextTaskName, nextTaskName,
+            constraints: Constraints(networkType: NetworkType.connected),
+            initialDelay: Duration(minutes: e.remainingMinutes),
+            inputData: {'ignoreAfter': nextIgnoreAfter.microsecondsSinceEpoch});
+      } else {
+        rethrow;
+      }
+    }
+    List<App> newUpdates = appsProvider
+        .getExistingUpdates(installedOnly: true)
+        .where((id) => !existingUpdateIds.contains(id))
+        .map((e) => appsProvider.apps[e]!.app)
+        .toList();
+
+    // TODO: This silent update code doesn't work yet
+    // List<String> silentlyUpdated = await appsProvider
+    //     .downloadAndInstallLatestApp(
+    //         [...newUpdates.map((e) => e.id), ...existingUpdateIds], null);
+    // if (silentlyUpdated.isNotEmpty) {
+    //   newUpdates = newUpdates
+    //       .where((element) => !silentlyUpdated.contains(element.id))
+    //       .toList();
+    //   notificationsProvider.notify(
+    //       SilentUpdateNotification(
+    //           silentlyUpdated.map((e) => appsProvider.apps[e]!.app).toList()),
+    //       cancelExisting: true);
+    // }
+
+    if (newUpdates.isNotEmpty) {
+      notificationsProvider.notify(UpdateNotification(newUpdates),
+          cancelExisting: true);
+    }
+    return Future.value(true);
+  } catch (e) {
+    notificationsProvider.notify(ErrorCheckingUpdatesNotification(e.toString()),
+        cancelExisting: true);
+    return Future.error(false);
+  } finally {
+    await notificationsProvider.cancel(checkingUpdatesNotification.id);
+  }
+}
 
 @pragma('vm:entry-point')
 void bgTaskCallback() {
-  // Background update checking process
-  Workmanager().executeTask((task, taskName) async {
-    var appsProvider = AppsProvider(bg: true);
-    var notificationsProvider = NotificationsProvider();
-    await notificationsProvider.notify(checkingUpdatesNotification);
-    try {
-      await appsProvider.loadApps();
-      List<App> updates = await appsProvider.checkUpdates();
-      if (updates.isNotEmpty) {
-        notificationsProvider.notify(UpdateNotification(updates),
-            cancelExisting: true);
-      }
-      return Future.value(true);
-    } catch (e) {
-      notificationsProvider.notify(
-          ErrorCheckingUpdatesNotification(e.toString()),
-          cancelExisting: true);
-      return Future.value(false);
-    } finally {
-      await notificationsProvider.cancel(checkingUpdatesNotification.id);
-    }
+  // Background process callback
+  Workmanager().executeTask((task, inputData) async {
+    return await bgUpdateCheck(inputData?['ignoreAfter']);
   });
 }
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
-  SystemChrome.setSystemUIOverlayStyle(
-    const SystemUiOverlayStyle(systemNavigationBarColor: Colors.transparent),
-  );
-  SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge);
+  if ((await DeviceInfoPlugin().androidInfo).version.sdkInt! >= 29) {
+    SystemChrome.setSystemUIOverlayStyle(
+      const SystemUiOverlayStyle(systemNavigationBarColor: Colors.transparent),
+    );
+    SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge);
+  }
   Workmanager().initialize(
     bgTaskCallback,
   );
   runApp(MultiProvider(
     providers: [
-      ChangeNotifierProvider(create: (context) => AppsProvider()),
+      ChangeNotifierProvider(
+          create: (context) => AppsProvider(
+              shouldLoadApps: true,
+              shouldCheckUpdatesAfterLoad: false,
+              shouldDeleteAPKs: true)),
       ChangeNotifierProvider(create: (context) => SettingsProvider()),
       Provider(create: (context) => NotificationsProvider())
     ],
-    child: const MyApp(),
+    child: const Obtainium(),
   ));
 }
 
 var defaultThemeColour = Colors.deepPurple;
 
-class MyApp extends StatelessWidget {
-  const MyApp({super.key});
+class Obtainium extends StatefulWidget {
+  const Obtainium({super.key});
+
+  @override
+  State<Obtainium> createState() => _ObtainiumState();
+}
+
+class _ObtainiumState extends State<Obtainium> {
+  var existingUpdateInterval = -1;
 
   @override
   Widget build(BuildContext context) {
@@ -69,30 +130,42 @@ class MyApp extends StatelessWidget {
     AppsProvider appsProvider = context.read<AppsProvider>();
 
     if (settingsProvider.prefs == null) {
-      settingsProvider.initializeSettings().then((value) {
-        // Delete past downloads and check for updates every time the app is launched
-        // Only runs once as the settings are only initialized once (so not on every build)
-        appsProvider.deleteSavedAPKs();
-        appsProvider.checkUpdates();
-      });
+      settingsProvider.initializeSettings();
     } else {
-      // Register the background update task according to the user's setting
-      Workmanager().registerPeriodicTask('bg-update-check', 'bg-update-check',
-          frequency: Duration(minutes: settingsProvider.updateInterval),
-          initialDelay: Duration(minutes: settingsProvider.updateInterval),
-          constraints: Constraints(networkType: NetworkType.connected),
-          existingWorkPolicy: ExistingWorkPolicy.replace);
       bool isFirstRun = settingsProvider.checkAndFlipFirstRun();
       if (isFirstRun) {
         // If this is the first run, ask for notification permissions and add Obtainium to the Apps list
         Permission.notification.request();
-        appsProvider.saveApp(App(
-            'imranr98_obtainium_github',
-            'https://github.com/ImranR98/Obtainium',
-            'ImranR98',
-            'Obtainium',
-            currentReleaseTag,
-            currentReleaseTag, []));
+        appsProvider.saveApps([
+          App(
+              'imranr98_obtainium_${GitHub().host}',
+              'https://github.com/ImranR98/Obtainium',
+              'ImranR98',
+              'Obtainium',
+              currentReleaseTag,
+              currentReleaseTag,
+              [],
+              0,
+              ['true'],
+              null)
+        ]);
+      }
+      // Register the background update task according to the user's setting
+      if (existingUpdateInterval != settingsProvider.updateInterval) {
+        existingUpdateInterval = settingsProvider.updateInterval;
+        if (existingUpdateInterval == 0) {
+          Workmanager().cancelByUniqueName(bgUpdateCheckTaskName);
+        } else {
+          Workmanager().registerPeriodicTask(
+              bgUpdateCheckTaskName, bgUpdateCheckTaskName,
+              frequency: Duration(minutes: existingUpdateInterval),
+              initialDelay: Duration(minutes: existingUpdateInterval),
+              constraints: Constraints(networkType: NetworkType.connected),
+              existingWorkPolicy: ExistingWorkPolicy.replace,
+              backoffPolicy: BackoffPolicy.linear,
+              backoffPolicyDelay:
+                  const Duration(minutes: minUpdateIntervalMinutes));
+        }
       }
     }
 
@@ -123,7 +196,8 @@ class MyApp extends StatelessWidget {
               useMaterial3: true,
               colorScheme: settingsProvider.theme == ThemeSettings.light
                   ? lightColorScheme
-                  : darkColorScheme),
+                  : darkColorScheme,
+              fontFamily: 'Metropolis'),
           home: const HomePage());
     });
   }

lib/mass_app_sources/githubstars.dart

@@ -0,0 +1,51 @@
+import 'dart:convert';
+
+import 'package:http/http.dart';
+import 'package:obtainium/app_sources/github.dart';
+import 'package:obtainium/custom_errors.dart';
+import 'package:obtainium/providers/source_provider.dart';
+
+class GitHubStars implements MassAppSource {
+  @override
+  late String name = 'GitHub Starred Repos';
+
+  @override
+  late List<String> requiredArgs = ['Username'];
+
+  Future<List<String>> getOnePageOfUserStarredUrls(
+      String username, int page) async {
+    Response res = await get(Uri.parse(
+        'https://${await GitHub().getCredentialPrefixIfAny()}api.github.com/users/$username/starred?per_page=100&page=$page'));
+    if (res.statusCode == 200) {
+      return (jsonDecode(res.body) as List<dynamic>)
+          .map((e) => e['html_url'] as String)
+          .toList();
+    } else {
+      if (res.headers['x-ratelimit-remaining'] == '0') {
+        throw RateLimitError(
+            (int.parse(res.headers['x-ratelimit-reset'] ?? '1800000000') /
+                    60000000)
+                .round());
+      }
+
+      throw 'Unable to find user\'s starred repos';
+    }
+  }
+
+  @override
+  Future<List<String>> getUrls(List<String> args) async {
+    if (args.length != requiredArgs.length) {
+      throw 'Wrong number of arguments provided';
+    }
+    List<String> urls = [];
+    var page = 1;
+    while (true) {
+      var pageUrls = await getOnePageOfUserStarredUrls(args[0], page++);
+      urls.addAll(pageUrls);
+      if (pageUrls.length < 100) {
+        break;
+      }
+    }
+    return urls;
+  }
+}

lib/pages/add_app.dart

@@ -1,9 +1,13 @@
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:obtainium/components/custom_app_bar.dart';
+import 'package:obtainium/components/generated_form.dart';
 import 'package:obtainium/pages/app.dart';
 import 'package:obtainium/providers/apps_provider.dart';
 import 'package:obtainium/providers/settings_provider.dart';
 import 'package:obtainium/providers/source_provider.dart';
 import 'package:provider/provider.dart';
+import 'package:url_launcher/url_launcher_string.dart';
 
 class AddAppPage extends StatefulWidget {
   const AddAppPage({super.key});
@@ -13,83 +17,214 @@ class AddAppPage extends StatefulWidget {
 }
 
 class _AddAppPageState extends State<AddAppPage> {
-  final _formKey = GlobalKey<FormState>();
-  final urlInputController = TextEditingController();
   bool gettingAppInfo = false;
 
+  String userInput = '';
+  AppSource? pickedSource;
+  List<String> additionalData = [];
+  String customName = '';
+  bool validAdditionalData = true;
+
   @override
   Widget build(BuildContext context) {
-    return Center(
-        child: Form(
-      key: _formKey,
-      child: Column(
-        crossAxisAlignment: CrossAxisAlignment.stretch,
-        children: [
-          const Spacer(),
-          Padding(
-              padding: const EdgeInsets.symmetric(horizontal: 16.0),
-              child: TextFormField(
-                decoration: const InputDecoration(
-                    hintText: 'https://github.com/Author/Project',
-                    helperText: 'Enter the App source URL'),
-                controller: urlInputController,
-                validator: (value) {
-                  if (value == null ||
-                      value.isEmpty ||
-                      Uri.tryParse(value) == null) {
-                    return 'Please enter a supported source URL';
-                  }
-                  return null;
-                },
-              )),
-          Padding(
-            padding:
-                const EdgeInsets.symmetric(vertical: 16.0, horizontal: 16.0),
-            child: ElevatedButton(
-              onPressed: gettingAppInfo
-                  ? null
-                  : () {
-                      if (_formKey.currentState!.validate()) {
-                        setState(() {
-                          gettingAppInfo = true;
-                        });
-                        sourceProvider()
-                            .getApp(urlInputController.value.text)
-                            .then((app) {
-                          var appsProvider = context.read<AppsProvider>();
-                          var settingsProvider =
-                              context.read<SettingsProvider>();
-                          if (appsProvider.apps.containsKey(app.id)) {
-                            throw 'App already added';
-                          }
-                          settingsProvider.getInstallPermission().then((_) {
-                            appsProvider.saveApp(app).then((_) {
-                              urlInputController.clear();
-                              Navigator.push(
-                                  context,
-                                  MaterialPageRoute(
-                                      builder: (context) =>
-                                          AppPage(appId: app.id)));
-                            });
-                          });
-                        }).catchError((e) {
-                          ScaffoldMessenger.of(context).showSnackBar(
-                            SnackBar(content: Text(e.toString())),
-                          );
-                        }).whenComplete(() {
-                          setState(() {
-                            gettingAppInfo = false;
-                          });
-                        });
-                      }
-                    },
-              child: const Text('Add'),
-            ),
-          ),
-          const Spacer(),
-          if (gettingAppInfo) const LinearProgressIndicator(),
-        ],
-      ),
-    ));
+    SourceProvider sourceProvider = SourceProvider();
+    return Scaffold(
+        backgroundColor: Theme.of(context).colorScheme.surface,
+        body: CustomScrollView(slivers: <Widget>[
+          const CustomAppBar(title: 'Add App'),
+          SliverFillRemaining(
+            child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.stretch,
+                    children: [
+                      Row(
+                        children: [
+                          Expanded(
+                              child: GeneratedForm(
+                                  items: [
+                                    [
+                                      GeneratedFormItem(
+                                          label: 'App Source Url',
+                                          additionalValidators: [
+                                            (value) {
+                                              try {
+                                                sourceProvider
+                                                    .getSource(value ?? '')
+                                                    .standardizeURL(
+                                                        preStandardizeUrl(
+                                                            value ?? ''));
+                                              } catch (e) {
+                                                return e is String
+                                                    ? e
+                                                    : 'Error';
+                                              }
+                                              return null;
+                                            }
+                                          ])
+                                    ]
+                                  ],
+                                  onValueChanges: (values, valid) {
+                                    setState(() {
+                                      userInput = values[0];
+                                      var source = valid
+                                          ? sourceProvider.getSource(userInput)
+                                          : null;
+                                      if (pickedSource != source) {
+                                        pickedSource = source;
+                                        additionalData = source != null
+                                            ? source.additionalDataDefaults
+                                            : [];
+                                        validAdditionalData = source != null
+                                            ? sourceProvider
+                                                .doesSourceHaveRequiredAdditionalData(
+                                                    source)
+                                            : true;
+                                        if (source == null) {
+                                          customName = '';
+                                        }
+                                      }
+                                    });
+                                  },
+                                  defaultValues: const [])),
+                          const SizedBox(
+                            width: 16,
+                          ),
+                          ElevatedButton(
+                              onPressed: gettingAppInfo ||
+                                      pickedSource == null ||
+                                      (pickedSource!.additionalDataFormItems
+                                              .isNotEmpty &&
+                                          !validAdditionalData)
+                                  ? null
+                                  : () {
+                                      HapticFeedback.selectionClick();
+                                      setState(() {
+                                        gettingAppInfo = true;
+                                      });
+                                      sourceProvider
+                                          .getApp(pickedSource!, userInput,
+                                              additionalData,
+                                              customName: customName)
+                                          .then((app) {
+                                        var appsProvider =
+                                            context.read<AppsProvider>();
+                                        var settingsProvider =
+                                            context.read<SettingsProvider>();
+                                        if (appsProvider.apps
+                                            .containsKey(app.id)) {
+                                          throw 'App already added';
+                                        }
+                                        settingsProvider
+                                            .getInstallPermission()
+                                            .then((_) {
+                                          appsProvider
+                                              .saveApps([app]).then((_) {
+                                            Navigator.push(
+                                                context,
+                                                MaterialPageRoute(
+                                                    builder: (context) =>
+                                                        AppPage(
+                                                            appId: app.id)));
+                                          });
+                                        });
+                                      }).catchError((e) {
+                                        ScaffoldMessenger.of(context)
+                                            .showSnackBar(
+                                          SnackBar(content: Text(e.toString())),
+                                        );
+                                      }).whenComplete(() {
+                                        setState(() {
+                                          gettingAppInfo = false;
+                                        });
+                                      });
+                                    },
+                              child: const Text('Add'))
+                        ],
+                      ),
+                      if (pickedSource != null)
+                        Column(
+                          crossAxisAlignment: CrossAxisAlignment.stretch,
+                          children: [
+                            const Divider(
+                              height: 64,
+                            ),
+                            Text(
+                                'Additional Options for ${pickedSource?.runtimeType}',
+                                style: TextStyle(
+                                    color:
+                                        Theme.of(context).colorScheme.primary)),
+                            const SizedBox(
+                              height: 16,
+                            ),
+                            if (pickedSource!
+                                .additionalDataFormItems.isNotEmpty)
+                              GeneratedForm(
+                                  items: pickedSource!.additionalDataFormItems,
+                                  onValueChanges: (values, valid) {
+                                    setState(() {
+                                      additionalData = values;
+                                      validAdditionalData = valid;
+                                    });
+                                  },
+                                  defaultValues:
+                                      pickedSource!.additionalDataDefaults),
+                            if (pickedSource!
+                                .additionalDataFormItems.isNotEmpty)
+                              const SizedBox(
+                                height: 8,
+                              ),
+                            if (pickedSource != null)
+                              GeneratedForm(
+                                  items: [
+                                    [
+                                      GeneratedFormItem(
+                                          label: 'Custom App Name',
+                                          required: false)
+                                    ]
+                                  ],
+                                  onValueChanges: (values, valid) {
+                                    setState(() {
+                                      customName = values[0];
+                                    });
+                                  },
+                                  defaultValues: [customName])
+                          ],
+                        )
+                      else
+                        Expanded(
+                            child: Column(
+                                crossAxisAlignment: CrossAxisAlignment.center,
+                                mainAxisAlignment: MainAxisAlignment.center,
+                                children: [
+                              // const SizedBox(
+                              //   height: 48,
+                              // ),
+                              const Text(
+                                'Supported Sources:',
+                              ),
+                              const SizedBox(
+                                height: 8,
+                              ),
+                              ...sourceProvider
+                                  .getSourceHosts()
+                                  .map((e) => GestureDetector(
+                                      onTap: () {
+                                        launchUrlString('https://$e',
+                                            mode:
+                                                LaunchMode.externalApplication);
+                                      },
+                                      child: Text(
+                                        e,
+                                        style: const TextStyle(
+                                            decoration:
+                                                TextDecoration.underline,
+                                            fontStyle: FontStyle.italic),
+                                      )))
+                                  .toList()
+                            ])),
+                    ])),
+          )
+        ]));
   }
 }

lib/pages/app.dart

@@ -1,5 +1,11 @@
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/components/generated_form_modal.dart';
 import 'package:obtainium/providers/apps_provider.dart';
+import 'package:obtainium/providers/settings_provider.dart';
+import 'package:obtainium/providers/source_provider.dart';
+import 'package:url_launcher/url_launcher_string.dart';
 import 'package:webview_flutter/webview_flutter.dart';
 import 'package:provider/provider.dart';
 
@@ -13,21 +19,102 @@ class AppPage extends StatefulWidget {
 }
 
 class _AppPageState extends State<AppPage> {
+  AppInMemory? prevApp;
+
   @override
   Widget build(BuildContext context) {
     var appsProvider = context.watch<AppsProvider>();
+    var settingsProvider = context.watch<SettingsProvider>();
+    getUpdate(String id) {
+      appsProvider.getUpdate(id).catchError((e) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text(e.toString())),
+        );
+      });
+    }
+
+    var sourceProvider = SourceProvider();
     AppInMemory? app = appsProvider.apps[widget.appId];
-    if (app?.app.installedVersion != null) {
-      appsProvider.getUpdate(app!.app.id);
+    var source = app != null ? sourceProvider.getSource(app.app.url) : null;
+    if (!appsProvider.areDownloadsRunning() && prevApp == null && app != null) {
+      prevApp = app;
+      getUpdate(app.app.id);
     }
     return Scaffold(
-      appBar: AppBar(
-        title: Text('${app?.app.author}/${app?.app.name}'),
-      ),
-      body: WebView(
-        initialUrl: app?.app.url,
-        javascriptMode: JavascriptMode.unrestricted,
-      ),
+      appBar: settingsProvider.showAppWebpage ? AppBar() : null,
+      backgroundColor: Theme.of(context).colorScheme.surface,
+      body: RefreshIndicator(
+          child: settingsProvider.showAppWebpage
+              ? WebView(
+                  initialUrl: app?.app.url,
+                  javascriptMode: JavascriptMode.unrestricted,
+                )
+              : CustomScrollView(
+                  slivers: [
+                    SliverFillRemaining(
+                        child: Column(
+                      mainAxisAlignment: MainAxisAlignment.center,
+                      crossAxisAlignment: CrossAxisAlignment.stretch,
+                      children: [
+                        Text(
+                          app?.app.name ?? 'App',
+                          textAlign: TextAlign.center,
+                          style: Theme.of(context).textTheme.displayLarge,
+                        ),
+                        Text(
+                          'By ${app?.app.author ?? 'Unknown'}',
+                          textAlign: TextAlign.center,
+                          style: Theme.of(context).textTheme.headlineMedium,
+                        ),
+                        const SizedBox(
+                          height: 32,
+                        ),
+                        GestureDetector(
+                            onTap: () {
+                              if (app?.app.url != null) {
+                                launchUrlString(app?.app.url ?? '',
+                                    mode: LaunchMode.externalApplication);
+                              }
+                            },
+                            child: Text(
+                              app?.app.url ?? '',
+                              textAlign: TextAlign.center,
+                              style: const TextStyle(
+                                  decoration: TextDecoration.underline,
+                                  fontStyle: FontStyle.italic,
+                                  fontSize: 12),
+                            )),
+                        const SizedBox(
+                          height: 32,
+                        ),
+                        Text(
+                          'Latest Version: ${app?.app.latestVersion ?? 'Unknown'}',
+                          textAlign: TextAlign.center,
+                          style: Theme.of(context).textTheme.bodyLarge,
+                        ),
+                        Text(
+                          'Installed Version: ${app?.app.installedVersion ?? 'None'}',
+                          textAlign: TextAlign.center,
+                          style: Theme.of(context).textTheme.bodyLarge,
+                        ),
+                        const SizedBox(
+                          height: 32,
+                        ),
+                        Text(
+                          'Last Update Check: ${app?.app.lastUpdateCheck == null ? 'Never' : '\n${app?.app.lastUpdateCheck?.toLocal()}'}',
+                          textAlign: TextAlign.center,
+                          style: const TextStyle(
+                              fontStyle: FontStyle.italic, fontSize: 12),
+                        )
+                      ],
+                    )),
+                  ],
+                ),
+          onRefresh: () async {
+            if (app != null) {
+              getUpdate(app.app.id);
+            }
+          }),
       bottomSheet: Padding(
           padding: EdgeInsets.fromLTRB(
               0, 0, 0, MediaQuery.of(context).padding.bottom),
@@ -39,17 +126,152 @@ class _AppPageState extends State<AppPage> {
                   child: Row(
                       mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                       children: [
+                        if (app?.app.installedVersion != app?.app.latestVersion)
+                          IconButton(
+                              onPressed: app?.downloadProgress != null
+                                  ? null
+                                  : () {
+                                      showDialog(
+                                          context: context,
+                                          builder: (BuildContext ctx) {
+                                            return AlertDialog(
+                                              title: Text(
+                                                  'App Already ${app?.app.installedVersion == null ? 'Installed' : 'Updated'}?'),
+                                              actions: [
+                                                TextButton(
+                                                    onPressed: () {
+                                                      Navigator.of(context)
+                                                          .pop();
+                                                    },
+                                                    child: const Text('No')),
+                                                TextButton(
+                                                    onPressed: () {
+                                                      HapticFeedback
+                                                          .selectionClick();
+                                                      var updatedApp = app?.app;
+                                                      if (updatedApp != null) {
+                                                        updatedApp
+                                                                .installedVersion =
+                                                            updatedApp
+                                                                .latestVersion;
+                                                        appsProvider.saveApps(
+                                                            [updatedApp]);
+                                                      }
+                                                      Navigator.of(context)
+                                                          .pop();
+                                                    },
+                                                    child: const Text(
+                                                        'Yes, Mark as Installed'))
+                                              ],
+                                            );
+                                          });
+                                    },
+                              tooltip: 'Mark as Installed',
+                              icon: const Icon(Icons.done))
+                        else
+                          IconButton(
+                              onPressed: app?.downloadProgress != null
+                                  ? null
+                                  : () {
+                                      showDialog(
+                                          context: context,
+                                          builder: (BuildContext ctx) {
+                                            return AlertDialog(
+                                              title: const Text(
+                                                  'App Not Installed?'),
+                                              actions: [
+                                                TextButton(
+                                                    onPressed: () {
+                                                      Navigator.of(context)
+                                                          .pop();
+                                                    },
+                                                    child: const Text('No')),
+                                                TextButton(
+                                                    onPressed: () {
+                                                      HapticFeedback
+                                                          .selectionClick();
+                                                      var updatedApp = app?.app;
+                                                      if (updatedApp != null) {
+                                                        updatedApp
+                                                                .installedVersion =
+                                                            null;
+                                                        appsProvider.saveApps(
+                                                            [updatedApp]);
+                                                      }
+                                                      Navigator.of(context)
+                                                          .pop();
+                                                    },
+                                                    child: const Text(
+                                                        'Yes, Mark as Not Installed'))
+                                              ],
+                                            );
+                                          });
+                                    },
+                              tooltip: 'Mark as Not Installed',
+                              icon: const Icon(Icons.no_cell_outlined)),
+                        if (source != null &&
+                            source.additionalDataFormItems.isNotEmpty)
+                          IconButton(
+                              onPressed: app?.downloadProgress != null
+                                  ? null
+                                  : () {
+                                      showDialog<List<String>>(
+                                          context: context,
+                                          builder: (BuildContext ctx) {
+                                            return GeneratedFormModal(
+                                                title: 'Additional Options',
+                                                items: [
+                                                  ...source
+                                                      .additionalDataFormItems,
+                                                  [
+                                                    GeneratedFormItem(
+                                                        label: 'App Name',
+                                                        required: true)
+                                                  ]
+                                                ],
+                                                defaultValues: app != null
+                                                    ? [
+                                                        ...app
+                                                            .app.additionalData,
+                                                        app.app.name
+                                                      ]
+                                                    : [
+                                                        ...source
+                                                            .additionalDataDefaults
+                                                      ]);
+                                          }).then((values) {
+                                        if (app != null && values != null) {
+                                          var changedApp = app.app;
+                                          var name = values.removeLast();
+                                          changedApp.name = name;
+                                          changedApp.additionalData = values;
+                                          appsProvider.saveApps(
+                                              [changedApp]).then((value) {
+                                            getUpdate(changedApp.id);
+                                          });
+                                        }
+                                      });
+                                    },
+                              tooltip: 'Additional Options',
+                              icon: const Icon(Icons.settings)),
+                        const SizedBox(width: 16.0),
                         Expanded(
                             child: ElevatedButton(
                                 onPressed: (app?.app.installedVersion == null ||
                                             appsProvider
                                                 .checkAppObjectForUpdate(
                                                     app!.app)) &&
-                                        app?.downloadProgress == null
+                                        !appsProvider.areDownloadsRunning()
                                     ? () {
+                                        HapticFeedback.heavyImpact();
                                         appsProvider
                                             .downloadAndInstallLatestApp(
-                                                [app!.app.id], context);
+                                                [app!.app.id],
+                                                context).then((res) {
+                                          if (res.isNotEmpty && mounted) {
+                                            Navigator.of(context).pop();
+                                          }
+                                        });
                                       }
                                     : null,
                                 child: Text(app?.app.installedVersion == null
@@ -70,9 +292,10 @@ class _AppPageState extends State<AppPage> {
                                           actions: [
                                             TextButton(
                                                 onPressed: () {
-                                                  appsProvider
-                                                      .removeApp(app!.app.id)
-                                                      .then((_) {
+                                                  HapticFeedback
+                                                      .selectionClick();
+                                                  appsProvider.removeApps(
+                                                      [app!.app.id]).then((_) {
                                                     int count = 0;
                                                     Navigator.of(context)
                                                         .popUntil((_) =>
@@ -90,8 +313,10 @@ class _AppPageState extends State<AppPage> {
                                       });
                                 },
                           style: TextButton.styleFrom(
-                              foregroundColor: Theme.of(context).errorColor,
-                              surfaceTintColor: Theme.of(context).errorColor),
+                              foregroundColor:
+                                  Theme.of(context).colorScheme.error,
+                              surfaceTintColor:
+                                  Theme.of(context).colorScheme.error),
                           child: const Text('Remove'),
                         ),
                       ])),

lib/pages/apps.dart

@@ -1,79 +1,467 @@
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:obtainium/components/custom_app_bar.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/components/generated_form_modal.dart';
 import 'package:obtainium/pages/app.dart';
 import 'package:obtainium/providers/apps_provider.dart';
 import 'package:obtainium/providers/settings_provider.dart';
+import 'package:obtainium/providers/source_provider.dart';
 import 'package:provider/provider.dart';
+import 'package:share_plus/share_plus.dart';
+import 'package:url_launcher/url_launcher_string.dart';
 
 class AppsPage extends StatefulWidget {
   const AppsPage({super.key});
 
   @override
-  State<AppsPage> createState() => _AppsPageState();
+  State<AppsPage> createState() => AppsPageState();
 }
 
-class _AppsPageState extends State<AppsPage> {
+class AppsPageState extends State<AppsPage> {
+  AppsFilter? filter;
+  var updatesOnlyFilter =
+      AppsFilter(includeUptodate: false, includeNonInstalled: false);
+  Set<String> selectedIds = {};
+
+  clearSelected() {
+    if (selectedIds.isNotEmpty) {
+      setState(() {
+        selectedIds.clear();
+      });
+      return true;
+    }
+    return false;
+  }
+
+  selectThese(List<String> appIds) {
+    if (selectedIds.isEmpty) {
+      setState(() {
+        for (var a in appIds) {
+          selectedIds.add(a);
+        }
+      });
+    }
+  }
+
   @override
   Widget build(BuildContext context) {
     var appsProvider = context.watch<AppsProvider>();
-    var existingUpdateAppIds = appsProvider.getExistingUpdates();
+    var settingsProvider = context.watch<SettingsProvider>();
+    var sortedApps = appsProvider.apps.values.toList();
+    var currentFilterIsUpdatesOnly =
+        filter?.isIdenticalTo(updatesOnlyFilter) ?? false;
+
+    selectedIds = selectedIds
+        .where((element) => sortedApps.map((e) => e.app.id).contains(element))
+        .toSet();
+
+    toggleAppSelected(String appId) {
+      setState(() {
+        if (selectedIds.contains(appId)) {
+          selectedIds.remove(appId);
+        } else {
+          selectedIds.add(appId);
+        }
+      });
+    }
+
+    if (filter != null) {
+      sortedApps = sortedApps.where((app) {
+        if (app.app.installedVersion == app.app.latestVersion &&
+            !(filter!.includeUptodate)) {
+          return false;
+        }
+        if (app.app.installedVersion == null &&
+            !(filter!.includeNonInstalled)) {
+          return false;
+        }
+        if (filter!.nameFilter.isEmpty && filter!.authorFilter.isEmpty) {
+          return true;
+        }
+        List<String> nameTokens = filter!.nameFilter
+            .split(' ')
+            .where((element) => element.trim().isNotEmpty)
+            .toList();
+        List<String> authorTokens = filter!.authorFilter
+            .split(' ')
+            .where((element) => element.trim().isNotEmpty)
+            .toList();
+
+        for (var t in nameTokens) {
+          if (!app.app.name.toLowerCase().contains(t.toLowerCase())) {
+            return false;
+          }
+        }
+        for (var t in authorTokens) {
+          if (!app.app.author.toLowerCase().contains(t.toLowerCase())) {
+            return false;
+          }
+        }
+        return true;
+      }).toList();
+    }
+
+    sortedApps.sort((a, b) {
+      int result = 0;
+      if (settingsProvider.sortColumn == SortColumnSettings.authorName) {
+        result =
+            (a.app.author + a.app.name).compareTo(b.app.author + b.app.name);
+      } else if (settingsProvider.sortColumn == SortColumnSettings.nameAuthor) {
+        result =
+            (a.app.name + a.app.author).compareTo(b.app.name + b.app.author);
+      }
+      return result;
+    });
+
+    if (settingsProvider.sortOrder == SortOrderSettings.ascending) {
+      sortedApps = sortedApps.reversed.toList();
+    }
+
+    var existingUpdateIdsAllOrSelected = appsProvider
+        .getExistingUpdates(installedOnly: true)
+        .where((element) => selectedIds.isEmpty
+            ? sortedApps.where((a) => a.app.id == element).isNotEmpty
+            : selectedIds.contains(element))
+        .toList();
+    var newInstallIdsAllOrSelected = appsProvider
+        .getExistingUpdates(nonInstalledOnly: true)
+        .where((element) => selectedIds.isEmpty
+            ? sortedApps.where((a) => a.app.id == element).isNotEmpty
+            : selectedIds.contains(element))
+        .toList();
 
     return Scaffold(
-        floatingActionButton: existingUpdateAppIds.isEmpty
-            ? null
-            : ElevatedButton.icon(
-                onPressed: appsProvider.apps.values
-                        .where((element) => element.downloadProgress != null)
-                        .isNotEmpty
-                    ? null
-                    : () {
-                        context
-                            .read<SettingsProvider>()
-                            .getInstallPermission()
-                            .then((_) {
-                          appsProvider.downloadAndInstallLatestApp(
-                              existingUpdateAppIds, context);
-                        });
-                      },
-                icon: const Icon(Icons.update),
-                label: const Text('Update All')),
-        body: Center(
-          child: appsProvider.loadingApps
-              ? const CircularProgressIndicator()
-              : appsProvider.apps.isEmpty
-                  ? Text(
-                      'No Apps',
-                      style: Theme.of(context).textTheme.headline4,
-                    )
-                  : RefreshIndicator(
-                      onRefresh: appsProvider.checkUpdates,
-                      child: ListView(
-                        children: appsProvider.apps.values
-                            .map(
-                              (e) => ListTile(
-                                title: Text('${e.app.author}/${e.app.name}'),
-                                subtitle: Text(
-                                    e.app.installedVersion ?? 'Not Installed'),
-                                trailing: e.downloadProgress != null
-                                    ? Text(
-                                        'Downloading - ${e.downloadProgress!.toInt()}%')
-                                    : (e.app.installedVersion != null &&
-                                            e.app.installedVersion !=
-                                                e.app.latestVersion
-                                        ? const Text('Update Available')
-                                        : null),
-                                onTap: () {
-                                  Navigator.push(
-                                    context,
-                                    MaterialPageRoute(
-                                        builder: (context) =>
-                                            AppPage(appId: e.app.id)),
-                                  );
-                                },
-                              ),
-                            )
-                            .toList(),
+      backgroundColor: Theme.of(context).colorScheme.surface,
+      body: RefreshIndicator(
+          onRefresh: () {
+            HapticFeedback.lightImpact();
+            return appsProvider.checkUpdates().catchError((e) {
+              ScaffoldMessenger.of(context).showSnackBar(
+                SnackBar(content: Text(e.toString())),
+              );
+            });
+          },
+          child: CustomScrollView(slivers: <Widget>[
+            const CustomAppBar(title: 'Apps'),
+            if (appsProvider.loadingApps || sortedApps.isEmpty)
+              SliverFillRemaining(
+                  child: Center(
+                      child: appsProvider.loadingApps
+                          ? const CircularProgressIndicator()
+                          : Text(
+                              appsProvider.apps.isEmpty
+                                  ? 'No Apps'
+                                  : 'No Apps for Filter',
+                              style: Theme.of(context).textTheme.headlineMedium,
+                              textAlign: TextAlign.center,
+                            ))),
+            SliverList(
+                delegate: SliverChildBuilderDelegate(
+                    (BuildContext context, int index) {
+              return ListTile(
+                selectedTileColor:
+                    Theme.of(context).colorScheme.primary.withOpacity(0.1),
+                selected: selectedIds.contains(sortedApps[index].app.id),
+                onLongPress: () {
+                  toggleAppSelected(sortedApps[index].app.id);
+                },
+                title: Text(sortedApps[index].app.name),
+                subtitle: Text('By ${sortedApps[index].app.author}'),
+                trailing: sortedApps[index].downloadProgress != null
+                    ? Text(
+                        'Downloading - ${sortedApps[index].downloadProgress?.toInt()}%')
+                    : (sortedApps[index].app.installedVersion != null &&
+                            sortedApps[index].app.installedVersion !=
+                                sortedApps[index].app.latestVersion
+                        ? Column(
+                            mainAxisAlignment: MainAxisAlignment.center,
+                            crossAxisAlignment: CrossAxisAlignment.end,
+                            children: [
+                              const Text('Update Available'),
+                              SourceProvider()
+                                          .getSource(sortedApps[index].app.url)
+                                          .changeLogPageFromStandardUrl(
+                                              sortedApps[index].app.url) ==
+                                      null
+                                  ? const SizedBox()
+                                  : GestureDetector(
+                                      onTap: () {
+                                        launchUrlString(
+                                            SourceProvider()
+                                                .getSource(
+                                                    sortedApps[index].app.url)
+                                                .changeLogPageFromStandardUrl(
+                                                    sortedApps[index].app.url)!,
+                                            mode:
+                                                LaunchMode.externalApplication);
+                                      },
+                                      child: const Text(
+                                        'See Changes',
+                                        style: TextStyle(
+                                            fontStyle: FontStyle.italic,
+                                            decoration:
+                                                TextDecoration.underline),
+                                      )),
+                            ],
+                          )
+                        : Text(sortedApps[index].app.installedVersion ??
+                            'Not Installed')),
+                onTap: () {
+                  if (selectedIds.isNotEmpty) {
+                    toggleAppSelected(sortedApps[index].app.id);
+                  } else {
+                    Navigator.push(
+                      context,
+                      MaterialPageRoute(
+                          builder: (context) =>
+                              AppPage(appId: sortedApps[index].app.id)),
+                    );
+                  }
+                },
+              );
+            }, childCount: sortedApps.length))
+          ])),
+      persistentFooterButtons: [
+        Row(
+          children: [
+            IconButton(
+                onPressed: () {
+                  selectedIds.isEmpty
+                      ? selectThese(sortedApps.map((e) => e.app.id).toList())
+                      : clearSelected();
+                },
+                icon: Icon(
+                  selectedIds.isEmpty
+                      ? Icons.select_all_outlined
+                      : Icons.deselect_outlined,
+                  color: Theme.of(context).colorScheme.primary,
+                ),
+                tooltip: selectedIds.isEmpty
+                    ? 'Select All'
+                    : 'Deselect ${selectedIds.length.toString()}'),
+            const VerticalDivider(),
+            Expanded(
+                child: Row(
+              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+              children: [
+                selectedIds.isEmpty
+                    ? const SizedBox()
+                    : IconButton(
+                        visualDensity: VisualDensity.compact,
+                        onPressed: () {
+                          showDialog<List<String>?>(
+                              context: context,
+                              builder: (BuildContext ctx) {
+                                return GeneratedFormModal(
+                                  title: 'Remove Selected Apps?',
+                                  items: const [],
+                                  defaultValues: const [],
+                                  initValid: true,
+                                  message:
+                                      '${selectedIds.length} App${selectedIds.length == 1 ? '' : 's'} will be removed from Obtainium but remain installed. You still need to uninstall ${selectedIds.length == 1 ? 'it' : 'them'} manually.',
+                                );
+                              }).then((values) {
+                            if (values != null) {
+                              appsProvider.removeApps(selectedIds.toList());
+                            }
+                          });
+                        },
+                        tooltip: 'Remove Selected Apps',
+                        icon: const Icon(Icons.delete_outline_outlined),
                       ),
+                IconButton(
+                    visualDensity: VisualDensity.compact,
+                    onPressed: appsProvider.areDownloadsRunning() ||
+                            (existingUpdateIdsAllOrSelected.isEmpty &&
+                                newInstallIdsAllOrSelected.isEmpty)
+                        ? null
+                        : () {
+                            HapticFeedback.heavyImpact();
+                            List<List<GeneratedFormItem>> formInputs = [];
+                            if (existingUpdateIdsAllOrSelected.isNotEmpty &&
+                                newInstallIdsAllOrSelected.isNotEmpty) {
+                              formInputs.add([
+                                GeneratedFormItem(
+                                    label:
+                                        'Update ${existingUpdateIdsAllOrSelected.length} App${existingUpdateIdsAllOrSelected.length == 1 ? '' : 's'}',
+                                    type: FormItemType.bool)
+                              ]);
+                              formInputs.add([
+                                GeneratedFormItem(
+                                    label:
+                                        'Install ${newInstallIdsAllOrSelected.length} new App${newInstallIdsAllOrSelected.length == 1 ? '' : 's'}',
+                                    type: FormItemType.bool)
+                              ]);
+                            }
+                            showDialog<List<String>?>(
+                                context: context,
+                                builder: (BuildContext ctx) {
+                                  return GeneratedFormModal(
+                                    title:
+                                        'Install${selectedIds.isEmpty ? ' ' : ' Selected '}Apps?',
+                                    message:
+                                        '${existingUpdateIdsAllOrSelected.length} update${existingUpdateIdsAllOrSelected.length == 1 ? '' : 's'} and ${newInstallIdsAllOrSelected.length} new install${newInstallIdsAllOrSelected.length == 1 ? '' : 's'}.',
+                                    items: formInputs,
+                                    defaultValues: const ['true', 'true'],
+                                    initValid: true,
+                                  );
+                                }).then((values) {
+                              if (values != null) {
+                                bool shouldInstallUpdates =
+                                    values.length < 2 || values[0] == 'true';
+                                bool shouldInstallNew =
+                                    values.length < 2 || values[1] == 'true';
+                                settingsProvider
+                                    .getInstallPermission()
+                                    .then((_) {
+                                  List<String> toInstall = [];
+                                  if (shouldInstallUpdates) {
+                                    toInstall
+                                        .addAll(existingUpdateIdsAllOrSelected);
+                                  }
+                                  if (shouldInstallNew) {
+                                    toInstall
+                                        .addAll(newInstallIdsAllOrSelected);
+                                  }
+                                  appsProvider.downloadAndInstallLatestApp(
+                                      toInstall, context);
+                                });
+                              }
+                            });
+                          },
+                    tooltip:
+                        'Install/Update${selectedIds.isEmpty ? ' ' : ' Selected '}Apps',
+                    icon: const Icon(
+                      Icons.file_download_outlined,
+                    )),
+                selectedIds.isEmpty
+                    ? const SizedBox()
+                    : IconButton(
+                        visualDensity: VisualDensity.compact,
+                        onPressed: () {
+                          String urls = '';
+                          for (var id in selectedIds) {
+                            urls += '${appsProvider.apps[id]!.app.url}\n';
+                          }
+                          urls = urls.substring(0, urls.length - 1);
+                          Share.share(urls,
+                              subject: 'Selected App URLs from Obtainium');
+                        },
+                        tooltip: 'Share Selected App URLs',
+                        icon: const Icon(Icons.share),
+                      ),
+              ],
+            )),
+            const VerticalDivider(),
+            IconButton(
+              visualDensity: VisualDensity.compact,
+              onPressed: () {
+                setState(() {
+                  if (currentFilterIsUpdatesOnly) {
+                    filter = null;
+                  } else {
+                    filter = updatesOnlyFilter;
+                  }
+                });
+              },
+              tooltip: currentFilterIsUpdatesOnly
+                  ? 'Remove Out-of-Date App Filter'
+                  : 'Show Out-of-Date Apps Only',
+              icon: Icon(
+                currentFilterIsUpdatesOnly
+                    ? Icons.update_disabled_rounded
+                    : Icons.update_rounded,
+                color: Theme.of(context).colorScheme.primary,
+              ),
+            ),
+            appsProvider.apps.isEmpty
+                ? const SizedBox()
+                : TextButton.icon(
+                    label: Text(
+                      filter == null ? 'Filter' : 'Filter *',
+                      style: TextStyle(
+                          fontWeight: filter == null
+                              ? FontWeight.normal
+                              : FontWeight.bold),
                     ),
-        ));
+                    onPressed: () {
+                      showDialog<List<String>?>(
+                          context: context,
+                          builder: (BuildContext ctx) {
+                            return GeneratedFormModal(
+                                title: 'Filter Apps',
+                                items: [
+                                  [
+                                    GeneratedFormItem(
+                                        label: 'App Name', required: false),
+                                    GeneratedFormItem(
+                                        label: 'Author', required: false)
+                                  ],
+                                  [
+                                    GeneratedFormItem(
+                                        label: 'Up to Date Apps',
+                                        type: FormItemType.bool)
+                                  ],
+                                  [
+                                    GeneratedFormItem(
+                                        label: 'Non-Installed Apps',
+                                        type: FormItemType.bool)
+                                  ]
+                                ],
+                                defaultValues: filter == null
+                                    ? AppsFilter().toValuesArray()
+                                    : filter!.toValuesArray());
+                          }).then((values) {
+                        if (values != null) {
+                          setState(() {
+                            filter = AppsFilter.fromValuesArray(values);
+                            if (AppsFilter().isIdenticalTo(filter!)) {
+                              filter = null;
+                            }
+                          });
+                        }
+                      });
+                    },
+                    icon: const Icon(Icons.filter_list_rounded))
+          ],
+        ),
+      ],
+    );
   }
 }
+
+class AppsFilter {
+  late String nameFilter;
+  late String authorFilter;
+  late bool includeUptodate;
+  late bool includeNonInstalled;
+
+  AppsFilter(
+      {this.nameFilter = '',
+      this.authorFilter = '',
+      this.includeUptodate = true,
+      this.includeNonInstalled = true});
+
+  List<String> toValuesArray() {
+    return [
+      nameFilter,
+      authorFilter,
+      includeUptodate ? 'true' : '',
+      includeNonInstalled ? 'true' : ''
+    ];
+  }
+
+  AppsFilter.fromValuesArray(List<String> values) {
+    nameFilter = values[0];
+    authorFilter = values[1];
+    includeUptodate = values[2] == 'true';
+    includeNonInstalled = values[3] == 'true';
+  }
+
+  bool isIdenticalTo(AppsFilter other) =>
+      authorFilter.trim() == other.authorFilter.trim() &&
+      nameFilter.trim() == other.nameFilter.trim() &&
+      includeUptodate == other.includeUptodate &&
+      includeNonInstalled == other.includeNonInstalled;
+}

lib/pages/home.dart

@@ -1,6 +1,9 @@
+import 'package:animations/animations.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
 import 'package:obtainium/pages/add_app.dart';
 import 'package:obtainium/pages/apps.dart';
+import 'package:obtainium/pages/import_export.dart';
 import 'package:obtainium/pages/settings.dart';
 
 class HomePage extends StatefulWidget {
@@ -10,32 +13,86 @@ class HomePage extends StatefulWidget {
   State<HomePage> createState() => _HomePageState();
 }
 
+class NavigationPageItem {
+  late String title;
+  late IconData icon;
+  late Widget widget;
+
+  NavigationPageItem(this.title, this.icon, this.widget);
+}
+
 class _HomePageState extends State<HomePage> {
-  int selectedIndex = 1;
-  List<Widget> pages = [
-    const SettingsPage(),
-    const AppsPage(),
-    const AddAppPage()
+  List<int> selectedIndexHistory = [];
+
+  List<NavigationPageItem> pages = [
+    NavigationPageItem(
+        'Apps', Icons.apps, AppsPage(key: GlobalKey<AppsPageState>())),
+    NavigationPageItem('Add App', Icons.add, const AddAppPage()),
+    NavigationPageItem(
+        'Import/Export', Icons.import_export, const ImportExportPage()),
+    NavigationPageItem('Settings', Icons.settings, const SettingsPage())
   ];
 
   @override
   Widget build(BuildContext context) {
-    return Scaffold(
-      appBar: AppBar(title: const Text('Obtainium')),
-      body: pages.elementAt(selectedIndex),
-      bottomNavigationBar: NavigationBar(
-        destinations: const [
-          NavigationDestination(icon: Icon(Icons.settings), label: 'Settings'),
-          NavigationDestination(icon: Icon(Icons.apps), label: 'Apps'),
-          NavigationDestination(icon: Icon(Icons.add), label: 'Add App'),
-        ],
-        onDestinationSelected: (int index) {
-          setState(() {
-            selectedIndex = index;
-          });
-        },
-        selectedIndex: selectedIndex,
-      ),
-    );
+    return WillPopScope(
+        child: Scaffold(
+          backgroundColor: Theme.of(context).colorScheme.surface,
+          body: PageTransitionSwitcher(
+            transitionBuilder: (
+              Widget child,
+              Animation<double> animation,
+              Animation<double> secondaryAnimation,
+            ) {
+              return SharedAxisTransition(
+                animation: animation,
+                secondaryAnimation: secondaryAnimation,
+                transitionType: SharedAxisTransitionType.horizontal,
+                child: child,
+              );
+            },
+            child: pages
+                .elementAt(selectedIndexHistory.isEmpty
+                    ? 0
+                    : selectedIndexHistory.last)
+                .widget,
+          ),
+          bottomNavigationBar: NavigationBar(
+            destinations: pages
+                .map((e) =>
+                    NavigationDestination(icon: Icon(e.icon), label: e.title))
+                .toList(),
+            onDestinationSelected: (int index) {
+              HapticFeedback.selectionClick();
+              setState(() {
+                if (index == 0) {
+                  selectedIndexHistory.clear();
+                } else if (selectedIndexHistory.isEmpty ||
+                    (selectedIndexHistory.isNotEmpty &&
+                        selectedIndexHistory.last != index)) {
+                  int existingInd = selectedIndexHistory.indexOf(index);
+                  if (existingInd >= 0) {
+                    selectedIndexHistory.removeAt(existingInd);
+                  }
+                  selectedIndexHistory.add(index);
+                }
+              });
+            },
+            selectedIndex:
+                selectedIndexHistory.isEmpty ? 0 : selectedIndexHistory.last,
+          ),
+        ),
+        onWillPop: () async {
+          if (selectedIndexHistory.isNotEmpty) {
+            setState(() {
+              selectedIndexHistory.removeLast();
+            });
+            return false;
+          }
+          return !(pages[0].widget.key as GlobalKey<AppsPageState>)
+              .currentState
+              ?.clearSelected();
+          // return !appsPageKey.currentState?.clearSelected();
+        });
   }
 }

lib/pages/import_export.dart

@@ -0,0 +1,467 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:obtainium/components/custom_app_bar.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/components/generated_form_modal.dart';
+import 'package:obtainium/providers/apps_provider.dart';
+import 'package:obtainium/providers/settings_provider.dart';
+import 'package:obtainium/providers/source_provider.dart';
+import 'package:provider/provider.dart';
+import 'package:file_picker/file_picker.dart';
+
+class ImportExportPage extends StatefulWidget {
+  const ImportExportPage({super.key});
+
+  @override
+  State<ImportExportPage> createState() => _ImportExportPageState();
+}
+
+class _ImportExportPageState extends State<ImportExportPage> {
+  bool importInProgress = false;
+
+  @override
+  Widget build(BuildContext context) {
+    SourceProvider sourceProvider = SourceProvider();
+    var settingsProvider = context.read<SettingsProvider>();
+    var appsProvider = context.read<AppsProvider>();
+    var outlineButtonStyle = ButtonStyle(
+      shape: MaterialStateProperty.all(
+        StadiumBorder(
+          side: BorderSide(
+            width: 1,
+            color: Theme.of(context).colorScheme.primary,
+          ),
+        ),
+      ),
+    );
+
+    Future<List<List<String>>> addApps(List<String> urls) async {
+      await settingsProvider.getInstallPermission();
+      List<dynamic> results = await sourceProvider.getApps(urls,
+          ignoreUrls: appsProvider.apps.values.map((e) => e.app.url).toList());
+      List<App> apps = results[0];
+      Map<String, dynamic> errorsMap = results[1];
+      for (var app in apps) {
+        if (appsProvider.apps.containsKey(app.id)) {
+          errorsMap.addAll({app.id: 'App already added'});
+        } else {
+          await appsProvider.saveApps([app]);
+        }
+      }
+      List<List<String>> errors =
+          errorsMap.keys.map((e) => [e, errorsMap[e].toString()]).toList();
+      return errors;
+    }
+
+    return Scaffold(
+        backgroundColor: Theme.of(context).colorScheme.surface,
+        body: CustomScrollView(slivers: <Widget>[
+          const CustomAppBar(title: 'Import/Export'),
+          SliverFillRemaining(
+              hasScrollBody: false,
+              child: Padding(
+                  padding:
+                      const EdgeInsets.symmetric(vertical: 8, horizontal: 16),
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.stretch,
+                    children: [
+                      Row(
+                        children: [
+                          Expanded(
+                              child: TextButton(
+                                  style: outlineButtonStyle,
+                                  onPressed: appsProvider.apps.isEmpty ||
+                                          importInProgress
+                                      ? null
+                                      : () {
+                                          HapticFeedback.selectionClick();
+                                          appsProvider
+                                              .exportApps()
+                                              .then((String path) {
+                                            ScaffoldMessenger.of(context)
+                                                .showSnackBar(
+                                              SnackBar(
+                                                  content: Text(
+                                                      'Exported to $path')),
+                                            );
+                                          });
+                                        },
+                                  child: const Text('Obtainium Export'))),
+                          const SizedBox(
+                            width: 16,
+                          ),
+                          Expanded(
+                              child: TextButton(
+                                  style: outlineButtonStyle,
+                                  onPressed: importInProgress
+                                      ? null
+                                      : () {
+                                          HapticFeedback.selectionClick();
+                                          FilePicker.platform
+                                              .pickFiles()
+                                              .then((result) {
+                                            setState(() {
+                                              importInProgress = true;
+                                            });
+                                            if (result != null) {
+                                              String data = File(
+                                                      result.files.single.path!)
+                                                  .readAsStringSync();
+                                              try {
+                                                jsonDecode(data);
+                                              } catch (e) {
+                                                throw 'Invalid input';
+                                              }
+                                              appsProvider
+                                                  .importApps(data)
+                                                  .then((value) {
+                                                ScaffoldMessenger.of(context)
+                                                    .showSnackBar(
+                                                  SnackBar(
+                                                      content: Text(
+                                                          '$value App${value == 1 ? '' : 's'} Imported')),
+                                                );
+                                              });
+                                            } else {
+                                              // User canceled the picker
+                                            }
+                                          }).catchError((e) {
+                                            ScaffoldMessenger.of(context)
+                                                .showSnackBar(
+                                              SnackBar(
+                                                  content: Text(e.toString())),
+                                            );
+                                          }).whenComplete(() {
+                                            setState(() {
+                                              importInProgress = false;
+                                            });
+                                          });
+                                        },
+                                  child: const Text('Obtainium Import')))
+                        ],
+                      ),
+                      if (importInProgress)
+                        Column(
+                          children: const [
+                            SizedBox(
+                              height: 14,
+                            ),
+                            LinearProgressIndicator(),
+                            SizedBox(
+                              height: 14,
+                            ),
+                          ],
+                        )
+                      else
+                        const Divider(
+                          height: 32,
+                        ),
+                      TextButton(
+                          onPressed: importInProgress
+                              ? null
+                              : () {
+                                  showDialog(
+                                      context: context,
+                                      builder: (BuildContext ctx) {
+                                        return GeneratedFormModal(
+                                          title: 'Import from URL List',
+                                          items: [
+                                            [
+                                              GeneratedFormItem(
+                                                  label: 'App URL List',
+                                                  max: 7,
+                                                  additionalValidators: [
+                                                    (String? value) {
+                                                      if (value != null &&
+                                                          value.isNotEmpty) {
+                                                        var lines = value
+                                                            .trim()
+                                                            .split('\n');
+                                                        for (int i = 0;
+                                                            i < lines.length;
+                                                            i++) {
+                                                          try {
+                                                            sourceProvider
+                                                                .getSource(
+                                                                    lines[i]);
+                                                          } catch (e) {
+                                                            return 'Line ${i + 1}: $e';
+                                                          }
+                                                        }
+                                                      }
+                                                      return null;
+                                                    }
+                                                  ])
+                                            ]
+                                          ],
+                                          defaultValues: const [],
+                                        );
+                                      }).then((values) {
+                                    if (values != null) {
+                                      var urls =
+                                          (values[0] as String).split('\n');
+                                      setState(() {
+                                        importInProgress = true;
+                                      });
+                                      addApps(urls).then((errors) {
+                                        if (errors.isEmpty) {
+                                          ScaffoldMessenger.of(context)
+                                              .showSnackBar(
+                                            SnackBar(
+                                                content: Text(
+                                                    'Imported ${urls.length} Apps')),
+                                          );
+                                        } else {
+                                          showDialog(
+                                              context: context,
+                                              builder: (BuildContext ctx) {
+                                                return ImportErrorDialog(
+                                                    urlsLength: urls.length,
+                                                    errors: errors);
+                                              });
+                                        }
+                                      }).catchError((e) {
+                                        ScaffoldMessenger.of(context)
+                                            .showSnackBar(
+                                          SnackBar(content: Text(e.toString())),
+                                        );
+                                      }).whenComplete(() {
+                                        setState(() {
+                                          importInProgress = false;
+                                        });
+                                      });
+                                    }
+                                  });
+                                },
+                          child: const Text(
+                            'Import from URL List',
+                          )),
+                      ...sourceProvider.massSources
+                          .map((source) => Column(
+                                  crossAxisAlignment:
+                                      CrossAxisAlignment.stretch,
+                                  children: [
+                                    const SizedBox(height: 8),
+                                    TextButton(
+                                        onPressed: importInProgress
+                                            ? null
+                                            : () {
+                                                showDialog(
+                                                    context: context,
+                                                    builder:
+                                                        (BuildContext ctx) {
+                                                      return GeneratedFormModal(
+                                                        title:
+                                                            'Import ${source.name}',
+                                                        items: source
+                                                            .requiredArgs
+                                                            .map((e) => [
+                                                                  GeneratedFormItem(
+                                                                      label: e)
+                                                                ])
+                                                            .toList(),
+                                                        defaultValues: const [],
+                                                      );
+                                                    }).then((values) {
+                                                  if (values != null) {
+                                                    setState(() {
+                                                      importInProgress = true;
+                                                    });
+                                                    source
+                                                        .getUrls(values)
+                                                        .then((urls) {
+                                                      showDialog<List<String>?>(
+                                                              context: context,
+                                                              builder:
+                                                                  (BuildContext
+                                                                      ctx) {
+                                                                return UrlSelectionModal(
+                                                                    urls: urls);
+                                                              })
+                                                          .then((selectedUrls) {
+                                                        if (selectedUrls !=
+                                                            null) {
+                                                          addApps(selectedUrls)
+                                                              .then((errors) {
+                                                            if (errors
+                                                                .isEmpty) {
+                                                              ScaffoldMessenger
+                                                                      .of(context)
+                                                                  .showSnackBar(
+                                                                SnackBar(
+                                                                    content: Text(
+                                                                        'Imported ${selectedUrls.length} Apps')),
+                                                              );
+                                                            } else {
+                                                              showDialog(
+                                                                  context:
+                                                                      context,
+                                                                  builder:
+                                                                      (BuildContext
+                                                                          ctx) {
+                                                                    return ImportErrorDialog(
+                                                                        urlsLength:
+                                                                            selectedUrls
+                                                                                .length,
+                                                                        errors:
+                                                                            errors);
+                                                                  });
+                                                            }
+                                                          }).whenComplete(() {
+                                                            setState(() {
+                                                              importInProgress =
+                                                                  false;
+                                                            });
+                                                          });
+                                                        } else {
+                                                          setState(() {
+                                                            importInProgress =
+                                                                false;
+                                                          });
+                                                        }
+                                                      });
+                                                    }).catchError((e) {
+                                                      setState(() {
+                                                        importInProgress =
+                                                            false;
+                                                      });
+                                                      ScaffoldMessenger.of(
+                                                              context)
+                                                          .showSnackBar(
+                                                        SnackBar(
+                                                            content: Text(
+                                                                e.toString())),
+                                                      );
+                                                    });
+                                                  }
+                                                });
+                                              },
+                                        child: Text('Import ${source.name}'))
+                                  ]))
+                          .toList()
+                    ],
+                  )))
+        ]));
+  }
+}
+
+class ImportErrorDialog extends StatefulWidget {
+  const ImportErrorDialog(
+      {super.key, required this.urlsLength, required this.errors});
+
+  final int urlsLength;
+  final List<List<String>> errors;
+
+  @override
+  State<ImportErrorDialog> createState() => _ImportErrorDialogState();
+}
+
+class _ImportErrorDialogState extends State<ImportErrorDialog> {
+  @override
+  Widget build(BuildContext context) {
+    return AlertDialog(
+      scrollable: true,
+      title: const Text('Import Errors'),
+      content:
+          Column(crossAxisAlignment: CrossAxisAlignment.stretch, children: [
+        Text(
+          '${widget.urlsLength - widget.errors.length} of ${widget.urlsLength} Apps imported.',
+          style: Theme.of(context).textTheme.bodyLarge,
+        ),
+        const SizedBox(height: 16),
+        Text(
+          'The following URLs had errors:',
+          style: Theme.of(context).textTheme.bodyLarge,
+        ),
+        ...widget.errors.map((e) {
+          return Column(
+              crossAxisAlignment: CrossAxisAlignment.stretch,
+              children: [
+                const SizedBox(
+                  height: 16,
+                ),
+                Text(e[0]),
+                Text(
+                  e[1],
+                  style: const TextStyle(fontStyle: FontStyle.italic),
+                )
+              ]);
+        }).toList()
+      ]),
+      actions: [
+        TextButton(
+            onPressed: () {
+              Navigator.of(context).pop(null);
+            },
+            child: const Text('Okay'))
+      ],
+    );
+  }
+}
+
+// ignore: must_be_immutable
+class UrlSelectionModal extends StatefulWidget {
+  UrlSelectionModal({super.key, required this.urls});
+
+  List<String> urls;
+
+  @override
+  State<UrlSelectionModal> createState() => _UrlSelectionModalState();
+}
+
+class _UrlSelectionModalState extends State<UrlSelectionModal> {
+  Map<String, bool> urlSelections = {};
+  @override
+  void initState() {
+    super.initState();
+    for (var url in widget.urls) {
+      urlSelections.putIfAbsent(url, () => true);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AlertDialog(
+      scrollable: true,
+      title: const Text('Select URLs to Import'),
+      content: Column(children: [
+        ...urlSelections.keys.map((url) {
+          return Row(children: [
+            Checkbox(
+                value: urlSelections[url],
+                onChanged: (value) {
+                  setState(() {
+                    urlSelections[url] = value ?? false;
+                  });
+                }),
+            const SizedBox(
+              width: 8,
+            ),
+            Expanded(
+                child: Text(
+              Uri.parse(url).path.substring(1),
+            ))
+          ]);
+        })
+      ]),
+      actions: [
+        TextButton(
+            onPressed: () {
+              Navigator.of(context).pop();
+            },
+            child: const Text('Cancel')),
+        TextButton(
+            onPressed: () {
+              Navigator.of(context).pop(urlSelections.keys
+                  .where((url) => urlSelections[url] ?? false)
+                  .toList());
+            },
+            child: Text(
+                'Import ${urlSelections.values.where((b) => b).length} URLs'))
+      ],
+    );
+  }
+}

lib/pages/settings.dart

@@ -1,8 +1,8 @@
-import 'dart:convert';
-
 import 'package:flutter/material.dart';
-import 'package:obtainium/providers/apps_provider.dart';
+import 'package:obtainium/components/custom_app_bar.dart';
+import 'package:obtainium/components/generated_form.dart';
 import 'package:obtainium/providers/settings_provider.dart';
+import 'package:obtainium/providers/source_provider.dart';
 import 'package:provider/provider.dart';
 import 'package:url_launcher/url_launcher_string.dart';
 
@@ -16,225 +16,263 @@ class SettingsPage extends StatefulWidget {
 class _SettingsPageState extends State<SettingsPage> {
   @override
   Widget build(BuildContext context) {
-    AppsProvider appsProvider = context.read<AppsProvider>();
     SettingsProvider settingsProvider = context.watch<SettingsProvider>();
+    SourceProvider sourceProvider = SourceProvider();
     if (settingsProvider.prefs == null) {
       settingsProvider.initializeSettings();
     }
-    return Padding(
-        padding: const EdgeInsets.all(16),
-        child: settingsProvider.prefs == null
-            ? Container()
-            : Column(
-                children: [
-                  DropdownButtonFormField(
-                      decoration: const InputDecoration(labelText: 'Theme'),
-                      value: settingsProvider.theme,
-                      items: const [
-                        DropdownMenuItem(
-                          value: ThemeSettings.dark,
-                          child: Text('Dark'),
-                        ),
-                        DropdownMenuItem(
-                          value: ThemeSettings.light,
-                          child: Text('Light'),
-                        ),
-                        DropdownMenuItem(
-                          value: ThemeSettings.system,
-                          child: Text('Follow System'),
-                        )
-                      ],
-                      onChanged: (value) {
-                        if (value != null) {
-                          settingsProvider.theme = value;
-                        }
-                      }),
-                  const SizedBox(
-                    height: 16,
-                  ),
-                  DropdownButtonFormField(
-                      decoration: const InputDecoration(labelText: 'Colour'),
-                      value: settingsProvider.colour,
-                      items: const [
-                        DropdownMenuItem(
-                          value: ColourSettings.basic,
-                          child: Text('Obtainium'),
-                        ),
-                        DropdownMenuItem(
-                          value: ColourSettings.materialYou,
-                          child: Text('Material You'),
-                        )
-                      ],
-                      onChanged: (value) {
-                        if (value != null) {
-                          settingsProvider.colour = value;
-                        }
-                      }),
-                  const SizedBox(
-                    height: 16,
-                  ),
-                  DropdownButtonFormField(
-                      decoration: const InputDecoration(
-                          labelText: 'Background Update Checking Interval'),
-                      value: settingsProvider.updateInterval,
-                      items: const [
-                        DropdownMenuItem(
-                          value: 15,
-                          child: Text('15 Minutes'),
-                        ),
-                        DropdownMenuItem(
-                          value: 30,
-                          child: Text('30 Minutes'),
-                        ),
-                        DropdownMenuItem(
-                          value: 60,
-                          child: Text('1 Hour'),
-                        ),
-                        DropdownMenuItem(
-                          value: 360,
-                          child: Text('6 Hours'),
-                        ),
-                        DropdownMenuItem(
-                          value: 720,
-                          child: Text('12 Hours'),
-                        ),
-                        DropdownMenuItem(
-                          value: 1440,
-                          child: Text('1 Day'),
-                        ),
-                      ],
-                      onChanged: (value) {
-                        if (value != null) {
-                          settingsProvider.updateInterval = value;
-                        }
-                      }),
-                  const SizedBox(
-                    height: 32,
-                  ),
-                  Row(
-                    mainAxisAlignment: MainAxisAlignment.spaceAround,
-                    children: [
-                      ElevatedButton(
-                          onPressed: appsProvider.apps.isEmpty
-                              ? null
-                              : () {
-                                  appsProvider.exportApps().then((String path) {
-                                    ScaffoldMessenger.of(context).showSnackBar(
-                                      SnackBar(
-                                          content: Text('Exported to $path')),
-                                    );
-                                  });
-                                },
-                          child: const Text('Export Apps')),
-                      ElevatedButton(
-                          onPressed: () {
-                            showDialog(
-                                context: context,
-                                builder: (BuildContext ctx) {
-                                  final formKey = GlobalKey<FormState>();
-                                  final jsonInputController =
-                                      TextEditingController();
+    return Scaffold(
+        backgroundColor: Theme.of(context).colorScheme.surface,
+        body: CustomScrollView(slivers: <Widget>[
+          const CustomAppBar(title: 'Settings'),
+          SliverToBoxAdapter(
+              child: Padding(
+                  padding: const EdgeInsets.all(16),
+                  child: settingsProvider.prefs == null
+                      ? const SizedBox()
+                      : Column(
+                          crossAxisAlignment: CrossAxisAlignment.start,
+                          children: [
+                            Text(
+                              'Appearance',
+                              style: TextStyle(
+                                  color: Theme.of(context).colorScheme.primary),
+                            ),
+                            DropdownButtonFormField(
+                                decoration:
+                                    const InputDecoration(labelText: 'Theme'),
+                                value: settingsProvider.theme,
+                                items: const [
+                                  DropdownMenuItem(
+                                    value: ThemeSettings.dark,
+                                    child: Text('Dark'),
+                                  ),
+                                  DropdownMenuItem(
+                                    value: ThemeSettings.light,
+                                    child: Text('Light'),
+                                  ),
+                                  DropdownMenuItem(
+                                    value: ThemeSettings.system,
+                                    child: Text('Follow System'),
+                                  )
+                                ],
+                                onChanged: (value) {
+                                  if (value != null) {
+                                    settingsProvider.theme = value;
+                                  }
+                                }),
+                            const SizedBox(
+                              height: 16,
+                            ),
+                            DropdownButtonFormField(
+                                decoration:
+                                    const InputDecoration(labelText: 'Colour'),
+                                value: settingsProvider.colour,
+                                items: const [
+                                  DropdownMenuItem(
+                                    value: ColourSettings.basic,
+                                    child: Text('Obtainium'),
+                                  ),
+                                  DropdownMenuItem(
+                                    value: ColourSettings.materialYou,
+                                    child: Text('Material You'),
+                                  )
+                                ],
+                                onChanged: (value) {
+                                  if (value != null) {
+                                    settingsProvider.colour = value;
+                                  }
+                                }),
+                            const SizedBox(
+                              height: 16,
+                            ),
+                            Row(
+                              mainAxisAlignment: MainAxisAlignment.start,
+                              crossAxisAlignment: CrossAxisAlignment.start,
+                              children: [
+                                Expanded(
+                                    child: DropdownButtonFormField(
+                                        decoration: const InputDecoration(
+                                            labelText: 'App Sort By'),
+                                        value: settingsProvider.sortColumn,
+                                        items: const [
+                                          DropdownMenuItem(
+                                            value:
+                                                SortColumnSettings.authorName,
+                                            child: Text('Author/Name'),
+                                          ),
+                                          DropdownMenuItem(
+                                            value:
+                                                SortColumnSettings.nameAuthor,
+                                            child: Text('Name/Author'),
+                                          ),
+                                          DropdownMenuItem(
+                                            value: SortColumnSettings.added,
+                                            child: Text('As Added'),
+                                          )
+                                        ],
+                                        onChanged: (value) {
+                                          if (value != null) {
+                                            settingsProvider.sortColumn = value;
+                                          }
+                                        })),
+                                const SizedBox(
+                                  width: 16,
+                                ),
+                                Expanded(
+                                    child: DropdownButtonFormField(
+                                        decoration: const InputDecoration(
+                                            labelText: 'App Sort Order'),
+                                        value: settingsProvider.sortOrder,
+                                        items: const [
+                                          DropdownMenuItem(
+                                            value: SortOrderSettings.ascending,
+                                            child: Text('Ascending'),
+                                          ),
+                                          DropdownMenuItem(
+                                            value: SortOrderSettings.descending,
+                                            child: Text('Descending'),
+                                          ),
+                                        ],
+                                        onChanged: (value) {
+                                          if (value != null) {
+                                            settingsProvider.sortOrder = value;
+                                          }
+                                        })),
+                              ],
+                            ),
+                            const SizedBox(
+                              height: 16,
+                            ),
+                            Row(
+                              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                              children: [
+                                const Text('Show Source Webpage in App View'),
+                                Switch(
+                                    value: settingsProvider.showAppWebpage,
+                                    onChanged: (value) {
+                                      settingsProvider.showAppWebpage = value;
+                                    })
+                              ],
+                            ),
+                            const Divider(
+                              height: 16,
+                            ),
+                            const SizedBox(
+                              height: 16,
+                            ),
+                            Text(
+                              'Updates',
+                              style: TextStyle(
+                                  color: Theme.of(context).colorScheme.primary),
+                            ),
+                            DropdownButtonFormField(
+                                decoration: const InputDecoration(
+                                    labelText:
+                                        'Background Update Checking Interval'),
+                                value: settingsProvider.updateInterval,
+                                items: updateIntervals.map((e) {
+                                  int displayNum = (e < 60
+                                          ? e
+                                          : e < 1440
+                                              ? e / 60
+                                              : e / 1440)
+                                      .round();
+                                  var displayUnit = (e < 60
+                                      ? 'Minute'
+                                      : e < 1440
+                                          ? 'Hour'
+                                          : 'Day');
 
-                                  return AlertDialog(
-                                    scrollable: true,
-                                    title: const Text('Import Apps'),
-                                    content: Column(children: [
-                                      const Text(
-                                          'Copy the contents of the Obtainium export file and paste them into the field below:'),
-                                      Form(
-                                        key: formKey,
-                                        child: TextFormField(
-                                          minLines: 7,
-                                          maxLines: 7,
-                                          decoration: const InputDecoration(
-                                              helperText:
-                                                  'Obtainium export data'),
-                                          controller: jsonInputController,
-                                          validator: (value) {
-                                            if (value == null ||
-                                                value.isEmpty) {
-                                              return 'Please enter your Obtainium export data';
-                                            }
-                                            bool isJSON = true;
-                                            try {
-                                              jsonDecode(value);
-                                            } catch (e) {
-                                              isJSON = false;
-                                            }
-                                            if (!isJSON) {
-                                              return 'Invalid input';
-                                            }
-                                            return null;
-                                          },
-                                        ),
-                                      )
-                                    ]),
-                                    actions: [
-                                      TextButton(
-                                          onPressed: () {
-                                            if (formKey.currentState!
-                                                .validate()) {
-                                              appsProvider
-                                                  .importApps(
-                                                      jsonInputController
-                                                          .value.text)
-                                                  .then((value) {
-                                                ScaffoldMessenger.of(context)
-                                                    .showSnackBar(
-                                                  SnackBar(
-                                                      content: Text(
-                                                          '$value Apps Imported')),
-                                                );
-                                              }).catchError((e) {
-                                                ScaffoldMessenger.of(context)
-                                                    .showSnackBar(
-                                                  SnackBar(
-                                                      content:
-                                                          Text(e.toString())),
-                                                );
-                                              }).whenComplete(() {
-                                                Navigator.of(context).pop();
-                                              });
-                                            }
-                                          },
-                                          child: const Text('Import')),
-                                      TextButton(
-                                          onPressed: () {
-                                            Navigator.of(context).pop();
-                                          },
-                                          child: const Text('Cancel'))
-                                    ],
-                                  );
-                                });
-                          },
-                          child: const Text('Import Apps'))
-                    ],
+                                  String display = e == 0
+                                      ? 'Never - Manual Only'
+                                      : '$displayNum $displayUnit${displayNum == 1 ? '' : 's'}';
+                                  return DropdownMenuItem(
+                                      value: e, child: Text(display));
+                                }).toList(),
+                                onChanged: (value) {
+                                  if (value != null) {
+                                    settingsProvider.updateInterval = value;
+                                  }
+                                }),
+                            const SizedBox(
+                              height: 8,
+                            ),
+                            Text(
+                              'Longer intervals recommended for large App collections',
+                              style: Theme.of(context)
+                                  .textTheme
+                                  .labelMedium!
+                                  .merge(const TextStyle(
+                                      fontStyle: FontStyle.italic)),
+                            ),
+                            const Divider(
+                              height: 48,
+                            ),
+                            Text(
+                              'Source-Specific',
+                              style: TextStyle(
+                                  color: Theme.of(context).colorScheme.primary),
+                            ),
+                            ...sourceProvider.sources.map((e) {
+                              if (e.moreSourceSettingsFormItems.isNotEmpty) {
+                                return GeneratedForm(
+                                    items: e.moreSourceSettingsFormItems
+                                        .map((e) => [e])
+                                        .toList(),
+                                    onValueChanges: (values, valid) {
+                                      if (valid) {
+                                        for (var i = 0;
+                                            i < values.length;
+                                            i++) {
+                                          settingsProvider.setSettingString(
+                                              e.moreSourceSettingsFormItems[i]
+                                                  .id,
+                                              values[i]);
+                                        }
+                                      }
+                                    },
+                                    defaultValues:
+                                        e.moreSourceSettingsFormItems.map((e) {
+                                      return settingsProvider
+                                              .getSettingString(e.id) ??
+                                          '';
+                                    }).toList());
+                              } else {
+                                return Container();
+                              }
+                            }),
+                          ],
+                        ))),
+          SliverToBoxAdapter(
+            child: Column(
+              children: [
+                const SizedBox(
+                  height: 16,
+                ),
+                TextButton.icon(
+                  style: ButtonStyle(
+                    foregroundColor: MaterialStateProperty.resolveWith<Color>(
+                        (Set<MaterialState> states) {
+                      return Colors.grey;
+                    }),
                   ),
-                  const Spacer(),
-                  Row(
-                    mainAxisAlignment: MainAxisAlignment.center,
-                    children: [
-                      TextButton.icon(
-                        style: ButtonStyle(
-                          foregroundColor:
-                              MaterialStateProperty.resolveWith<Color>(
-                                  (Set<MaterialState> states) {
-                            return Colors.grey;
-                          }),
-                        ),
-                        onPressed: () {
-                          launchUrlString(settingsProvider.sourceUrl,
-                              mode: LaunchMode.externalApplication);
-                        },
-                        icon: const Icon(Icons.code),
-                        label: Text(
-                          'Source',
-                          style: Theme.of(context).textTheme.caption,
-                        ),
-                      )
-                    ],
+                  onPressed: () {
+                    launchUrlString(settingsProvider.sourceUrl,
+                        mode: LaunchMode.externalApplication);
+                  },
+                  icon: const Icon(Icons.code),
+                  label: Text(
+                    'Source',
+                    style: Theme.of(context).textTheme.bodySmall,
                   ),
-                ],
-              ));
+                ),
+                const SizedBox(
+                  height: 16,
+                ),
+              ],
+            ),
+          )
+        ]));
   }
 }

lib/providers/apps_provider.dart

@@ -5,14 +5,17 @@ import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
+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:obtainium/app_sources/github.dart';
 import 'package:obtainium/providers/notifications_provider.dart';
 import 'package:provider/provider.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:flutter_fgbg/flutter_fgbg.dart';
 import 'package:obtainium/providers/source_provider.dart';
 import 'package:http/http.dart';
-import 'package:install_plugin_v2/install_plugin_v2.dart';
 
 class AppInMemory {
   late App app;
@@ -38,17 +41,32 @@ class AppsProvider with ChangeNotifier {
   late Stream<FGBGType> foregroundStream;
   late StreamSubscription<FGBGType> foregroundSubscription;
 
-  AppsProvider({bool bg = false}) {
+  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();
     });
-    loadApps();
+    if (shouldDeleteAPKs) {
+      deleteSavedAPKs();
+    }
+    if (shouldLoadApps) {
+      loadApps().then((_) {
+        if (shouldCheckUpdatesAfterLoad) {
+          checkUpdates();
+        }
+      });
+    }
   }
 
   Future<ApkFile> downloadApp(String apkUrl, String appId) async {
+    apkUrl = await SourceProvider()
+        .getSource(apps[appId]!.app.url)
+        .apkUrlPrefetchModifier(apkUrl);
     StreamedResponse response =
         await Client().send(Request('GET', Uri.parse(apkUrl)));
     File downloadFile =
@@ -79,71 +97,146 @@ class AppsProvider with ChangeNotifier {
     return ApkFile(appId, downloadFile);
   }
 
-  // Given an AppId, uses stored info about the app to download an APK (with user input if needed) and install it
-  // Installs can only be done in the foreground, so a notification is sent to get the user's attention if needed
-  // Returns upon successful download, regardless of installation result
-  Future<void> downloadAndInstallLatestApp(
-      List<String> appIds, BuildContext context) async {
+  bool areDownloadsRunning() => apps.values
+      .where((element) => element.downloadProgress != null)
+      .isNotEmpty;
+
+  Future<bool> canInstallSilently(App app) async {
+    // 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;
+  }
+
+  Future<void> askUserToReturnToForeground(BuildContext context,
+      {bool waitForFG = false}) async {
     NotificationsProvider notificationsProvider =
         context.read<NotificationsProvider>();
+    if (!isForeground) {
+      await notificationsProvider.notify(completeInstallationNotification,
+          cancelExisting: true);
+      if (waitForFG) {
+        await FGBGEvents.stream.first == FGBGType.foreground;
+        await notificationsProvider.cancel(completeInstallationNotification.id);
+      }
+    }
+  }
+
+  // Unfortunately this 'await' does not actually wait for the APK to finish installing
+  // 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');
+    apps[file.appId]!.app.installedVersion =
+        apps[file.appId]!.app.latestVersion;
+    await saveApps([apps[file.appId]!.app]);
+  }
+
+  // Given a list of AppIds, uses stored info about the apps to download APKs and install them
+  // If the APKs can be installed silently, they are
+  // 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(
+      List<String> appIds, BuildContext? context) async {
     Map<String, String> appsToInstall = {};
     for (var id in appIds) {
       if (apps[id] == null) {
         throw 'App not found';
       }
-      String apkUrl = apps[id]!.app.apkUrls.last;
-      if (apps[id]!.app.apkUrls.length > 1) {
-        await showDialog(
+
+      // 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 AlertDialog(
-                scrollable: true,
-                title: const Text('Pick an APK'),
-                content: Column(children: [
-                  Text(
-                      '${apps[id]!.app.name} has more than one package - pick one.'),
-                  ...apps[id]!.app.apkUrls.map((u) => ListTile(
-                      title: Text(Uri.parse(u).pathSegments.last),
-                      leading: Radio<String>(
-                          value: u,
-                          groupValue: apkUrl,
-                          onChanged: (String? val) {
-                            apkUrl = val!;
-                          })))
-                ]),
-                actions: [
-                  TextButton(
-                      onPressed: () {
-                        Navigator.of(context).pop();
-                      },
-                      child: const Text('Continue'))
-                ],
-              );
+              return APKPicker(app: apps[id]!.app, initVal: apkUrl);
             });
       }
-      appsToInstall.putIfAbsent(id, () => 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;
+        }
+      }
+      if (apkUrl != null) {
+        int urlInd = apps[id]!.app.apkUrls.indexOf(apkUrl);
+        if (urlInd != apps[id]!.app.preferredApkIndex) {
+          apps[id]!.app.preferredApkIndex = urlInd;
+          await saveApps([apps[id]!.app]);
+        }
+        if (context != null ||
+            (await canInstallSilently(apps[id]!.app) &&
+                apps[id]!.app.apkUrls.length == 1)) {
+          appsToInstall.putIfAbsent(id, () => apkUrl!);
+        }
+      }
     }
 
     List<ApkFile> downloadedFiles = await Future.wait(appsToInstall.entries
         .map((entry) => downloadApp(entry.value, entry.key)));
 
-    if (!isForeground) {
-      await notificationsProvider.notify(completeInstallationNotification,
-          cancelExisting: true);
-      await FGBGEvents.stream.first == FGBGType.foreground;
-      // We need to wait for the App to come to the foreground to install it
-      // Can't try to call install plugin in a background isolate (may not have worked anyways) because of:
-      // https://github.com/flutter/flutter/issues/13937
+    List<ApkFile> silentUpdates = [];
+    List<ApkFile> regularInstalls = [];
+    for (var f in downloadedFiles) {
+      bool willBeSilent = await canInstallSilently(apps[f.appId]!.app);
+      if (willBeSilent) {
+        silentUpdates.add(f);
+      } else {
+        regularInstalls.add(f);
+      }
     }
 
-    // Unfortunately this 'await' does not actually wait for the APK to finish installing
-    // So we only know that the install prompt was shown, but the user could still cancel w/o us knowing
-    // This also does not use the 'session-based' installer API, so background/silent updates are impossible
-    for (var f in downloadedFiles) {
-      await InstallPlugin.installApk(f.file.path, 'dev.imranr.obtainium');
-      apps[f.appId]!.app.installedVersion = apps[f.appId]!.app.latestVersion;
-      await saveApp(apps[f.appId]!.app);
+    // If Obtainium is being installed, it should be the last one
+    List<ApkFile> moveObtainiumToEnd(List<ApkFile> items) {
+      String obtainiumId = 'imranr98_obtainium_${GitHub().host}';
+      ApkFile? temp;
+      items.removeWhere((element) {
+        bool res = element.appId == obtainiumId;
+        if (res) {
+          temp = element;
+        }
+        return res;
+      });
+      if (temp != null) {
+        items.add(temp!);
+      }
+      return items;
     }
+
+    // TODO: Remove below line if silentupdates are ever figured out
+    regularInstalls.addAll(silentUpdates);
+
+    silentUpdates = moveObtainiumToEnd(silentUpdates);
+    regularInstalls = moveObtainiumToEnd(regularInstalls);
+
+    // TODO: Uncomment below if silentupdates are ever figured out
+    // for (var u in silentUpdates) {
+    //   await installApk(u, silent: true); // Would need to add silent option
+    // }
+
+    if (context != null) {
+      if (regularInstalls.isNotEmpty) {
+        // ignore: use_build_context_synchronously
+        await askUserToReturnToForeground(context, waitForFG: true);
+      }
+      for (var i in regularInstalls) {
+        await installApk(i);
+      }
+    }
+
+    return downloadedFiles.map((e) => e.appId).toList();
   }
 
   Future<Directory> getAppsDir() async {
@@ -181,23 +274,30 @@ class AppsProvider with ChangeNotifier {
     notifyListeners();
   }
 
-  Future<void> saveApp(App app) async {
-    File('${(await getAppsDir()).path}/${app.id}.json')
-        .writeAsStringSync(jsonEncode(app.toJson()));
-    apps.update(app.id, (value) => AppInMemory(app, value.downloadProgress),
-        ifAbsent: () => AppInMemory(app, null));
+  Future<void> saveApps(List<App> apps) async {
+    for (var app in apps) {
+      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));
+    }
     notifyListeners();
   }
 
-  Future<void> removeApp(String appId) async {
-    File file = File('${(await getAppsDir()).path}/$appId.json');
-    if (file.existsSync()) {
-      file.deleteSync();
+  Future<void> removeApps(List<String> appIds) async {
+    for (var appId in appIds) {
+      File file = File('${(await getAppsDir()).path}/$appId.json');
+      if (file.existsSync()) {
+        file.deleteSync();
+      }
+      if (apps.containsKey(appId)) {
+        apps.remove(appId);
+      }
     }
-    if (apps.containsKey(appId)) {
-      apps.remove(appId);
+    if (appIds.isNotEmpty) {
+      notifyListeners();
     }
-    notifyListeners();
   }
 
   bool checkAppObjectForUpdate(App app) {
@@ -209,21 +309,36 @@ class AppsProvider with ChangeNotifier {
 
   Future<App?> getUpdate(String appId) async {
     App? currentApp = apps[appId]!.app;
-    App newApp = await sourceProvider().getApp(currentApp.url);
-    if (newApp.latestVersion != currentApp.latestVersion) {
-      newApp.installedVersion = currentApp.installedVersion;
-      await saveApp(newApp);
-      return newApp;
+    SourceProvider sourceProvider = SourceProvider();
+    App newApp = await sourceProvider.getApp(
+        sourceProvider.getSource(currentApp.url),
+        currentApp.url,
+        currentApp.additionalData);
+    newApp.installedVersion = currentApp.installedVersion;
+    if (currentApp.preferredApkIndex < newApp.apkUrls.length) {
+      newApp.preferredApkIndex = currentApp.preferredApkIndex;
     }
-    return null;
+    await saveApps([newApp]);
+    return newApp.latestVersion != currentApp.latestVersion ? newApp : null;
   }
 
-  Future<List<App>> checkUpdates() async {
+  Future<List<App>> checkUpdates({DateTime? ignoreAfter}) async {
     List<App> updates = [];
     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)));
       for (int i = 0; i < appIds.length; i++) {
         App? newApp = await getUpdate(appIds[i]);
         if (newApp != null) {
@@ -235,13 +350,20 @@ class AppsProvider with ChangeNotifier {
     return updates;
   }
 
-  List<String> getExistingUpdates() {
+  List<String> getExistingUpdates(
+      {bool installedOnly = false, bool nonInstalledOnly = false}) {
     List<String> updateAppIds = [];
     List<String> appIds = apps.keys.toList();
     for (int i = 0; i < appIds.length; i++) {
       App? app = apps[appIds[i]]!.app;
-      if (app.installedVersion != app.latestVersion) {
-        updateAppIds.add(app.id);
+      if (app.installedVersion != app.latestVersion &&
+          (!installedOnly || !nonInstalledOnly)) {
+        if ((app.installedVersion == null &&
+                (nonInstalledOnly || !installedOnly) ||
+            (app.installedVersion != null &&
+                (installedOnly || !nonInstalledOnly)))) {
+          updateAppIds.add(app.id);
+        }
       }
     }
     return updateAppIds;
@@ -269,7 +391,7 @@ class AppsProvider with ChangeNotifier {
     for (App a in importedApps) {
       a.installedVersion =
           apps.containsKey(a.id) ? apps[a]?.app.installedVersion : null;
-      await saveApp(a);
+      await saveApps([a]);
     }
     notifyListeners();
     return importedApps.length;
@@ -281,3 +403,91 @@ class AppsProvider with ChangeNotifier {
     super.dispose();
   }
 }
+
+class APKPicker extends StatefulWidget {
+  const APKPicker({super.key, required this.app, this.initVal});
+
+  final App app;
+  final String? initVal;
+
+  @override
+  State<APKPicker> createState() => _APKPickerState();
+}
+
+class _APKPickerState extends State<APKPicker> {
+  String? apkUrl;
+
+  @override
+  Widget build(BuildContext context) {
+    apkUrl ??= widget.initVal;
+    return AlertDialog(
+      scrollable: true,
+      title: const Text('Pick an APK'),
+      content: Column(children: [
+        Text('${widget.app.name} has more than one package:'),
+        const SizedBox(height: 16),
+        ...widget.app.apkUrls.map((u) => RadioListTile<String>(
+            title: Text(Uri.parse(u)
+                .pathSegments
+                .where((element) => element.isNotEmpty)
+                .last),
+            value: u,
+            groupValue: apkUrl,
+            onChanged: (String? val) {
+              setState(() {
+                apkUrl = val;
+              });
+            }))
+      ]),
+      actions: [
+        TextButton(
+            onPressed: () {
+              Navigator.of(context).pop(null);
+            },
+            child: const Text('Cancel')),
+        TextButton(
+            onPressed: () {
+              HapticFeedback.selectionClick();
+              Navigator.of(context).pop(apkUrl);
+            },
+            child: const Text('Continue'))
+      ],
+    );
+  }
+}
+
+class APKOriginWarningDialog extends StatefulWidget {
+  const APKOriginWarningDialog(
+      {super.key, required this.sourceUrl, required this.apkUrl});
+
+  final String sourceUrl;
+  final String apkUrl;
+
+  @override
+  State<APKOriginWarningDialog> createState() => _APKOriginWarningDialogState();
+}
+
+class _APKOriginWarningDialogState extends State<APKOriginWarningDialog> {
+  @override
+  Widget build(BuildContext context) {
+    return AlertDialog(
+      scrollable: true,
+      title: const Text('Warning'),
+      content: Text(
+          'The App source is \'${Uri.parse(widget.sourceUrl).host}\' but the release package comes from \'${Uri.parse(widget.apkUrl).host}\'. Continue?'),
+      actions: [
+        TextButton(
+            onPressed: () {
+              Navigator.of(context).pop(null);
+            },
+            child: const Text('Cancel')),
+        TextButton(
+            onPressed: () {
+              HapticFeedback.selectionClick();
+              Navigator.of(context).pop(true);
+            },
+            child: const Text('Continue'))
+      ],
+    );
+  }
+}

lib/providers/notifications_provider.dart

@@ -33,6 +33,22 @@ class UpdateNotification extends ObtainiumNotification {
   }
 }
 
+class SilentUpdateNotification extends ObtainiumNotification {
+  SilentUpdateNotification(List<App> updates)
+      : super(
+            3,
+            'Apps Updated',
+            '',
+            'APPS_UPDATED',
+            'Apps Updated',
+            'Notifies the user that updates to one or more Apps were applied in the background',
+            Importance.defaultImportance) {
+    message = updates.length == 1
+        ? '${updates[0].name} was updated to ${updates[0].latestVersion}.'
+        : '${(updates.length == 2 ? '${updates[0].name} and ${updates[1].name}' : '${updates[0].name} and ${updates.length - 1} more apps')} were updated.';
+  }
+}
+
 class ErrorCheckingUpdatesNotification extends ObtainiumNotification {
   ErrorCheckingUpdatesNotification(String error)
       : super(

lib/providers/settings_provider.dart

@@ -9,6 +9,20 @@ enum ThemeSettings { system, light, dark }
 
 enum ColourSettings { basic, materialYou }
 
+enum SortColumnSettings { added, nameAuthor, authorName }
+
+enum SortOrderSettings { ascending, descending }
+
+const maxAPIRateLimitMinutes = 30;
+const minUpdateIntervalMinutes = maxAPIRateLimitMinutes + 30;
+const maxUpdateIntervalMinutes = 4320;
+List<int> updateIntervals = [15, 30, 60, 120, 180, 360, 720, 1440, 4320, 0]
+    .where((element) =>
+        (element >= minUpdateIntervalMinutes &&
+            element <= maxUpdateIntervalMinutes) ||
+        element == 0)
+    .toList();
+
 class SettingsProvider with ChangeNotifier {
   SharedPreferences? prefs;
 
@@ -41,11 +55,41 @@ class SettingsProvider with ChangeNotifier {
   }
 
   int get updateInterval {
-    return prefs?.getInt('updateInterval') ?? 1440;
+    var min = prefs?.getInt('updateInterval') ?? 180;
+    if (!updateIntervals.contains(min)) {
+      var temp = updateIntervals[0];
+      for (var i in updateIntervals) {
+        if (min > i && i != 0) {
+          temp = i;
+        }
+      }
+      min = temp;
+    }
+    return min;
   }
 
   set updateInterval(int min) {
-    prefs?.setInt('updateInterval', min < 15 ? 15 : min);
+    prefs?.setInt('updateInterval', (min < 15 && min != 0) ? 15 : min);
+    notifyListeners();
+  }
+
+  SortColumnSettings get sortColumn {
+    return SortColumnSettings
+        .values[prefs?.getInt('sortColumn') ?? SortColumnSettings.added.index];
+  }
+
+  set sortColumn(SortColumnSettings s) {
+    prefs?.setInt('sortColumn', s.index);
+    notifyListeners();
+  }
+
+  SortOrderSettings get sortOrder {
+    return SortOrderSettings.values[
+        prefs?.getInt('sortOrder') ?? SortOrderSettings.descending.index];
+  }
+
+  set sortOrder(SortOrderSettings s) {
+    prefs?.setInt('sortOrder', s.index);
     notifyListeners();
   }
 
@@ -69,4 +113,22 @@ class SettingsProvider with ChangeNotifier {
       }
     }
   }
+
+  bool get showAppWebpage {
+    return prefs?.getBool('showAppWebpage') ?? false;
+  }
+
+  set showAppWebpage(bool show) {
+    prefs?.setBool('showAppWebpage', show);
+    notifyListeners();
+  }
+
+  String? getSettingString(String settingId) {
+    return prefs?.getString(settingId);
+  }
+
+  void setSettingString(String settingId, String value) {
+    prefs?.setString(settingId, value);
+    notifyListeners();
+  }
 }

lib/providers/source_provider.dart

@@ -4,8 +4,16 @@
 import 'dart:convert';
 
 import 'package:html/dom.dart';
-import 'package:http/http.dart';
-import 'package:html/parser.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';
+import 'package:obtainium/app_sources/izzyondroid.dart';
+import 'package:obtainium/app_sources/mullvad.dart';
+import 'package:obtainium/app_sources/signal.dart';
+import 'package:obtainium/app_sources/sourceforge.dart';
+import 'package:obtainium/components/generated_form.dart';
+import 'package:obtainium/mass_app_sources/githubstars.dart';
 
 class AppNames {
   late String author;
@@ -29,8 +37,20 @@ class App {
   String? installedVersion;
   late String latestVersion;
   List<String> apkUrls = [];
-  App(this.id, this.url, this.author, this.name, this.installedVersion,
-      this.latestVersion, this.apkUrls);
+  late int preferredApkIndex;
+  late List<String> additionalData;
+  late DateTime? lastUpdateCheck;
+  App(
+      this.id,
+      this.url,
+      this.author,
+      this.name,
+      this.installedVersion,
+      this.latestVersion,
+      this.apkUrls,
+      this.preferredApkIndex,
+      this.additionalData,
+      this.lastUpdateCheck);
 
   @override
   String toString() {
@@ -46,7 +66,16 @@ class App {
           ? null
           : json['installedVersion'] as String,
       json['latestVersion'] as String,
-      List<String>.from(jsonDecode(json['apkUrls'])));
+      json['apkUrls'] == null
+          ? []
+          : List<String>.from(jsonDecode(json['apkUrls'])),
+      json['preferredApkIndex'] == null ? 0 : json['preferredApkIndex'] as int,
+      json['additionalData'] == null
+          ? SourceProvider().getSource(json['url']).additionalDataDefaults
+          : List<String>.from(jsonDecode(json['additionalData'])),
+      json['lastUpdateCheck'] == null
+          ? null
+          : DateTime.fromMicrosecondsSinceEpoch(json['lastUpdateCheck']));
 
   Map<String, dynamic> toJson() => {
         'id': id,
@@ -56,15 +85,38 @@ class App {
         'installedVersion': installedVersion,
         'latestVersion': latestVersion,
         'apkUrls': jsonEncode(apkUrls),
+        'preferredApkIndex': preferredApkIndex,
+        'additionalData': jsonEncode(additionalData),
+        'lastUpdateCheck': lastUpdateCheck?.microsecondsSinceEpoch
       };
 }
 
 escapeRegEx(String s) {
   return s.replaceAllMapped(RegExp(r'[.*+?^${}()|[\]\\]'), (x) {
-    return "\\${x[0]}";
+    return '\\${x[0]}';
   });
 }
 
+preStandardizeUrl(String url) {
+  if (url.toLowerCase().indexOf('http://') != 0 &&
+      url.toLowerCase().indexOf('https://') != 0) {
+    url = 'https://$url';
+  }
+  if (url.toLowerCase().indexOf('https://www.') == 0) {
+    url = 'https://${url.substring(12)}';
+  }
+  return url;
+}
+
+const String couldNotFindReleases = 'Could not find a suitable release';
+const String couldNotFindLatestVersion =
+    'Could not determine latest release version';
+String notValidURL(String sourceName) {
+  return 'Not a valid $sourceName App URL';
+}
+
+const String noAPKFound = 'No APK found';
+
 List<String> getLinksFromParsedHTML(
         Document dom, RegExp hrefPattern, String prependToLinks) =>
     dom
@@ -77,154 +129,103 @@ List<String> getLinksFromParsedHTML(
         .toList();
 
 abstract class AppSource {
-  late String sourceId;
+  late String host;
   String standardizeURL(String url);
-  Future<APKDetails> getLatestAPKDetails(String standardUrl);
+  Future<APKDetails> getLatestAPKDetails(
+      String standardUrl, List<String> additionalData);
   AppNames getAppNames(String standardUrl);
+  late List<List<GeneratedFormItem>> additionalDataFormItems;
+  late List<String> additionalDataDefaults;
+  late List<GeneratedFormItem> moreSourceSettingsFormItems;
+  String? changeLogPageFromStandardUrl(String standardUrl);
+  Future<String> apkUrlPrefetchModifier(String apkUrl);
 }
 
-class GitHub implements AppSource {
-  @override
-  String sourceId = 'github';
-
-  @override
-  String standardizeURL(String url) {
-    RegExp standardUrlRegEx = RegExp(r'^https?://github.com/[^/]*/[^/]*');
-    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
-    if (match == null) {
-      throw 'Not a valid URL';
-    }
-    return url.substring(0, match.end);
-  }
-
-  @override
-  Future<APKDetails> getLatestAPKDetails(String standardUrl) async {
-    // The GitHub RSS feed does not contain asset download details, so we use web scraping (avoid API due to rate limits)
-    Response res = await get(Uri.parse('$standardUrl/releases/latest'));
-    if (res.statusCode == 200) {
-      var standardUri = Uri.parse(standardUrl);
-      var parsedHtml = parse(res.body);
-      var apkUrlList = getLinksFromParsedHTML(
-          parsedHtml,
-          RegExp(
-              '^${escapeRegEx(standardUri.path)}/releases/download/[^/]+/[^/]+\\.apk\$',
-              caseSensitive: false),
-          standardUri.origin);
-      if (apkUrlList.isEmpty) {
-        throw 'No APK found';
-      }
-      String getTag(String url) {
-        List<String> parts = url.split('/');
-        return parts[parts.length - 2];
-      }
-
-      String latestTag = getTag(apkUrlList[0]);
-      String? version = parsedHtml
-          .querySelector('.octicon-tag')
-          ?.nextElementSibling
-          ?.innerHtml
-          .trim();
-      if (version == null) {
-        throw 'Could not determine latest release version';
-      }
-      return APKDetails(version,
-          apkUrlList.where((element) => getTag(element) == latestTag).toList());
-    } else {
-      throw 'Unable to fetch release info';
-    }
-  }
-
-  @override
-  AppNames getAppNames(String standardUrl) {
-    String temp = standardUrl.substring(standardUrl.indexOf('://') + 3);
-    List<String> names = temp.substring(temp.indexOf('/') + 1).split('/');
-    return AppNames(names[0], names[1]);
-  }
+abstract class MassAppSource {
+  late String name;
+  late List<String> requiredArgs;
+  Future<List<String>> getUrls(List<String> args);
 }
 
-class GitLab implements AppSource {
-  @override
-  String sourceId = 'gitlab';
-
-  @override
-  String standardizeURL(String url) {
-    RegExp standardUrlRegEx = RegExp(r'^https?://gitlab.com/[^/]*/[^/]*');
-    RegExpMatch? match = standardUrlRegEx.firstMatch(url.toLowerCase());
-    if (match == null) {
-      throw 'Not a valid URL';
-    }
-    return url.substring(0, match.end);
-  }
-
-  @override
-  Future<APKDetails> getLatestAPKDetails(String standardUrl) async {
-    // GitLab provides an RSS feed with all the details we need
-    Response res = await get(Uri.parse('$standardUrl/-/tags?format=atom'));
-    if (res.statusCode == 200) {
-      var standardUri = Uri.parse(standardUrl);
-      var parsedHtml = parse(res.body);
-      var entry = parsedHtml.querySelector('entry');
-      var entryContent =
-          parse(parseFragment(entry!.querySelector('content')!.innerHtml).text);
-      var apkUrlList = getLinksFromParsedHTML(
-          entryContent,
-          RegExp(
-              '^${escapeRegEx(standardUri.path)}/uploads/[^/]+/[^/]+\\.apk\$',
-              caseSensitive: false),
-          standardUri.origin);
-      if (apkUrlList.isEmpty) {
-        throw 'No APK found';
-      }
-
-      var entryId = entry.querySelector('id')?.innerHtml;
-      var version =
-          entryId == null ? null : Uri.parse(entryId).pathSegments.last;
-      if (version == null) {
-        throw 'Could not determine latest release version';
-      }
-      return APKDetails(version, apkUrlList);
-    } else {
-      throw 'Unable to fetch release info';
-    }
-  }
-
-  @override
-  AppNames getAppNames(String standardUrl) {
-    // Same as GitHub
-    return GitHub().getAppNames(standardUrl);
-  }
-}
-
-class sourceProvider {
+class SourceProvider {
   // Add more source classes here so they are available via the service
+  List<AppSource> sources = [
+    GitHub(),
+    GitLab(),
+    FDroid(),
+    IzzyOnDroid(),
+    Mullvad(),
+    Signal(),
+    SourceForge(),
+    APKMirror()
+  ];
+
+  // Add more mass source classes here so they are available via the service
+  List<MassAppSource> massSources = [GitHubStars()];
+
   AppSource getSource(String url) {
-    if (url.toLowerCase().contains('://github.com')) {
-      return GitHub();
-    } else if (url.toLowerCase().contains('://gitlab.com')) {
-      return GitLab();
+    url = preStandardizeUrl(url);
+    AppSource? source;
+    for (var s in sources) {
+      if (url.toLowerCase().contains('://${s.host}')) {
+        source = s;
+        break;
+      }
     }
-    throw 'URL does not match a known source';
+    if (source == null) {
+      throw 'URL does not match a known source';
+    }
+    return source;
   }
 
-  Future<App> getApp(String url) async {
-    if (url.toLowerCase().indexOf('http://') != 0 &&
-        url.toLowerCase().indexOf('https://') != 0) {
-      url = 'https://$url';
+  bool doesSourceHaveRequiredAdditionalData(AppSource source) {
+    for (var row in source.additionalDataFormItems) {
+      for (var element in row) {
+        if (element.required) {
+          return true;
+        }
+      }
     }
-    if (url.toLowerCase().indexOf('https://www.') == 0) {
-      url = 'https://${url.substring(12)}';
-    }
-    AppSource source = getSource(url);
-    String standardUrl = source.standardizeURL(url);
+    return false;
+  }
+
+  Future<App> getApp(AppSource source, String url, List<String> additionalData,
+      {String customName = ''}) async {
+    String standardUrl = source.standardizeURL(preStandardizeUrl(url));
     AppNames names = source.getAppNames(standardUrl);
-    APKDetails apk = await source.getLatestAPKDetails(standardUrl);
+    APKDetails apk =
+        await source.getLatestAPKDetails(standardUrl, additionalData);
     return App(
-        '${names.author.toLowerCase()}_${names.name.toLowerCase()}_${source.sourceId}',
+        '${names.author.toLowerCase()}_${names.name.toLowerCase()}_${source.host}',
         standardUrl,
         names.author[0].toUpperCase() + names.author.substring(1),
-        names.name[0].toUpperCase() + names.name.substring(1),
+        customName.trim().isNotEmpty
+            ? customName
+            : names.name[0].toUpperCase() + names.name.substring(1),
         null,
         apk.version,
-        apk.apkUrls);
+        apk.apkUrls,
+        apk.apkUrls.length - 1,
+        additionalData,
+        DateTime.now());
   }
+
+  /// Returns a length 2 list, where the first element is a list of Apps and
+  /// the second is a Map<String, dynamic> of URLs and errors
+  Future<List<dynamic>> getApps(List<String> urls,
+      {List<String> ignoreUrls = const []}) async {
+    List<App> apps = [];
+    Map<String, dynamic> errors = {};
+    for (var url in urls.where((element) => !ignoreUrls.contains(element))) {
+      try {
+        var source = getSource(url);
+        apps.add(await getApp(source, url, source.additionalDataDefaults));
+      } catch (e) {
+        errors.addAll(<String, dynamic>{url: e});
+      }
+    }
+    return [apps, errors];
+  }
+
+  List<String> getSourceHosts() => sources.map((e) => e.host).toList();
 }

pubspec.lock

@@ -1,6 +1,13 @@
 # Generated by pub
 # See https://dart.dev/tools/pub/glossary#lockfile
 packages:
+  animations:
+    dependency: "direct main"
+    description:
+      name: animations
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.0.7"
   archive:
     dependency: transitive
     description:
@@ -64,6 +71,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.16.0"
+  cross_file:
+    dependency: transitive
+    description:
+      name: cross_file
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "0.3.3+2"
   crypto:
     dependency: transitive
     description:
@@ -92,13 +106,55 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "0.7.8"
+  device_info_plus:
+    dependency: "direct main"
+    description:
+      name: device_info_plus
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "5.0.5"
+  device_info_plus_linux:
+    dependency: transitive
+    description:
+      name: device_info_plus_linux
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "4.0.2"
+  device_info_plus_macos:
+    dependency: transitive
+    description:
+      name: device_info_plus_macos
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "4.0.2"
+  device_info_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: device_info_plus_platform_interface
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "4.0.1"
+  device_info_plus_web:
+    dependency: transitive
+    description:
+      name: device_info_plus_web
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "4.0.2"
+  device_info_plus_windows:
+    dependency: transitive
+    description:
+      name: device_info_plus_windows
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "5.0.2"
   dynamic_color:
     dependency: "direct main"
     description:
       name: dynamic_color
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.5.3"
+    version: "1.5.4"
   fake_async:
     dependency: transitive
     description:
@@ -120,6 +176,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "6.1.4"
+  file_picker:
+    dependency: "direct main"
+    description:
+      name: file_picker
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "5.2.0+1"
   flutter:
     dependency: "direct main"
     description: flutter
@@ -152,21 +215,28 @@ packages:
       name: flutter_local_notifications
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "9.8.0+1"
+    version: "12.0.0"
   flutter_local_notifications_linux:
     dependency: transitive
     description:
       name: flutter_local_notifications_linux
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.5.1"
+    version: "1.0.0"
   flutter_local_notifications_platform_interface:
     dependency: transitive
     description:
       name: flutter_local_notifications_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "5.0.0"
+    version: "6.0.0"
+  flutter_plugin_android_lifecycle:
+    dependency: transitive
+    description:
+      name: flutter_plugin_android_lifecycle
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.0.7"
   flutter_test:
     dependency: "direct dev"
     description: flutter
@@ -232,7 +302,7 @@ packages:
       name: json_annotation
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "4.6.0"
+    version: "4.7.0"
   lints:
     dependency: transitive
     description:
@@ -261,6 +331,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.8.0"
+  mime:
+    dependency: transitive
+    description:
+      name: mime
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "1.0.2"
   nested:
     dependency: transitive
     description:
@@ -316,49 +393,49 @@ packages:
       name: path_provider_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.0.4"
+    version: "2.0.5"
   path_provider_windows:
     dependency: transitive
     description:
       name: path_provider_windows
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.1.2"
+    version: "2.1.3"
   permission_handler:
     dependency: "direct main"
     description:
       name: permission_handler
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "10.0.0"
+    version: "10.1.0"
   permission_handler_android:
     dependency: transitive
     description:
       name: permission_handler_android
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "10.0.0"
+    version: "10.1.0"
   permission_handler_apple:
     dependency: transitive
     description:
       name: permission_handler_apple
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "9.0.4"
+    version: "9.0.6"
   permission_handler_platform_interface:
     dependency: transitive
     description:
       name: permission_handler_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "3.7.0"
+    version: "3.9.0"
   permission_handler_windows:
     dependency: transitive
     description:
       name: permission_handler_windows
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.1.0"
+    version: "0.1.1"
   petitparser:
     dependency: transitive
     description:
@@ -379,7 +456,7 @@ packages:
       name: plugin_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.1.2"
+    version: "2.1.3"
   process:
     dependency: transitive
     description:
@@ -394,6 +471,48 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "6.0.3"
+  share_plus:
+    dependency: "direct main"
+    description:
+      name: share_plus
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "4.5.3"
+  share_plus_linux:
+    dependency: transitive
+    description:
+      name: share_plus_linux
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.0"
+  share_plus_macos:
+    dependency: transitive
+    description:
+      name: share_plus_macos
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.1"
+  share_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: share_plus_platform_interface
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.1.1"
+  share_plus_web:
+    dependency: transitive
+    description:
+      name: share_plus_web
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.1.0"
+  share_plus_windows:
+    dependency: transitive
+    description:
+      name: share_plus_windows
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.1"
   shared_preferences:
     dependency: "direct main"
     description:
@@ -407,7 +526,7 @@ packages:
       name: shared_preferences_android
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.0.12"
+    version: "2.0.13"
   shared_preferences_ios:
     dependency: transitive
     description:
@@ -435,7 +554,7 @@ packages:
       name: shared_preferences_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.0.0"
+    version: "2.1.0"
   shared_preferences_web:
     dependency: transitive
     description:
@@ -475,7 +594,7 @@ packages:
       name: stream_channel
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.1.0"
+    version: "2.1.1"
   string_scanner:
     dependency: transitive
     description:
@@ -496,14 +615,14 @@ packages:
       name: test_api
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.4.12"
+    version: "0.4.14"
   timezone:
     dependency: transitive
     description:
       name: timezone
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.8.0"
+    version: "0.9.0"
   typed_data:
     dependency: transitive
     description:
@@ -517,14 +636,14 @@ packages:
       name: url_launcher
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "6.1.5"
+    version: "6.1.6"
   url_launcher_android:
     dependency: transitive
     description:
       name: url_launcher_android
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "6.0.17"
+    version: "6.0.19"
   url_launcher_ios:
     dependency: transitive
     description:
@@ -552,7 +671,7 @@ packages:
       name: url_launcher_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.1.0"
+    version: "2.1.1"
   url_launcher_web:
     dependency: transitive
     description:
@@ -573,7 +692,7 @@ packages:
       name: vector_math
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.1.2"
+    version: "2.1.4"
   webview_flutter:
     dependency: "direct main"
     description:
@@ -587,28 +706,28 @@ packages:
       name: webview_flutter_android
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.9.5"
+    version: "2.10.4"
   webview_flutter_platform_interface:
     dependency: transitive
     description:
       name: webview_flutter_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.9.2"
+    version: "1.9.5"
   webview_flutter_wkwebview:
     dependency: transitive
     description:
       name: webview_flutter_wkwebview
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.9.3"
+    version: "2.9.5"
   win32:
     dependency: transitive
     description:
       name: win32
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.7.0"
+    version: "3.0.0"
   workmanager:
     dependency: "direct main"
     description:
@@ -639,4 +758,4 @@ packages:
     version: "3.1.1"
 sdks:
   dart: ">=2.19.0-79.0.dev <3.0.0"
-  flutter: ">=3.1.0-0.0.pre.1036"
+  flutter: ">=3.3.0"

pubspec.yaml

@@ -17,7 +17,7 @@ publish_to: 'none' # Remove this line if you wish to publish to pub.dev
 # https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
 # In Windows, build-name is used as the major, minor, and patch parts
 # of the product and file versions while build-number is used as the build suffix.
-version: 0.1.3+4 # When changing this, update the tag in main() accordingly
+version: 0.5.5+26 # When changing this, update the tag in main() accordingly
 
 environment:
   sdk: '>=2.19.0-79.0.dev <3.0.0'
@@ -35,21 +35,25 @@ dependencies:
 
   # The following adds the Cupertino Icons font to your application.
   # Use with the CupertinoIcons class for iOS style icons.
-  cupertino_icons: ^1.0.2
+  cupertino_icons: ^1.0.5
   path_provider: ^2.0.11
   flutter_fgbg: ^0.2.0 # Try removing reliance on this
-  flutter_local_notifications: ^9.8.0+1
+  flutter_local_notifications: ^12.0.0
   provider: ^6.0.3
   http: ^0.13.5
   webview_flutter: ^3.0.4
   workmanager: ^0.5.0
-  dynamic_color: ^1.5.3
-  install_plugin_v2: ^1.0.0 # Try replacing this
+  dynamic_color: ^1.5.4
   html: ^0.15.0
   shared_preferences: ^2.0.15
   url_launcher: ^6.1.5
   permission_handler: ^10.0.0
   fluttertoast: ^8.0.9
+  device_info_plus: ^5.0.5
+  file_picker: ^5.1.0
+  animations: ^2.0.4
+  install_plugin_v2: ^1.0.0
+  share_plus: ^4.4.0
 
 
 dev_dependencies:
@@ -62,13 +66,13 @@ dev_dependencies:
   # activated in the `analysis_options.yaml` file located at the root of your
   # package. See that file for information about deactivating specific lint
   # rules and activating additional ones.
-  flutter_lints: ^2.0.0
+  flutter_lints: ^2.0.1
 
 flutter_icons:
   android: true
-  image_path: "assets/icon.png"
+  image_path: "assets/graphics/icon.png"
   adaptive_icon_background: "#FFFFFF"
-  adaptive_icon_foreground: "assets/icon.png"
+  adaptive_icon_foreground: "assets/graphics/icon.png"
 
 # For information on the generic Dart part of this file, see the
 # following page: https://dart.dev/tools/pub/pubspec

test/widget_test.dart

@@ -13,7 +13,7 @@ import 'package:obtainium/main.dart';
 void main() {
   testWidgets('Counter increments smoke test', (WidgetTester tester) async {
     // Build our app and trigger a frame.
-    await tester.pumpWidget(const MyApp());
+    await tester.pumpWidget(const Obtainium());
 
     // Verify that our counter starts at 0.
     expect(find.text('0'), findsOneWidget);