Fixed update checking on App page

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

@@ -4,19 +4,23 @@ 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/)
+
 ## 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 GitHub, data is gathered using Web scraping and can easily break due to changes in website design. More reliable methods are either insufficient (GitHub RSS) or subject to rate limits (GitHub API). This may also apply to new sources added in the future.
+- 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/AndroidManifest.xml

@@ -30,6 +30,16 @@
         <meta-data
             android:name="flutterEmbedding"
             android:value="2" />
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileProvider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
     </application>
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />

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/fdroid.dart

@@ -0,0 +1,66 @@
+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
+  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,158 @@
+import 'dart:convert';
+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';
+
+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
+  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 Credentials (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;
+          }
+        ])
+  ];
+}

lib/app_sources/gitlab.dart

@@ -0,0 +1,74 @@
+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
+  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,68 @@
+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
+  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,54 @@
+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
+  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,47 @@
+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
+  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,71 @@
+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
+  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,177 @@
+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;
+
+  GeneratedFormItem(
+      {this.label = 'Input',
+      this.type = FormItemType.string,
+      this.required = true,
+      this.max = 1,
+      this.additionalValidators = const [],
+      this.id = 'input'});
+}
+
+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 ? ' *' : '')),
+            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: rowInput.value));
+      });
+      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,50 +11,100 @@ 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.5-beta'; // KEEP THIS IN SYNC WITH GITHUB RELEASES
+    'v0.5.1-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 = // TODO: Uncomment this and below when it works
+    //     appsProvider.getExistingUpdates(installedOnly: true);
+    List<String> existingUpdateIds =
+        appsProvider.getExistingUpdates(installedOnly: true);
+    DateTime nextIgnoreAfter = DateTime.now();
+    try {
+      await appsProvider.checkUpdates(ignoreAfter: ignoreAfter);
+    } catch (e) {
+      if (e is RateLimitError) {
+        // Ignore these (scheduling another task as below does not work)
+        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();
+    // List<String> silentlyUpdated = await appsProvider
+    //     .downloadAndInstallLatestApp(
+    //         [...newUpdates.map((e) => e.id), ...existingUpdateIds], null);
+    // if (silentlyUpdated.isNotEmpty) {
+    //   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 notificationsProvider
-          .cancel(ErrorCheckingUpdatesNotification('').id);
-      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())
     ],
@@ -71,30 +123,39 @@ 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().host}',
-            '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 (settingsProvider.updateInterval == 0) {
+        Workmanager().cancelByUniqueName(bgUpdateCheckTaskName);
+      } else {
+        Workmanager().registerPeriodicTask(
+            bgUpdateCheckTaskName, bgUpdateCheckTaskName,
+            frequency: Duration(minutes: settingsProvider.updateInterval),
+            initialDelay: Duration(minutes: settingsProvider.updateInterval),
+            constraints: Constraints(networkType: NetworkType.connected),
+            existingWorkPolicy: ExistingWorkPolicy.keep,
+            backoffPolicy: BackoffPolicy.linear,
+            backoffPolicyDelay:
+                const Duration(minutes: minUpdateIntervalMinutes));
       }
     }
 

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,5 +1,7 @@
 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';
@@ -15,120 +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) {
     SourceProvider sourceProvider = SourceProvider();
-    return Center(
-      child: Form(
-          key: _formKey,
-          child: Column(
-            mainAxisAlignment: MainAxisAlignment.spaceBetween,
-            crossAxisAlignment: CrossAxisAlignment.stretch,
-            children: [
-              Container(),
-              Padding(
+    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: [
-                    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),
-                      child: ElevatedButton(
-                        onPressed: gettingAppInfo
-                            ? null
-                            : () {
-                                HapticFeedback.mediumImpact();
-                                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(() {
+                    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(() {
-                                      gettingAppInfo = false;
+                                      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 = '';
+                                        }
+                                      }
                                     });
-                                  });
-                                }
-                              },
-                        child: const Text('Add'),
+                                  },
+                                  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'))
+                        ],
                       ),
-                    ),
-                  ],
-                ),
-              ),
-              Column(crossAxisAlignment: CrossAxisAlignment.center, children: [
-                const Text(
-                  'Supported Sources:',
-                  // style: TextStyle(fontWeight: FontWeight.bold),
-                  // style: Theme.of(context).textTheme.bodySmall,
-                ),
-                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()
-              ]),
-              if (gettingAppInfo)
-                const LinearProgressIndicator()
-              else
-                Container(),
-            ],
-          )),
-    );
+                      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,6 +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';
 
