Hi, I'm Jiayuan
Flutter Developer

abstract class BaseFFI {
  DynamicLibrary? _lib;

  Future<void> initializeLibrary() async {
    if (Platform.isWindows) {
      _lib = await WindowsDllLoader
          .loadDll(windowsDllName);
    } else if (Platform.isMacOS) {
      // Static lib: symbols in process
      _lib = DynamicLibrary.process();
    }
  }

  // Isolate-safe library access
  static DynamicLibrary getLibForIsolate(
    {required String dllName}
  ) => Platform.isWindows
    ? loadLibInIsolate(dllName)
    : DynamicLibrary.process();
}

// Rust: Atomic handle + minimal lock
static NEXT_HANDLE: AtomicU64 =
  AtomicU64::new(1);

pub extern "C" fn create(pid: pid_t)
  -> u64 {
  let handle = NEXT_HANDLE
    .fetch_add(1, Ordering::Relaxed);
  registry.lock().insert(handle, pid);
  handle
}

// Dart: Finalizer = Rust Drop trait
static final Finalizer _finalizer =
  Finalizer((cb) => cb());

ProcessGuard._(this._handle) {
  _finalizer.attach(this, () {
    ProcessGuardFFI.kill(_handle);
  });
}

struct IpcConnectionPool {
  connections: Arc<Mutex<
    VecDeque<IpcConnection>>>,
  semaphore: Arc<Semaphore>,
  config: PoolConfig,
}

enum RejectPolicy {
  New    = 0, // Create new connection
  Reject = 1, // Reject immediately
  Timeout= 2, // Wait with timeout
  Wait   = 3, // Wait indefinitely
}

// Global tokio runtime for pool reuse
static GLOBAL_RUNTIME:
  OnceLock<tokio::Runtime> =
  OnceLock::new();

static int get maxConcurrency {
  if (Platform.isMacOS ||
      Platform.isWindows) {
    return 36; // Desktop: high concurrency
  }
  return 20; // Mobile: Semaphore(20)
}

// Stream-based result delivery
// Android: EventChannel replaces
//   300ms polling with push
static const EventChannel
  _delayStream = EventChannel(
  'com.sail/mihomo_delay_stream'
);

// Cache: proxy name TTL=1500ms
final _cache = TimedCache<
  String, bool>(ttl: 1500);