460 lines
16 KiB
Dart
460 lines
16 KiB
Dart
import 'dart:io';
|
|
import 'dart:isolate';
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:jni/jni.dart';
|
|
import 'package:unyo_lib/jni_isolate_message.dart';
|
|
import 'package:path/path.dart' as path;
|
|
|
|
import 'jmodels/janiyomibridge.dart';
|
|
import 'jmodels/jpage.dart';
|
|
import 'jmodels/jpreferenceitem.dart';
|
|
import 'jmodels/jsanime.dart';
|
|
import 'jmodels/jschapter.dart';
|
|
import 'jmodels/jsepisode.dart';
|
|
import 'jmodels/jsmanga.dart';
|
|
import 'jmodels/jvideo.dart';
|
|
|
|
class JniIsolate {
|
|
// Static consts
|
|
static const String _aniyomiBridgeAnimeExtensionsDir = "animeExtensions";
|
|
static const String _aniyomiBridgeMangaExtensionsDir = "mangaExtensions";
|
|
// Static variables
|
|
static late Isolate _jvmIsolate;
|
|
static late SendPort _jvmIsolateSendPort;
|
|
// Instance variables
|
|
late final String _supportDirectoryPath;
|
|
|
|
Future<(bool, SendPort)> initJniIsolate(
|
|
ReceivePort readyPort,
|
|
ReceivePort mainIsolateReceiverPort,
|
|
Directory supportDirectory,
|
|
String dyLibDir,
|
|
List<String> classPath,
|
|
) async {
|
|
_supportDirectoryPath = supportDirectory.path;
|
|
_jvmIsolate = await Isolate.spawn(
|
|
_jniWorkerEntryPoint, {
|
|
'readyPort': readyPort.sendPort,
|
|
'mainIsolateSendPort': mainIsolateReceiverPort.sendPort,
|
|
'dylibDir': dyLibDir,
|
|
'classPath': classPath,
|
|
'supportDirectoryPath': _supportDirectoryPath,
|
|
}, debugName: 'Aniyomi-JNI-Isolate');
|
|
final message = await readyPort.first;
|
|
readyPort.close();
|
|
if (message is SendPort) {
|
|
_jvmIsolateSendPort = message;
|
|
} else if (message is Map && message['error'] != null) {
|
|
throw Exception('Failed to initialize JVM: ${message['error']}');
|
|
} else {
|
|
throw Exception('Unexpected message from JVM isolate: $message');
|
|
}
|
|
return (true, _jvmIsolateSendPort);
|
|
}
|
|
|
|
void _jniWorkerEntryPoint(Map<String, dynamic> parameters) {
|
|
final SendPort readyPort = parameters['readyPort'];
|
|
final SendPort mainIsolateSendPort = parameters['mainIsolateSendPort'];
|
|
final String dylibDir = parameters['dylibDir'];
|
|
final List<String> classPath = parameters['classPath'];
|
|
final String supportDirectoryPath = parameters['supportDirectoryPath'];
|
|
|
|
try {
|
|
debugPrint('[JNI Isolate] Spawning JVM...');
|
|
Jni.spawnIfNotExists(
|
|
dylibDir: dylibDir,
|
|
classPath: classPath,
|
|
jvmOptions: ['-Djava.util.prefs.userRoot=$supportDirectoryPath'],
|
|
);
|
|
debugPrint('[JNI Isolate] JVM spawned. Running init...');
|
|
JAniyomiBridge.init();
|
|
debugPrint('[JNI Isolate] Init complete. Creating bridge instance...');
|
|
JAniyomiBridge jAniyomiBridge = JAniyomiBridge();
|
|
debugPrint('[JNI Isolate] Bridge ready. Starting message loop.');
|
|
|
|
final jniIsolateReceiverPort = ReceivePort();
|
|
// ONLY send ready signal AFTER successful init
|
|
readyPort.send(jniIsolateReceiverPort.sendPort);
|
|
|
|
jniIsolateReceiverPort.listen((message) {
|
|
if (message is! JniIsolateMessage) {
|
|
mainIsolateSendPort.send(
|
|
JniIsolateError(
|
|
id: 0,
|
|
error: 'Invalid message type received: ${message.runtimeType}',
|
|
stackTrace: '',
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
debugPrint('[JNI Isolate] Received message id=${message.id} type=${message.type.name}');
|
|
try {
|
|
switch ((message).type) {
|
|
case JniIsolateMessageType.getAnimeSearchResults:
|
|
List<JSAnime> results = _getAnimeSearchResults(
|
|
jAniyomiBridge,
|
|
message.args['query'] as String,
|
|
message.args['page'] as int,
|
|
message.args['source'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.getMangaSearchResults:
|
|
List<JSManga> results = _getMangaSearchResults(
|
|
jAniyomiBridge,
|
|
message.args['query'] as String,
|
|
message.args['page'] as int,
|
|
message.args['source'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.getEpisodeList:
|
|
List<JSEpisode> results = _getEpisodeList(
|
|
jAniyomiBridge,
|
|
message.args['sAnime'] as JSAnime,
|
|
message.args['source'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.getChapterList:
|
|
List<JSChapter> results = _getChapterList(
|
|
jAniyomiBridge,
|
|
message.args['sManga'] as JSManga,
|
|
message.args['source'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.getVideoList:
|
|
List<JVideo> results = _getVideoList(
|
|
jAniyomiBridge,
|
|
message.args['sEpisode'] as JSEpisode,
|
|
message.args['source'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.getPageList:
|
|
List<JPage> results = _getPageList(
|
|
jAniyomiBridge,
|
|
message.args['sChapter'] as JSChapter,
|
|
message.args['source'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.loadAnimeExtension:
|
|
_loadAnimeExtension(
|
|
jAniyomiBridge,
|
|
message.args['extensionUrl'] as String,
|
|
message.args['packageName'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id),
|
|
);
|
|
case JniIsolateMessageType.loadMangaExtension:
|
|
_loadMangaExtension(
|
|
jAniyomiBridge,
|
|
message.args['extensionUrl'] as String,
|
|
message.args['packageName'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id),
|
|
);
|
|
case JniIsolateMessageType.unloadAnimeExtension:
|
|
_unloadAnimeExtension(
|
|
jAniyomiBridge,
|
|
message.args['packageName'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id),
|
|
);
|
|
case JniIsolateMessageType.unloadMangaExtension:
|
|
_unloadMangaExtension(
|
|
jAniyomiBridge,
|
|
message.args['packageName'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id),
|
|
);
|
|
case JniIsolateMessageType.getAnimePreferences:
|
|
List<JPreferenceItem> results = _getAnimePreferences(
|
|
jAniyomiBridge,
|
|
message.args['packageName'] as String,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.setAnimePreference:
|
|
_setAnimePreference(
|
|
jAniyomiBridge,
|
|
message.args['packageName'] as String,
|
|
message.args['key'] as String,
|
|
message.args['value'],
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id),
|
|
);
|
|
case JniIsolateMessageType.setAnimePreferences:
|
|
_setAnimePreferences(
|
|
jAniyomiBridge,
|
|
message.args['packageName'] as String,
|
|
message.args['values'] as Map<String, dynamic>,
|
|
);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id),
|
|
);
|
|
case JniIsolateMessageType.getAnimeLoadedExtensions:
|
|
List<String> results = _getAnimeLoadedExtensions(jAniyomiBridge);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
case JniIsolateMessageType.getMangaLoadedExtensions:
|
|
List<String> results = _getMangaLoadedExtensions(jAniyomiBridge);
|
|
mainIsolateSendPort.send(
|
|
JniIsolateResponse(id: message.id, results: results),
|
|
);
|
|
}
|
|
debugPrint('[JNI Isolate] Message id=${message.id} processed OK');
|
|
} catch (e, stackTrace) {
|
|
debugPrint('[JNI Isolate] ERROR handling message id=${message.id}: $e');
|
|
mainIsolateSendPort.send(
|
|
JniIsolateError(
|
|
id: message.id,
|
|
error: e.toString(),
|
|
stackTrace: stackTrace.toString(),
|
|
),
|
|
);
|
|
}
|
|
});
|
|
} catch (e, stackTrace) {
|
|
debugPrint('[JNI Isolate] FATAL: JVM/Bridge init failed: $e');
|
|
// Send error back through readyPort so initJniIsolate throws
|
|
readyPort.send({
|
|
'error': e.toString(),
|
|
'stackTrace': stackTrace.toString(),
|
|
});
|
|
}
|
|
}
|
|
|
|
void dispose() {
|
|
_jvmIsolate.kill(priority: Isolate.immediate);
|
|
}
|
|
|
|
List<JSAnime> _getAnimeSearchResults(JAniyomiBridge jAniyomiBridge, String query, int page, String source) {
|
|
JList<JObject?>? searchResults = jAniyomiBridge.getAnimeSearchResults(
|
|
JString.fromString(query),
|
|
page,
|
|
JString.fromString(source),
|
|
);
|
|
if (searchResults == null) {
|
|
return [];
|
|
}
|
|
return searchResults
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => jObj!.as<JSAnime>(JSAnime.type))
|
|
.toList();
|
|
}
|
|
|
|
List<JSManga> _getMangaSearchResults(JAniyomiBridge jAniyomiBridge, String query, int page, String source) {
|
|
JList<JObject?>? searchResults = jAniyomiBridge.getMangaSearchResults(
|
|
JString.fromString(query),
|
|
page,
|
|
JString.fromString(source),
|
|
);
|
|
if (searchResults == null) {
|
|
return [];
|
|
}
|
|
return searchResults
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => jObj!.as<JSManga>(JSManga.type))
|
|
.toList();
|
|
}
|
|
|
|
List<JSEpisode> _getEpisodeList(JAniyomiBridge jAniyomiBridge, JSAnime sAnime, String source) {
|
|
JList<JObject?>? episodeList = jAniyomiBridge.getEpisodeList(
|
|
sAnime,
|
|
JString.fromString(source),
|
|
);
|
|
if (episodeList == null) {
|
|
return [];
|
|
}
|
|
return episodeList
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => jObj!.as<JSEpisode>(JSEpisode.type))
|
|
.toList();
|
|
}
|
|
|
|
List<JSChapter> _getChapterList(JAniyomiBridge jAniyomiBridge, JSManga sManga, String source) {
|
|
JList<JObject?>? chapterList = jAniyomiBridge.getChapterList(
|
|
sManga,
|
|
JString.fromString(source),
|
|
);
|
|
if (chapterList == null) {
|
|
return [];
|
|
}
|
|
return chapterList
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => jObj!.as<JSChapter>(JSChapter.type))
|
|
.toList();
|
|
}
|
|
|
|
List<JVideo> _getVideoList(JAniyomiBridge jAniyomiBridge, JSEpisode sEpisode, String source) {
|
|
JList<JObject?>? videoList = jAniyomiBridge.getVideoList(
|
|
sEpisode,
|
|
JString.fromString(source),
|
|
);
|
|
if (videoList == null) {
|
|
return [];
|
|
}
|
|
return videoList
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => jObj!.as<JVideo>(JVideo.type))
|
|
.toList();
|
|
}
|
|
|
|
List<JPage> _getPageList(JAniyomiBridge jAniyomiBridge, JSChapter sChapter, String source) {
|
|
JList<JObject?>? pageList = jAniyomiBridge.getPageList(
|
|
sChapter,
|
|
JString.fromString(source),
|
|
);
|
|
if (pageList == null) {
|
|
return [];
|
|
}
|
|
return pageList
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => jObj!.as<JPage>(JPage.type))
|
|
.toList();
|
|
}
|
|
|
|
void _loadAnimeExtension(JAniyomiBridge jAniyomiBridge, String extensionUrl, String packageName) {
|
|
final repoName = _resolveRepoNameFromUrl(extensionUrl);
|
|
jAniyomiBridge.loadAnimeExtension(
|
|
JString.fromString(extensionUrl),
|
|
JString.fromString(
|
|
path.join(_supportDirectoryPath, _aniyomiBridgeAnimeExtensionsDir, repoName),
|
|
),
|
|
JString.fromString(packageName),
|
|
);
|
|
}
|
|
|
|
void _unloadAnimeExtension(JAniyomiBridge jAniyomiBridge, String packageName) {
|
|
jAniyomiBridge.unloadAnimeExtension(
|
|
JString.fromString(packageName),
|
|
);
|
|
}
|
|
|
|
void _loadMangaExtension(JAniyomiBridge jAniyomiBridge, String extensionUrl, String packageName) {
|
|
final repoName = _resolveRepoNameFromUrl(extensionUrl);
|
|
jAniyomiBridge.loadMangaExtension(
|
|
JString.fromString(extensionUrl),
|
|
JString.fromString(
|
|
path.join(_supportDirectoryPath, _aniyomiBridgeMangaExtensionsDir, repoName),
|
|
),
|
|
JString.fromString(packageName),
|
|
);
|
|
}
|
|
|
|
void _unloadMangaExtension(JAniyomiBridge jAniyomiBridge, String packageName) {
|
|
jAniyomiBridge.unloadMangaExtension(
|
|
JString.fromString(packageName),
|
|
);
|
|
}
|
|
|
|
/// Resolves a repo name from an extension URL to use as a subdirectory.
|
|
/// Extracts the first 2 path segments + hostname and sanitizes for filesystem use.
|
|
String _resolveRepoNameFromUrl(String extensionUrl) {
|
|
try {
|
|
final uri = Uri.parse(extensionUrl);
|
|
final host = uri.host;
|
|
if (host.isNotEmpty) {
|
|
// Get first 2 non-empty path segments
|
|
final segments = uri.pathSegments
|
|
.where((s) => s.isNotEmpty)
|
|
.take(2)
|
|
.toList();
|
|
// Sanitize each part: replace non-alphanumeric with underscore
|
|
final sanitizedHost = host.replaceAll(RegExp(r'[^a-zA-Z0-9._-]'), '_');
|
|
if (segments.isEmpty) {
|
|
return sanitizedHost;
|
|
}
|
|
final sanitizedSegments = segments
|
|
.map((s) => s.replaceAll(RegExp(r'[^a-zA-Z0-9._-]'), '_'))
|
|
.join('-');
|
|
return '$sanitizedSegments:$sanitizedHost';
|
|
}
|
|
} catch (_) {
|
|
// Fall through to default
|
|
}
|
|
return 'unknown';
|
|
}
|
|
|
|
List<JPreferenceItem> _getAnimePreferences(JAniyomiBridge jAniyomiBridge, String packageName) {
|
|
JList<JObject?>? prefs = jAniyomiBridge.getAnimePreferences(JString.fromString(packageName));
|
|
if (prefs == null) return [];
|
|
return prefs
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => jObj!.as<JPreferenceItem>(JPreferenceItem.type))
|
|
.toList();
|
|
}
|
|
|
|
void _setAnimePreference(JAniyomiBridge jAniyomiBridge, String packageName, String key, dynamic value) {
|
|
JObject jValue;
|
|
if (value is bool) {
|
|
jValue = JBoolean(value);
|
|
} else if (value is String) {
|
|
jValue = JString.fromString(value);
|
|
} else if (value is Set || value is List) {
|
|
// Java side splits String by ";" for MultiSelectListPreference
|
|
jValue = JString.fromString(value.join(';'));
|
|
} else {
|
|
throw UnsupportedError('Unsupported preference value type: ${value.runtimeType}');
|
|
}
|
|
jAniyomiBridge.setAnimePreference(
|
|
JString.fromString(packageName),
|
|
JString.fromString(key),
|
|
jValue,
|
|
);
|
|
}
|
|
|
|
void _setAnimePreferences(JAniyomiBridge jAniyomiBridge, String packageName, Map<String, dynamic> values) {
|
|
for (final entry in values.entries) {
|
|
_setAnimePreference(jAniyomiBridge, packageName, entry.key, entry.value);
|
|
}
|
|
}
|
|
|
|
List<String> _getAnimeLoadedExtensions(JAniyomiBridge jAniyomiBridge) {
|
|
JList<JObject?>? loaded = jAniyomiBridge.getAnimeLoadedExtensions();
|
|
if (loaded == null) return [];
|
|
return loaded
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => (jObj!.as<JString>(JString.type)).toDartString())
|
|
.toList();
|
|
}
|
|
|
|
List<String> _getMangaLoadedExtensions(JAniyomiBridge jAniyomiBridge) {
|
|
JList<JObject?>? loaded = jAniyomiBridge.getMangaLoadedExtensions();
|
|
if (loaded == null) return [];
|
|
return loaded
|
|
.cast<JObject?>()
|
|
.where(_jObjIsNotNull)
|
|
.map((jObj) => (jObj!.as<JString>(JString.type)).toDartString())
|
|
.toList();
|
|
}
|
|
|
|
bool Function(JObject? jObj) get _jObjIsNotNull =>
|
|
(jObj) => jObj != null;
|
|
}
|