Add android separates the core process

Support core status check and force restart

Optimize proxies page and access page

Update flutter and pub dependencies

Optimize more details

android/app/src/main/kotlin/com/follow/clash/MainActivity.kt

@@ -2,6 +2,7 @@ package com.follow.clash
 
 import android.os.Bundle
 import androidx.lifecycle.lifecycleScope
+import com.follow.clash.common.GlobalState
 import com.follow.clash.plugins.AppPlugin
 import com.follow.clash.plugins.ServicePlugin
 import com.follow.clash.plugins.TilePlugin
@@ -31,6 +32,9 @@ class MainActivity : FlutterActivity(),
     }
 
     override fun onDestroy() {
+        GlobalState.launch {
+            Service.setEventListener(null)
+        }
         State.flutterEngine = null
         super.onDestroy()
     }

android/app/src/main/kotlin/com/follow/clash/Service.kt

@@ -55,24 +55,30 @@ object Service {
     }
 
     suspend fun setEventListener(
-        cb: (result: String?) -> Unit
+        cb: ((result: String?) -> Unit)?
     ): Result<Unit> {
         val results = HashMap<String, MutableList<ByteArray>>()
         return delegate.useService {
-            it.setEventListener(object : IEventInterface.Stub() {
-                override fun onEvent(
-                    id: String, data: ByteArray?, isSuccess: Boolean
-                ) {
-                    if (results[id] == null) {
-                        results[id] = mutableListOf()
-                    }
-                    results[id]?.add(data ?: byteArrayOf())
-                    if (isSuccess) {
-                        cb(results[id]?.formatString())
-                        results.remove(id)
+            it.setEventListener(
+                when (cb != null) {
+                    true -> object : IEventInterface.Stub() {
+                        override fun onEvent(
+                            id: String, data: ByteArray?, isSuccess: Boolean
+                        ) {
+                            if (results[id] == null) {
+                                results[id] = mutableListOf()
+                            }
+                            results[id]?.add(data ?: byteArrayOf())
+                            if (isSuccess) {
+                                cb(results[id]?.formatString())
+                                results.remove(id)
+                            }
+                        }
                     }
+
+                    false -> null
                 }
-            })
+            )
         }
     }
 

android/common/src/main/java/com/follow/clash/common/Service.kt

@@ -44,7 +44,10 @@ class ServiceDelegate<T>(
             job = null
             _serviceState.value = null
             job = launch {
-                GlobalState.application.bindServiceFlow<IBinder>(intent).collect { handleBind(it) }
+                runCatching {
+                    GlobalState.application.bindServiceFlow<IBinder>(intent)
+                        .collect { handleBind(it) }
+                }
             }
         }
     }

android/core/src/main/cpp/core.cpp

@@ -41,9 +41,13 @@ Java_com_follow_clash_core_Core_invokeAction(JNIEnv *env, jobject thiz, jstring
 
 extern "C"
 JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_setMessageCallback(JNIEnv *env, jobject thiz, jobject cb) {
-    const auto interface = new_global(cb);
-    setMessageCallback(interface);
+Java_com_follow_clash_core_Core_setEventListener(JNIEnv *env, jobject thiz, jobject cb) {
+    if (cb != nullptr) {
+        const auto interface = new_global(cb);
+        setEventListener(interface);
+    } else {
+        setEventListener(nullptr);
+    }
 }
 
 extern "C"
@@ -169,7 +173,7 @@ Java_com_follow_clash_core_Core_updateDNS(JNIEnv *env, jobject thiz, jstring dns
 
 extern "C"
 JNIEXPORT void JNICALL
-Java_com_follow_clash_core_Core_setMessageCallback(JNIEnv *env, jobject thiz, jobject cb) {
+Java_com_follow_clash_core_Core_setEventListener(JNIEnv *env, jobject thiz, jobject cb) {
 }
 
 extern "C"

android/core/src/main/java/com/follow/clash/core/Core.kt

@@ -84,18 +84,22 @@ data object Core {
         )
     }
 
-    private external fun setMessageCallback(cb: InvokeInterface)
+    private external fun setEventListener(cb: InvokeInterface?)
 
-    fun setMessageCallback(
-        cb: (result: String?) -> Unit
+    fun callSetEventListener(
+        cb: ((result: String?) -> Unit)?
     ) {
-        setMessageCallback(
-            object : InvokeInterface {
-                override fun onResult(result: String?) {
-                    cb(result)
-                }
-            },
-        )
+        when (cb != null) {
+            true -> setEventListener(
+                object : InvokeInterface {
+                    override fun onResult(result: String?) {
+                        cb(result)
+                    }
+                },
+            )
+
+            false -> setEventListener(null)
+        }
     }
 
     external fun stopTun()

android/service/src/main/aidl/com/follow/clash/service/ICallbackInterface.aidl

@@ -2,5 +2,5 @@
 package com.follow.clash.service;
 
 interface ICallbackInterface {
-    void onResult(in byte[] data,in boolean isSuccess);
+    oneway void onResult(in byte[] data,in boolean isSuccess);
 }

android/service/src/main/aidl/com/follow/clash/service/IEventInterface.aidl

@@ -2,5 +2,5 @@
 package com.follow.clash.service;
 
 interface IEventInterface {
-    void onEvent(in String id, in byte[] data,in boolean isSuccess);
+    oneway void onEvent(in String id, in byte[] data,in boolean isSuccess);
 }

android/service/src/main/aidl/com/follow/clash/service/IResultInterface.aidl

@@ -2,5 +2,5 @@
 package com.follow.clash.service;
 
 interface IResultInterface {
-    void onResult();
+    oneway void onResult();
 }

android/service/src/main/java/com/follow/clash/service/RemoteService.kt

@@ -99,16 +99,21 @@ class RemoteService : Service(),
             handleStopService(result)
         }
 
-        override fun setEventListener(event: IEventInterface) {
-            Core.setMessageCallback {
-                runCatching {
-                    val id = UUID.randomUUID().toString()
-                    val chunks = it?.chunkedForAidl() ?: listOf()
-                    val totalSize = chunks.size
-                    chunks.forEachIndexed { index, chunk ->
-                        event.onEvent(id, chunk, totalSize - 1 == index)
+        override fun setEventListener(eventListener: IEventInterface?) {
+            GlobalState.log("isRemoveEventListener is ${eventListener == null}")
+            when (eventListener != null) {
+                true -> Core.callSetEventListener {
+                    runCatching {
+                        val id = UUID.randomUUID().toString()
+                        val chunks = it?.chunkedForAidl() ?: listOf()
+                        val totalSize = chunks.size
+                        chunks.forEachIndexed { index, chunk ->
+                            eventListener.onEvent(id, chunk, totalSize - 1 == index)
+                        }
                     }
                 }
+
+                false -> Core.callSetEventListener(null)
             }
         }
 

core/lib.go

@@ -27,7 +27,7 @@ import (
 	"unsafe"
 )
 
-var messageCallback unsafe.Pointer
+var eventListener unsafe.Pointer
 
 type TunHandler struct {
 	listener *sing_tun.Listener
@@ -202,12 +202,12 @@ func startTUN(callback unsafe.Pointer, fd C.int, stackChar, addressChar, dnsChar
 	return true
 }
 
-//export setMessageCallback
-func setMessageCallback(callback unsafe.Pointer) {
-	if messageCallback != nil {
-		releaseObject(messageCallback)
+//export setEventListener
+func setEventListener(listener unsafe.Pointer) {
+	if eventListener != nil || listener == nil {
+		releaseObject(eventListener)
 	}
-	messageCallback = callback
+	eventListener = listener
 }
 
 //export getTotalTraffic
@@ -225,12 +225,12 @@ func getTraffic(onlyStatisticsProxy bool) *C.char {
 }
 
 func sendMessage(message Message) {
-	if messageCallback == nil {
+	if eventListener == nil {
 		return
 	}
 	result := ActionResult{
 		Method:   messageMethod,
-		callback: messageCallback,
+		callback: eventListener,
 		Data:     message,
 	}
 	result.send()

lib/common/cache.dart

@@ -1,16 +1,185 @@
+import 'dart:io';
+
+import 'package:dio/dio.dart';
+import 'package:fl_clash/common/common.dart';
 import 'package:flutter_cache_manager/flutter_cache_manager.dart';
 
-class LocalImageResponse extends HttpGetResponse {
-  LocalImageResponse(super.response);
+class LocalImageCacheManager extends CacheManager {
+  static const key = 'ImageCaches';
+
+  static final LocalImageCacheManager _instance = LocalImageCacheManager._();
+
+  factory LocalImageCacheManager() {
+    return _instance;
+  }
+
+  LocalImageCacheManager._()
+    : super(Config(key, fileService: _LocalImageCacheFileService()));
+}
+
+class _LocalImageCacheFileService extends FileService {
+  _LocalImageCacheFileService();
+
+  @override
+  Future<FileServiceResponse> get(
+    String url, {
+    Map<String, String>? headers,
+  }) async {
+    final response = await request.dio.get<ResponseBody>(
+      url,
+      options: Options(headers: headers, responseType: ResponseType.stream),
+    );
+    return _LocalImageResponse(response);
+  }
+}
+
+class _LocalImageResponse implements FileServiceResponse {
+  _LocalImageResponse(this._response);
 
   final DateTime _receivedTime = DateTime.now();
 
+  final Response<ResponseBody> _response;
+
+  String? _header(String name) {
+    return _response.headers.value(name);
+  }
+
+  @override
+  int get statusCode => _response.statusCode ?? 0;
+
+  @override
+  Stream<List<int>> get content =>
+      _response.data!.stream.transform(uint8ListToListIntConverter);
+
+  @override
+  int? get contentLength => _response.data?.contentLength;
+
   @override
   DateTime get validTill {
-    final minValidTill = _receivedTime.add(const Duration(days: 7));
-    if (super.validTill.isBefore(minValidTill)) {
-      return minValidTill;
+    var ageDuration = const Duration(days: 7);
+    final controlHeader = _header(HttpHeaders.cacheControlHeader);
+    if (controlHeader != null) {
+      final controlSettings = controlHeader.split(',');
+      for (final setting in controlSettings) {
+        final sanitizedSetting = setting.trim().toLowerCase();
+        if (sanitizedSetting == 'no-cache') {
+          ageDuration = Duration.zero;
+        }
+        if (sanitizedSetting.startsWith('max-age=')) {
+          final validSeconds =
+              int.tryParse(sanitizedSetting.split('=')[1]) ?? 0;
+          if (validSeconds > 0) {
+            ageDuration = Duration(seconds: validSeconds);
+          }
+        }
+      }
     }
-    return super.validTill;
+
+    if (ageDuration > const Duration(days: 7)) {
+      return _receivedTime.add(ageDuration);
+    }
+    return _receivedTime.add(const Duration(days: 7));
+  }
+
+  @override
+  String? get eTag => _header(HttpHeaders.etagHeader);
+
+  @override
+  String get fileExtension {
+    var fileExtension = '';
+    final contentTypeHeader = _header(HttpHeaders.contentTypeHeader);
+    if (contentTypeHeader != null) {
+      final contentType = ContentType.parse(contentTypeHeader);
+      fileExtension = contentType.fileExtension;
+    }
+    return fileExtension;
   }
 }
+
+extension ContentTypeConverter on ContentType {
+  String get fileExtension => mimeTypes[mimeType] ?? '.$subType';
+}
+
+const mimeTypes = {
+  'application/vnd.android.package-archive': '.apk',
+  'application/epub+zip': '.epub',
+  'application/gzip': '.gz',
+  'application/java-archive': '.jar',
+  'application/json': '.json',
+  'application/ld+json': '.jsonld',
+  'application/msword': '.doc',
+  'application/octet-stream': '.bin',
+  'application/ogg': '.ogx',
+  'application/pdf': '.pdf',
+  'application/php': '.php',
+  'application/rtf': '.rtf',
+  'application/vnd.amazon.ebook': '.azw',
+  'application/vnd.apple.installer+xml': '.mpkg',
+  'application/vnd.mozilla.xul+xml': '.xul',
+  'application/vnd.ms-excel': '.xls',
+  'application/vnd.ms-fontobject': '.eot',
+  'application/vnd.ms-powerpoint': '.ppt',
+  'application/vnd.oasis.opendocument.presentation': '.odp',
+  'application/vnd.oasis.opendocument.spreadsheet': '.ods',
+  'application/vnd.oasis.opendocument.text': '.odt',
+  'application/vnd.openxmlformats-officedocument.presentationml.presentation':
+      '.pptx',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+      '.docx',
+  'application/vnd.rar': '.rar',
+  'application/vnd.visio': '.vsd',
+  'application/x-7z-compressed': '.7z',
+  'application/x-abiword': '.abw',
+  'application/x-bzip': '.bz',
+  'application/x-bzip2': '.bz2',
+  'application/x-csh': '.csh',
+  'application/x-freearc': '.arc',
+  'application/x-sh': '.sh',
+  'application/x-shockwave-flash': '.swf',
+  'application/x-tar': '.tar',
+  'application/xhtml+xml': '.xhtml',
+  'application/xml': '.xml',
+  'application/zip': '.zip',
+  'audio/3gpp': '.3gp',
+  'audio/3gpp2': '.3g2',
+  'audio/aac': '.aac',
+  'audio/x-aac': '.aac',
+  'audio/midi': '.midi',
+  'audio/x-midi': '.midi',
+  'audio/x-m4a': '.m4a',
+  'audio/m4a': '.m4a',
+  'audio/mpeg': '.mp3',
+  'audio/ogg': '.oga',
+  'audio/opus': '.opus',
+  'audio/wav': '.wav',
+  'audio/x-wav': '.wav',
+  'audio/webm': '.weba',
+  'font/otf': '.otf',
+  'font/ttf': '.ttf',
+  'font/woff': '.woff',
+  'font/woff2': '.woff2',
+  'image/bmp': '.bmp',
+  'image/gif': '.gif',
+  'image/jpeg': '.jpg',
+  'image/png': '.png',
+  'image/svg+xml': '.svg',
+  'image/tiff': '.tiff',
+  'image/vnd.microsoft.icon': '.ico',
+  'image/webp': '.webp',
+  'text/calendar': '.ics',
+  'text/css': '.css',
+  'text/csv': '.csv',
+  'text/html': '.html',
+  'text/javascript': '.js',
+  'text/plain': '.txt',
+  'text/xml': '.xml',
+  'video/3gpp': '.3gp',
+  'video/3gpp2': '.3g2',
+  'video/mp2t': '.ts',
+  'video/mpeg': '.mpeg',
+  'video/ogg': '.ogv',
+  'video/webm': '.webm',
+  'video/x-msvideo': '.avi',
+  'video/quicktime': '.mov',
+};

lib/views/config/general.dart

@@ -51,7 +51,7 @@ class UaItem extends ConsumerWidget {
       subtitle: Text(globalUa ?? appLocalizations.defaultText),
       delegate: OptionsDelegate<String?>(
         title: 'UA',
-        options: [null, 'clash-verge/v1.6.6', 'ClashforWindows/0.19.23'],
+        options: [null, 'clash-verge/v2.4.2', 'ClashforWindows/0.19.23'],
         value: globalUa,
         onChanged: (value) {
           ref

lib/widgets/icon.dart

@@ -2,7 +2,6 @@ import 'dart:io';
 
 import 'package:fl_clash/common/common.dart';
 import 'package:flutter/material.dart';
-import 'package:flutter_cache_manager/flutter_cache_manager.dart';
 import 'package:flutter_svg/svg.dart';
 
 class CommonTargetIcon extends StatelessWidget {
@@ -60,7 +59,7 @@ class _ImageCacheWidgetState extends State<ImageCacheWidget> {
   @override
   void initState() {
     super.initState();
-    _imageFuture = DefaultCacheManager().getSingleFile(widget.src);
+    _imageFuture = LocalImageCacheManager().getSingleFile(widget.src);
   }
 
   @override

pubspec.yaml

@@ -1,7 +1,7 @@
 name: fl_clash
 description: A multi-platform proxy client based on ClashMeta, simple and easy to use, open-source and ad-free.
 publish_to: 'none'
-version: 0.8.88+2025091701
+version: 0.8.88+2025091902
 environment:
   sdk: '>=3.8.0 <4.0.0'