@@ -17,18 +22,98 @@ class _AppPageState extends State<AppPage> {
   @override
   Widget build(BuildContext context) {
     var appsProvider = context.watch<AppsProvider>();
+    var settingsProvider = context.watch<SettingsProvider>();
+    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() && app != null) {
+      appsProvider.getUpdate(app.app.id).catchError((e) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text(e.toString())),
+        );
+      });
     }
     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) {
+              try {
+                await appsProvider.getUpdate(app.app.id);
+              } catch (e) {
+                ScaffoldMessenger.of(context).showSnackBar(
+                  SnackBar(content: Text(e.toString())),
+                );
+              }
+            }
+          }),
       bottomSheet: Padding(
           padding: EdgeInsets.fromLTRB(
               0, 0, 0, MediaQuery.of(context).padding.bottom),
@@ -40,6 +125,132 @@ 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]);
+                                        }
+                                      });
+                                    },
+                              tooltip: 'Additional Options',
+                              icon: const Icon(Icons.settings)),
+                        const SizedBox(width: 16.0),
                         Expanded(
                             child: ElevatedButton(
                                 onPressed: (app?.app.installedVersion == null ||
@@ -53,7 +264,7 @@ class _AppPageState extends State<AppPage> {
                                             .downloadAndInstallLatestApp(
                                                 [app!.app.id],
                                                 context).then((res) {
-                                          if (res && mounted) {
+                                          if (res.isNotEmpty && mounted) {
                                             Navigator.of(context).pop();
                                           }
                                         });
@@ -67,7 +278,6 @@ class _AppPageState extends State<AppPage> {
                           onPressed: app?.downloadProgress != null
                               ? null
                               : () {
-                                  HapticFeedback.lightImpact();
                                   showDialog(
                                       context: context,
                                       builder: (BuildContext ctx) {
@@ -78,10 +288,10 @@ class _AppPageState extends State<AppPage> {
                                           actions: [
                                             TextButton(
                                                 onPressed: () {
-                                                  HapticFeedback.heavyImpact();
-                                                  appsProvider
-                                                      .removeApp(app!.app.id)
-                                                      .then((_) {
+                                                  HapticFeedback
+                                                      .selectionClick();
+                                                  appsProvider.removeApps(
+                                                      [app!.app.id]).then((_) {
                                                     int count = 0;
                                                     Navigator.of(context)
                                                         .popUntil((_) =>
@@ -91,7 +301,6 @@ class _AppPageState extends State<AppPage> {
                                                 child: const Text('Remove')),
                                             TextButton(
                                                 onPressed: () {
-                                                  HapticFeedback.lightImpact();
                                                   Navigator.of(context).pop();
                                                 },
                                                 child: const Text('Cancel'))
@@ -100,8 +309,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,82 +1,435 @@
 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:provider/provider.dart';
+import 'package:share_plus/share_plus.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.areDownloadsRunning()
-                    ? null
-                    : () {
-                        HapticFeedback.heavyImpact();
-                        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: () {
-                        HapticFeedback.lightImpact();
-                        return 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
+                        ? const Text('Update Available')
+                        : 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,7 +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 {
@@ -11,44 +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 WillPopScope(
         child: Scaffold(
-          appBar: AppBar(title: const Text('Obtainium')),
-          body: pages.elementAt(selectedIndex),
+          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: const [
-              NavigationDestination(
-                  icon: Icon(Icons.settings), label: 'Settings'),
-              NavigationDestination(icon: Icon(Icons.apps), label: 'Apps'),
-              NavigationDestination(icon: Icon(Icons.add), label: 'Add App'),
-            ],
+            destinations: pages
+                .map((e) =>
+                    NavigationDestination(icon: Icon(e.icon), label: e.title))
+                .toList(),
             onDestinationSelected: (int index) {
-              HapticFeedback.lightImpact();
+              HapticFeedback.selectionClick();
               setState(() {
-                selectedIndex = index;
+                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: selectedIndex,
+            selectedIndex:
+                selectedIndexHistory.isEmpty ? 0 : selectedIndexHistory.last,
           ),
         ),
         onWillPop: () async {
-          if (selectedIndex != 1) {
+          if (selectedIndexHistory.isNotEmpty) {
             setState(() {
-              selectedIndex = 1;
+              selectedIndexHistory.removeLast();
             });
             return false;
           }
-          return true;
+          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,9 +1,8 @@
-import 'dart:convert';
-
 import 'package:flutter/material.dart';
-import 'package:flutter/services.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';
 
@@ -17,230 +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
-                              : () {
-                                  HapticFeedback.lightImpact();
-                                  appsProvider.exportApps().then((String path) {
-                                    ScaffoldMessenger.of(context).showSnackBar(
-                                      SnackBar(
-                                          content: Text('Exported to $path')),
-                                    );
-                                  });
-                                },
-                          child: const Text('Export Apps')),
-                      ElevatedButton(
-                          onPressed: () {
-                            HapticFeedback.lightImpact();
-                            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: () {
-                                            HapticFeedback.lightImpact();
-                                            Navigator.of(context).pop();
-                                          },
-                                          child: const Text('Cancel')),
-                                      TextButton(
-                                          onPressed: () {
-                                            HapticFeedback.heavyImpact();
-                                            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')),
-                                    ],
-                                  );
-                                });
-                          },
-                          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: () {
-                          HapticFeedback.lightImpact();
-                          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,6 +5,7 @@ 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:obtainium/providers/notifications_provider.dart';
@@ -13,7 +14,7 @@ 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';
+import 'package:flutter_install_app/flutter_install_app.dart';
 
 class AppInMemory {
   late App app;
@@ -39,14 +40,26 @@ 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 {
@@ -84,54 +97,118 @@ class AppsProvider with ChangeNotifier {
       .where((element) => element.downloadProgress != null)
       .isNotEmpty;
 
-  // 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<bool> downloadAndInstallLatestApp(
-      List<String> appIds, BuildContext context) async {
+  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 AppInstaller.installApk(file.file.path, actionRequired: false);
+    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) {
+
+      // If the App has more than one APK, the user should pick one (if context provided)
+      String? apkUrl = apps[id]!.app.apkUrls[apps[id]!.app.preferredApkIndex];
+      if (apps[id]!.app.apkUrls.length > 1 && context != null) {
         apkUrl = await showDialog(
             context: context,
             builder: (BuildContext ctx) {
               return APKPicker(app: apps[id]!.app, initVal: apkUrl);
             });
       }
+      // If the picked APK comes from an origin different from the source, get user confirmation (if context provided)
+      if (apkUrl != null &&
+          Uri.parse(apkUrl).origin != Uri.parse(apps[id]!.app.url).origin &&
+          context != null) {
+        if (await showDialog(
+                context: context,
+                builder: (BuildContext ctx) {
+                  return APKOriginWarningDialog(
+                      sourceUrl: apps[id]!.app.url, apkUrl: apkUrl!);
+                }) !=
+            true) {
+          apkUrl = null;
+        }
+      }
       if (apkUrl != null) {
-        appsToInstall.putIfAbsent(id, () => apkUrl!);
+        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;
-      await notificationsProvider.cancel(completeInstallationNotification.id);
-      // 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
-    }
-
-    // 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
+    List<ApkFile> silentUpdates = [];
+    List<ApkFile> regularInstalls = [];
     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);
+      bool willBeSilent = await canInstallSilently(apps[f.appId]!.app);
+      if (willBeSilent) {
+        silentUpdates.add(f);
+      } else {
+        regularInstalls.add(f);
+      }
     }
 
-    return downloadedFiles.isNotEmpty;
+    for (var u in silentUpdates) {
+      await installApk(u);
+    }
+
+    if (context != null) {
+      if (regularInstalls.isNotEmpty) {
+        // ignore: use_build_context_synchronously
+        await askUserToReturnToForeground(context);
+      }
+      for (var i in regularInstalls) {
+        await installApk(i);
+      }
+    }
+
+    return downloadedFiles.map((e) => e.appId).toList();
   }
 
   Future<Directory> getAppsDir() async {
@@ -169,23 +246,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) {
@@ -197,21 +281,44 @@ class AppsProvider with ChangeNotifier {
 
   Future<App?> getUpdate(String appId) async {
     App? currentApp = apps[appId]!.app;
-    App newApp = await SourceProvider().getApp(currentApp.url);
+    SourceProvider sourceProvider = SourceProvider();
+    App newApp = await sourceProvider.getApp(
+        sourceProvider.getSource(currentApp.url),
+        currentApp.url,
+        currentApp.additionalData);
     if (newApp.latestVersion != currentApp.latestVersion) {
       newApp.installedVersion = currentApp.installedVersion;
-      await saveApp(newApp);
+      if (currentApp.preferredApkIndex < newApp.apkUrls.length) {
+        newApp.preferredApkIndex = currentApp.preferredApkIndex;
+      }
+      await saveApps([newApp]);
       return newApp;
+    } else if ((newApp.lastUpdateCheck?.microsecondsSinceEpoch ?? 0) -
+            (currentApp.lastUpdateCheck?.microsecondsSinceEpoch ?? 0) >
+        5000000) {
+      currentApp.lastUpdateCheck = newApp.lastUpdateCheck;
+      await saveApps([currentApp]);
     }
     return 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) {
@@ -223,13 +330,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;
@@ -257,7 +371,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;
@@ -290,28 +404,27 @@ class _APKPickerState extends State<APKPicker> {
       scrollable: true,
       title: const Text('Pick an APK'),
       content: Column(children: [
-        Text('${widget.app.name} has more than one package - pick one.'),
-        ...widget.app.apkUrls.map((u) => ListTile(
+        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.last),
-            leading: Radio<String>(
-                value: u,
-                groupValue: apkUrl,
-                onChanged: (String? val) {
-                  setState(() {
-                    apkUrl = val;
-                  });
-                })))
+            value: u,
+            groupValue: apkUrl,
+            onChanged: (String? val) {
+              setState(() {
+                apkUrl = val;
+              });
+            }))
       ]),
       actions: [
         TextButton(
             onPressed: () {
-              HapticFeedback.lightImpact();
               Navigator.of(context).pop(null);
             },
             child: const Text('Cancel')),
         TextButton(
             onPressed: () {
-              HapticFeedback.mediumImpact();
+              HapticFeedback.selectionClick();
               Navigator.of(context).pop(apkUrl);
             },
             child: const Text('Continue'))
@@ -319,3 +432,39 @@ class _APKPickerState extends State<APKPicker> {
     );
   }
 }
+
+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,21 @@ 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);
+  }
 }

lib/providers/source_provider.dart

@@ -4,8 +4,15 @@
 import 'dart:convert';
 
 import 'package:html/dom.dart';
-import 'package:http/http.dart';
-import 'package:html/parser.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 +36,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 +65,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 +84,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
@@ -79,160 +130,37 @@ List<String> getLinksFromParsedHTML(
 abstract class AppSource {
   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;
 }
 
-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 '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]);
-  }
-}
-
-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 '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 Signal implements AppSource {
-  @override
-  late String host = 'signal.org';
-
-  @override
-  String standardizeURL(String url) {
-    return 'https://$host';
-  }
-
-  @override
-  Future<APKDetails> getLatestAPKDetails(String standardUrl) 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 'No APK found';
-      }
-      String? version = json['versionName'];
-      if (version == null) {
-        throw 'Could not determine latest release version';
-      }
-      return APKDetails(version, [apkUrl]);
-    } else {
-      throw 'Unable to fetch release info';
-    }
-  }
-
-  @override
-  AppNames getAppNames(String standardUrl) => AppNames('signal', 'signal');
+abstract class MassAppSource {
+  late String name;
+  late List<String> requiredArgs;
+  Future<List<String>> getUrls(List<String> args);
 }
 
 class SourceProvider {
-  List<AppSource> sources = [GitHub(), GitLab(), Signal()];
-
   // Add more source classes here so they are available via the service
+  List<AppSource> sources = [
+    GitHub(),
+    GitLab(),
+    FDroid(),
+    IzzyOnDroid(),
+    Mullvad(),
+    Signal(),
+    SourceForge()
+  ];
+
+  // Add more mass source classes here so they are available via the service
+  List<MassAppSource> massSources = [GitHubStars()];
+
   AppSource getSource(String url) {
+    url = preStandardizeUrl(url);
     AppSource? source;
     for (var s in sources) {
       if (url.toLowerCase().contains('://${s.host}')) {
@@ -246,26 +174,53 @@ class SourceProvider {
     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.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.5"
   archive:
     dependency: transitive
     description:
@@ -92,13 +99,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: "4.1.2"
+  device_info_plus_linux:
+    dependency: transitive
+    description:
+      name: device_info_plus_linux
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.0"
+  device_info_plus_macos:
+    dependency: transitive
+    description:
+      name: device_info_plus_macos
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.0"
+  device_info_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: device_info_plus_platform_interface
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.0"
+  device_info_plus_web:
+    dependency: transitive
+    description:
+      name: device_info_plus_web
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.0"
+  device_info_plus_windows:
+    dependency: transitive
+    description:
+      name: device_info_plus_windows
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "4.1.0"
   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 +169,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
@@ -132,6 +188,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "0.2.0"
+  flutter_install_app:
+    dependency: "direct main"
+    description:
+      name: flutter_install_app
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "1.3.0"
   flutter_launcher_icons:
     dependency: "direct dev"
     description:
@@ -152,21 +215,28 @@ packages:
       name: flutter_local_notifications
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "9.8.0+1"
+    version: "11.0.1"
   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
@@ -212,13 +282,6 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "3.2.0"
-  install_plugin_v2:
-    dependency: "direct main"
-    description:
-      name: install_plugin_v2
-      url: "https://pub.dartlang.org"
-    source: hosted
-    version: "1.0.0"
   js:
     dependency: transitive
     description:
@@ -232,7 +295,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 +324,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,21 +386,21 @@ 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.0.2"
   permission_handler_android:
     dependency: transitive
     description:
@@ -351,7 +421,7 @@ packages:
       name: permission_handler_platform_interface
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "3.7.0"
+    version: "3.8.0"
   permission_handler_windows:
     dependency: transitive
     description:
@@ -379,7 +449,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 +464,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.4.0"
+  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.0.3"
+  share_plus_web:
+    dependency: transitive
+    description:
+      name: share_plus_web
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "3.0.1"
+  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 +519,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 +547,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 +587,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 +608,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 +629,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 +664,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 +685,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 +699,28 @@ packages:
       name: webview_flutter_android
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.9.5"
+    version: "2.10.3"
   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 +751,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.5+6 # When changing this, update the tag in main() accordingly
+version: 0.5.1+22 # 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: ^11.0.1
   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: ^4.1.2
+  file_picker: ^5.1.0
+  animations: ^2.0.4
+  flutter_install_app: ^1.3.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