Merge branch 'flutter' of https://github.com/revanced/revanced-manager into flutter

lib/services/github_api.dart

@@ -1,11 +1,21 @@
+import 'dart:convert';
 import 'dart:io';
+import 'package:collection/collection.dart';
+import 'package:dio/dio.dart';
+import 'package:dio_http_cache_lts/dio_http_cache_lts.dart';
 import 'package:flutter_cache_manager/flutter_cache_manager.dart';
-import 'package:github/github.dart';
-import 'package:timeago/timeago.dart';
+import 'package:injectable/injectable.dart';
+import 'package:revanced_manager/models/patch.dart';
 
+@lazySingleton
 class GithubAPI {
-  final GitHub _github = GitHub();
-
+  final String apiUrl = 'https://api.github.com';
+  final Dio _dio = Dio();
+  final DioCacheManager _dioCacheManager = DioCacheManager(CacheConfig());
+  final Options _cacheOptions = buildCacheOptions(
+    const Duration(hours: 1),
+    maxStale: const Duration(days: 7),
+  );
   final Map<String, String> repoAppPath = {
     'com.google.android.youtube': 'youtube',
     'com.google.android.apps.youtube.music': 'music',
@@ -16,31 +26,66 @@ class GithubAPI {
     'com.garzotto.pflotsh.ecmwf_a': 'ecmwf',
   };
 
-  Future<String?> latestReleaseVersion(String repoName) async {
+  void initialize() {
+    _dio.interceptors.add(_dioCacheManager.interceptor);
+  }
+
+  Future<void> clearAllCache() async {
+    await _dioCacheManager.clearAll();
+  }
+
+  Future<Map<String, dynamic>?> _getLatestRelease(String repoName) async {
     try {
-      var latestRelease = await _github.repositories.getLatestRelease(
-        RepositorySlug.full(repoName),
+      var response = await _dio.get(
+        '$apiUrl/repos/$repoName/releases/latest',
+        options: _cacheOptions,
       );
-      return latestRelease.tagName;
+      return response.data;
     } on Exception {
       return null;
     }
   }
 
-  Future<File?> latestReleaseFile(String extension, String repoName) async {
+  Future<List<String>> getCommits(
+    String packageName,
+    String repoName,
+    DateTime since,
+  ) async {
+    String path =
+        'src/main/kotlin/app/revanced/patches/${repoAppPath[packageName]}';
     try {
-      var latestRelease = await _github.repositories.getLatestRelease(
-        RepositorySlug.full(repoName),
+      var response = await _dio.get(
+        '$apiUrl/repos/$repoName/commits',
+        queryParameters: {
+          'path': path,
+          'per_page': 3,
+          'since': since.toIso8601String(),
+        },
+        options: _cacheOptions,
       );
-      String? url = latestRelease.assets
-          ?.firstWhere((asset) =>
-              asset.name != null &&
-              asset.name!.endsWith(extension) &&
-              !asset.name!.contains('-sources') &&
-              !asset.name!.contains('-javadoc'))
-          .browserDownloadUrl;
-      if (url != null) {
-        return await DefaultCacheManager().getSingleFile(url);
+      List<dynamic> commits = response.data;
+      return commits
+          .map((commit) =>
+              (commit['commit']['message'] as String).split('\n')[0])
+          .toList();
+    } on Exception {
+      return List.empty();
+    }
+  }
+
+  Future<File?> getLatestReleaseFile(String extension, String repoName) async {
+    try {
+      Map<String, dynamic>? release = await _getLatestRelease(repoName);
+      if (release != null) {
+        Map<String, dynamic>? asset =
+            (release['assets'] as List<dynamic>).firstWhereOrNull(
+          (asset) => (asset['name'] as String).endsWith(extension),
+        );
+        if (asset != null) {
+          return await DefaultCacheManager().getSingleFile(
+            asset['browser_download_url'],
+          );
+        }
       }
     } on Exception {
       return null;
@@ -48,37 +93,17 @@ class GithubAPI {
     return null;
   }
 
-  Future<String> latestCommitTime(String repoName) async {
+  Future<List<Patch>> getPatches(String repoName) async {
+    List<Patch> patches = [];
     try {
-      var repo = await _github.repositories.getRepository(
-        RepositorySlug.full(repoName),
-      );
-      return repo.pushedAt != null
-          ? format(repo.pushedAt!, locale: 'en_short')
-          : '';
+      File? f = await getLatestReleaseFile('.json', repoName);
+      if (f != null) {
+        List<dynamic> list = jsonDecode(f.readAsStringSync());
+        patches = list.map((patch) => Patch.fromJson(patch)).toList();
+      }
     } on Exception {
-      return '';
+      return List.empty();
     }
-  }
-
-  Future<List<Contributor>> getContributors(String repoName) async {
-    return await (_github.repositories.listContributors(
-      RepositorySlug.full(repoName),
-    )).toList();
-  }
-
-  Future<List<RepositoryCommit>> getCommits(
-    String packageName,
-    String repoName,
-  ) async {
-    String path =
-        'src/main/kotlin/app/revanced/patches/${repoAppPath[packageName]}';
-    return await (PaginationHelper(_github)
-        .objects<Map<String, dynamic>, RepositoryCommit>(
-      'GET',
-      '/repos/$repoName/commits',
-      (i) => RepositoryCommit.fromJson(i),
-      params: <String, dynamic>{'path': path},
-    )).toList();
+    return patches;
   }
 }

lib/services/manager_api.dart

@@ -1,17 +1,20 @@
 import 'dart:convert';
 import 'dart:io';
 import 'package:device_apps/device_apps.dart';
-import 'package:github/github.dart';
 import 'package:injectable/injectable.dart';
 import 'package:package_info_plus/package_info_plus.dart';
+import 'package:revanced_manager/app/app.locator.dart';
+import 'package:revanced_manager/models/patch.dart';
 import 'package:revanced_manager/models/patched_application.dart';
 import 'package:revanced_manager/services/github_api.dart';
+import 'package:revanced_manager/services/revanced_api.dart';
 import 'package:revanced_manager/services/root_api.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
 @lazySingleton
 class ManagerAPI {
-  final GithubAPI _githubAPI = GithubAPI();
+  final RevancedAPI _revancedAPI = locator<RevancedAPI>();
+  final GithubAPI _githubAPI = locator<GithubAPI>();
   final RootAPI _rootAPI = RootAPI();
   final String patcherRepo = 'revanced-patcher';
   final String cliRepo = 'revanced-cli';
@@ -26,10 +29,6 @@ class ManagerAPI {
     _prefs = await SharedPreferences.getInstance();
   }
 
-  String getPatcherRepo() {
-    return defaultPatcherRepo;
-  }
-
   String getPatchesRepo() {
     return _prefs.getString('patchesRepo') ?? defaultPatchesRepo;
   }
@@ -52,46 +51,6 @@ class ManagerAPI {
     await _prefs.setString('integrationsRepo', value);
   }
 
-  String getCliRepo() {
-    return defaultCliRepo;
-  }
-
-  String getManagerRepo() {
-    return _prefs.getString('managerRepo') ?? defaultManagerRepo;
-  }
-
-  Future<void> setManagerRepo(String value) async {
-    if (value.isEmpty || value.startsWith('/') || value.endsWith('/')) {
-      value = defaultManagerRepo;
-    }
-    await _prefs.setString('managerRepo', value);
-  }
-
-  Future<File?> downloadPatches(String extension) async {
-    return await _githubAPI.latestReleaseFile(extension, getPatchesRepo());
-  }
-
-  Future<File?> downloadIntegrations(String extension) async {
-    return await _githubAPI.latestReleaseFile(extension, getIntegrationsRepo());
-  }
-
-  Future<File?> downloadManager(String extension) async {
-    return await _githubAPI.latestReleaseFile(extension, getManagerRepo());
-  }
-
-  Future<String?> getLatestPatchesVersion() async {
-    return await _githubAPI.latestReleaseVersion(getPatchesRepo());
-  }
-
-  Future<String?> getLatestManagerVersion() async {
-    return await _githubAPI.latestReleaseVersion(getManagerRepo());
-  }
-
-  Future<String> getCurrentManagerVersion() async {
-    PackageInfo packageInfo = await PackageInfo.fromPlatform();
-    return packageInfo.version;
-  }
-
   bool getUseDynamicTheme() {
     return _prefs.getBool('useDynamicTheme') ?? false;
   }
@@ -110,9 +69,7 @@ class ManagerAPI {
 
   List<PatchedApplication> getPatchedApps() {
     List<String> apps = _prefs.getStringList('patchedApps') ?? [];
-    return apps
-        .map((a) => PatchedApplication.fromJson(json.decode(a)))
-        .toList();
+    return apps.map((a) => PatchedApplication.fromJson(jsonDecode(a))).toList();
   }
 
   Future<void> setPatchedApps(List<PatchedApplication> patchedApps) async {
@@ -143,6 +100,71 @@ class ManagerAPI {
     await setPatchedApps(patchedApps);
   }
 
+  void clearAllData() {
+    _revancedAPI.clearAllCache();
+    _githubAPI.clearAllCache();
+  }
+
+  Future<Map<String, List<dynamic>>> getContributors() async {
+    return await _revancedAPI.getContributors();
+  }
+
+  Future<List<Patch>> getPatches() async {
+    if (getPatchesRepo() == defaultPatchesRepo) {
+      return await _revancedAPI.getPatches();
+    } else {
+      return await _githubAPI.getPatches(getPatchesRepo());
+    }
+  }
+
+  Future<File?> downloadPatches() async {
+    String repoName = getPatchesRepo();
+    if (repoName == defaultPatchesRepo) {
+      return await _revancedAPI.getLatestReleaseFile(
+        '.jar',
+        defaultPatchesRepo,
+      );
+    } else {
+      return await _githubAPI.getLatestReleaseFile('.jar', repoName);
+    }
+  }
+
+  Future<File?> downloadIntegrations() async {
+    String repoName = getIntegrationsRepo();
+    if (repoName == defaultIntegrationsRepo) {
+      return await _revancedAPI.getLatestReleaseFile(
+        '.apk',
+        defaultIntegrationsRepo,
+      );
+    } else {
+      return await _githubAPI.getLatestReleaseFile('.apk', repoName);
+    }
+  }
+
+  Future<File?> downloadManager() async {
+    return await _revancedAPI.getLatestReleaseFile('.apk', defaultManagerRepo);
+  }
+
+  Future<String?> getLatestPatcherReleaseTime() async {
+    return await _revancedAPI.getLatestReleaseTime('.gz', defaultPatcherRepo);
+  }
+
+  Future<String?> getLatestManagerReleaseTime() async {
+    return await _revancedAPI.getLatestReleaseTime('.apk', defaultManagerRepo);
+  }
+
+  Future<String?> getLatestManagerVersion() async {
+    return await _revancedAPI.getLatestReleaseVersion(
+      '.apk',
+      defaultManagerRepo,
+    );
+  }
+
+  Future<String> getCurrentManagerVersion() async {
+    PackageInfo packageInfo = await PackageInfo.fromPlatform();
+    return packageInfo.version;
+  }
+
   Future<void> reAssessSavedApps() async {
     List<PatchedApplication> patchedApps = getPatchedApps();
     List<PatchedApplication> toRemove = [];
@@ -183,40 +205,27 @@ class ManagerAPI {
   }
 
   Future<bool> hasAppUpdates(String packageName, DateTime patchDate) async {
-    List<RepositoryCommit> commits = await _githubAPI.getCommits(
+    List<String> commits = await _githubAPI.getCommits(
       packageName,
       getPatchesRepo(),
+      patchDate,
     );
-    return commits.any((c) =>
-        c.commit != null &&
-        c.commit!.author != null &&
-        c.commit!.author!.date != null &&
-        c.commit!.author!.date!.isAfter(patchDate));
+    return commits.isNotEmpty;
   }
 
   Future<List<String>> getAppChangelog(
-    String packageName,
-    DateTime patchDate,
-  ) async {
-    List<RepositoryCommit> commits = await _githubAPI.getCommits(
+      String packageName, DateTime patchDate) async {
+    List<String> newCommits = await _githubAPI.getCommits(
       packageName,
       getPatchesRepo(),
+      patchDate,
     );
-    List<String> newCommits = commits
-        .where((c) =>
-            c.commit != null &&
-            c.commit!.author != null &&
-            c.commit!.author!.date != null &&
-            c.commit!.author!.date!.isAfter(patchDate) &&
-            c.commit!.message != null)
-        .map((c) => c.commit!.message!)
-        .toList();
     if (newCommits.isEmpty) {
-      newCommits = commits
-          .where((c) => c.commit != null && c.commit!.message != null)
-          .take(3)
-          .map((c) => c.commit!.message!)
-          .toList();
+      newCommits = await _githubAPI.getCommits(
+        packageName,
+        getPatchesRepo(),
+        DateTime(2022, 3, 20, 21, 06, 01),
+      );
     }
     return newCommits;
   }

lib/services/patcher_api.dart

@@ -1,6 +1,6 @@
-import 'dart:convert';
 import 'dart:io';
 import 'package:app_installer/app_installer.dart';
+import 'package:collection/collection.dart';
 import 'package:device_apps/device_apps.dart';
 import 'package:flutter/services.dart';
 import 'package:injectable/injectable.dart';
@@ -40,11 +40,7 @@ class PatcherAPI {
   Future<void> _loadPatches() async {
     try {
       if (_patches.isEmpty) {
-        File? patchJsonFile = await _managerAPI.downloadPatches('.json');
-        if (patchJsonFile != null) {
-          List<dynamic> list = json.decode(patchJsonFile.readAsStringSync());
-          _patches = list.map((patch) => Patch.fromJson(patch)).toList();
-        }
+        _patches = await _managerAPI.getPatches();
       }
     } on Exception {
       _patches = List.empty();
@@ -53,7 +49,6 @@ class PatcherAPI {
 
   Future<List<ApplicationWithIcon>> getFilteredInstalledApps() async {
     List<ApplicationWithIcon> filteredApps = [];
-    await _loadPatches();
     for (Patch patch in _patches) {
       for (Package package in patch.compatiblePackages) {
         try {
@@ -74,7 +69,6 @@ class PatcherAPI {
   }
 
   Future<List<Patch>> getFilteredPatches(String packageName) async {
-    await _loadPatches();
     return _patches
         .where((patch) =>
             !patch.name.contains('settings') &&
@@ -83,7 +77,6 @@ class PatcherAPI {
   }
 
   Future<List<Patch>> getAppliedPatches(List<String> appliedPatches) async {
-    await _loadPatches();
     return _patches
         .where((patch) => appliedPatches.contains(patch.name))
         .toList();
@@ -105,20 +98,22 @@ class PatcherAPI {
     );
     if (includeSettings) {
       try {
-        Patch settingsPatch = _patches.firstWhere(
+        Patch? settingsPatch = _patches.firstWhereOrNull(
           (patch) =>
               patch.name.contains('settings') &&
               patch.compatiblePackages.any((pack) => pack.name == packageName),
         );
-        selectedPatches.add(settingsPatch);
+        if (settingsPatch != null) {
+          selectedPatches.add(settingsPatch);
+        }
       } catch (e) {
         // ignore
       }
     }
-    File? patchBundleFile = await _managerAPI.downloadPatches('.jar');
+    File? patchBundleFile = await _managerAPI.downloadPatches();
     File? integrationsFile;
     if (mergeIntegrations) {
-      integrationsFile = await _managerAPI.downloadIntegrations('.apk');
+      integrationsFile = await _managerAPI.downloadIntegrations();
     }
     if (patchBundleFile != null) {
       _tmpDir.createSync();

lib/services/revanced_api.dart

@@ -0,0 +1,121 @@
+import 'dart:io';
+import 'package:collection/collection.dart';
+import 'package:dio/dio.dart';
+import 'package:dio_http_cache_lts/dio_http_cache_lts.dart';
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+import 'package:injectable/injectable.dart';
+import 'package:revanced_manager/models/patch.dart';
+import 'package:timeago/timeago.dart';
+
+@lazySingleton
+class RevancedAPI {
+  final String apiUrl = 'https://revanced-releases-api.afterst0rm.xyz';
+  final Dio _dio = Dio();
+  final DioCacheManager _dioCacheManager = DioCacheManager(CacheConfig());
+  final Options _cacheOptions = buildCacheOptions(
+    const Duration(hours: 1),
+    maxStale: const Duration(days: 7),
+  );
+
+  void initialize() {
+    _dio.interceptors.add(_dioCacheManager.interceptor);
+  }
+
+  Future<void> clearAllCache() async {
+    await _dioCacheManager.clearAll();
+  }
+
+  Future<Map<String, List<dynamic>>> getContributors() async {
+    Map<String, List<dynamic>> contributors = {};
+    try {
+      var response = await _dio.get(
+        '$apiUrl/contributors',
+        options: _cacheOptions,
+      );
+      List<dynamic> repositories = response.data['repositories'];
+      for (Map<String, dynamic> repo in repositories) {
+        String name = repo['name'];
+        contributors[name] = repo['contributors'];
+      }
+    } on Exception {
+      return {};
+    }
+    return contributors;
+  }
+
+  Future<List<Patch>> getPatches() async {
+    try {
+      var response = await _dio.get('$apiUrl/patches', options: _cacheOptions);
+      List<dynamic> patches = response.data;
+      return patches.map((patch) => Patch.fromJson(patch)).toList();
+    } on Exception {
+      return List.empty();
+    }
+  }
+
+  Future<Map<String, dynamic>?> _getLatestRelease(
+    String extension,
+    String repoName,
+  ) async {
+    try {
+      var response = await _dio.get('$apiUrl/tools', options: _cacheOptions);
+      List<dynamic> tools = response.data['tools'];
+      return tools.firstWhereOrNull(
+        (t) =>
+            t['repository'] == repoName &&
+            (t['name'] as String).endsWith(extension),
+      );
+    } on Exception {
+      return null;
+    }
+  }
+
+  Future<String?> getLatestReleaseVersion(
+      String extension, String repoName) async {
+    try {
+      Map<String, dynamic>? release =
+          await _getLatestRelease(extension, repoName);
+      if (release != null) {
+        return release['version'];
+      }
+    } on Exception {
+      return null;
+    }
+    return null;
+  }
+
+  Future<File?> getLatestReleaseFile(String extension, String repoName) async {
+    try {
+      Map<String, dynamic>? release = await _getLatestRelease(
+        extension,
+        repoName,
+      );
+      if (release != null) {
+        String url = release['browser_download_url'];
+        return await DefaultCacheManager().getSingleFile(url);
+      }
+    } on Exception {
+      return null;
+    }
+    return null;
+  }
+
+  Future<String?> getLatestReleaseTime(
+    String extension,
+    String repoName,
+  ) async {
+    try {
+      Map<String, dynamic>? release = await _getLatestRelease(
+        extension,
+        repoName,
+      );
+      if (release != null) {
+        DateTime timestamp = DateTime.parse(release['timestamp'] as String);
+        return format(timestamp, locale: 'en_short');
+      }
+    } on Exception {
+      return null;
+    }
+    return null;
+  }
+}