ReVanced/revanced-manager
1
0
Fork 0
mirror of https://github.com/revanced/revanced-manager.git synced 2025-06-12 20:57:36 +02:00
Code Issues Packages Projects Releases Wiki Activity

feat: Add ReVanced API and implement cache on it and on Github API

Browse Source
This commit is contained in:
Alberto Ponces
2022-09-11 02:01:06 +01:00
parent fe13234faa
commit 595ecb7660
15 changed files with 454 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
lib/services/github_api.dart
View File

@ -1,11 +1,21 @@
import 'dart:convert';
import 'dart:io';
// ignore: depend_on_referenced_packages
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:revanced_manager/models/patch.dart';
class GithubAPI {
final GitHub _github = GitHub();
final String apiUrl = 'https://api.github.com';
final Dio _dio = Dio();
final DioCacheManager _dioCacheManager = DioCacheManager(
CacheConfig(
defaultMaxAge: const Duration(hours: 1),
defaultMaxStale: const Duration(days: 7),
),
);
final Map<String, String> repoAppPath = {
'com.google.android.youtube': 'youtube',
'com.google.android.apps.youtube.music': 'music',
@ -16,31 +26,78 @@ class GithubAPI {
'com.garzotto.pflotsh.ecmwf_a': 'ecmwf',
};
Future<String?> latestReleaseVersion(String repoName) async {
try {
var latestRelease = await _github.repositories.getLatestRelease(
RepositorySlug.full(repoName),
);
return latestRelease.tagName;
} on Exception {
return null;
}
void initialize() {
_dio.interceptors.add(_dioCacheManager.interceptor);
}
Future<File?> latestReleaseFile(String extension, String repoName) async {
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: buildCacheOptions(const Duration(hours: 1)),
);
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);
if (response.headers.value(DIO_CACHE_HEADER_KEY_DATA_SOURCE) != null) {
print('1 - From cache');
} else {
print('1 - From net');
}
return response.data;
} on Exception {
// ignore
}
return null;
}
Future<List<String>> getCommits(
String packageName,
String repoName,
DateTime since,
) async {
String path =
'src/main/kotlin/app/revanced/patches/${repoAppPath[packageName]}';
try {
var response = await _dio.get(
'$apiUrl/repos/$repoName/commits',
queryParameters: {
'path': path,
'per_page': 3,
'since': since.toIso8601String(),
},
options: buildCacheOptions(const Duration(hours: 1)),
);
if (response.headers.value(DIO_CACHE_HEADER_KEY_DATA_SOURCE) != null) {
print('2 - From cache');
} else {
print('2 - From net');
}
List<dynamic> commits = response.data;
return commits
.map((commit) =>
(commit['commit']['message'] as String).split('\n')[0])
.toList();
} on Exception {
// ignore
}
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 +105,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 '';
// ignore
}
}
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;
}
}

152
lib/services/manager_api.dart
View File

@ -1,16 +1,18 @@
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/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 RevancedAPI _revancedAPI = RevancedAPI();
final GithubAPI _githubAPI = GithubAPI();
final RootAPI _rootAPI = RootAPI();
final String patcherRepo = 'revanced-patcher';
@ -26,10 +28,6 @@ class ManagerAPI {
_prefs = await SharedPreferences.getInstance();
}
String getPatcherRepo() {
return defaultPatcherRepo;
}
String getPatchesRepo() {
return _prefs.getString('patchesRepo') ?? defaultPatchesRepo;
}
@ -52,46 +50,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 +68,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 +99,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 +204,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;
}

22
lib/services/patcher_api.dart
View File

@ -1,6 +1,7 @@
import 'dart:convert';
import 'dart:io';
import 'package:app_installer/app_installer.dart';
// ignore: depend_on_referenced_packages
import 'package:collection/collection.dart';
import 'package:device_apps/device_apps.dart';
import 'package:flutter/services.dart';
import 'package:injectable/injectable.dart';
@ -39,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();
@ -52,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 {
@ -73,7 +69,6 @@ class PatcherAPI {
}
Future<List<Patch>> getFilteredPatches(String packageName) async {
await _loadPatches();
return _patches
.where((patch) =>
!patch.name.contains('settings') &&
@ -82,7 +77,6 @@ class PatcherAPI {
}
Future<List<Patch>> getAppliedPatches(List<String> appliedPatches) async {
await _loadPatches();
return _patches
.where((patch) => appliedPatches.contains(patch.name))
.toList();
@ -104,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();

138
lib/services/revanced_api.dart Normal file
View File

@ -0,0 +1,138 @@
import 'dart:io';
// ignore: depend_on_referenced_packages
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(minutes: 10),
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,
);
if (response.headers.value(DIO_CACHE_HEADER_KEY_DATA_SOURCE) != null) {
print('3 - From cache');
} else {
print('3 - From net');
}
List<dynamic> repositories = response.data['repositories'];
for (Map<String, dynamic> repo in repositories) {
String name = repo['name'];
contributors[name] = repo['contributors'];
}
} on Exception {
// ignore
}
return contributors;
}
Future<List<Patch>> getPatches() async {
try {
var response = await _dio.get('$apiUrl/patches', options: _cacheOptions);
if (response.headers.value(DIO_CACHE_HEADER_KEY_DATA_SOURCE) != null) {
print('4 - From cache');
} else {
print('4 - From net');
}
List<dynamic> patches = response.data;
return patches.map((patch) => Patch.fromJson(patch)).toList();
} on Exception {
// ignore
}
return List.empty();
}
Future<Map<String, dynamic>?> _getLatestRelease(
String extension,
String repoName,
) async {
try {
var response = await _dio.get('$apiUrl/tools', options: _cacheOptions);
if (response.headers.value(DIO_CACHE_HEADER_KEY_DATA_SOURCE) != null) {
print('5 - From cache');
} else {
print('5 - From net');
}
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;
}
}