neoagent 2.3.1-beta.0 → 2.3.1-beta.100

package/flutter_app/lib/src/android_app_installer_io.dart

@@ -0,0 +1,122 @@
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:http/http.dart' as http;
+import 'package:path_provider/path_provider.dart';
+
+import 'android_app_installer.dart';
+
+const MethodChannel _androidAppInstallerChannel = MethodChannel(
+  'neoagent/app_update',
+);
+
+AndroidAppInstaller createPlatformAndroidAppInstaller() =>
+    _IoAndroidAppInstaller();
+
+class _IoAndroidAppInstaller implements AndroidAppInstaller {
+  _IoAndroidAppInstaller({http.Client? client})
+    : _client = client ?? http.Client();
+
+  final http.Client _client;
+
+  @override
+  bool get supported =>
+      defaultTargetPlatform == TargetPlatform.android && !kIsWeb;
+
+  @override
+  Future<AndroidAppInstallResult> installApkFromUrl({
+    required String downloadUrl,
+    required String fileName,
+    Map<String, String> headers = const <String, String>{},
+  }) async {
+    if (!supported) {
+      return const AndroidAppInstallResult(
+        launched: false,
+        error: 'Android APK install is unavailable on this platform.',
+      );
+    }
+
+    try {
+      final canInstall = await _androidAppInstallerChannel.invokeMethod<bool>(
+        'canRequestPackageInstalls',
+      );
+      if (canInstall != true) {
+        await _androidAppInstallerChannel.invokeMethod<void>(
+          'openInstallUnknownAppsSettings',
+        );
+        return const AndroidAppInstallResult(
+          launched: false,
+          error:
+              'Allow "Install unknown apps" for NeoAgent, then retry the update.',
+        );
+      }
+
+      final apkFile = await _downloadApk(
+        downloadUrl: downloadUrl,
+        fileName: fileName,
+        headers: headers,
+      );
+      final launched = await _androidAppInstallerChannel.invokeMethod<bool>(
+        'installApk',
+        <String, dynamic>{'apkPath': apkFile.path},
+      );
+      if (launched == true) {
+        return const AndroidAppInstallResult(launched: true);
+      }
+      return const AndroidAppInstallResult(
+        launched: false,
+        error: 'Android package installer could not be opened.',
+      );
+    } on PlatformException catch (error) {
+      return AndroidAppInstallResult(
+        launched: false,
+        error: error.message ?? error.code,
+      );
+    } catch (error) {
+      return AndroidAppInstallResult(launched: false, error: error.toString());
+    }
+  }
+
+  Future<File> _downloadApk({
+    required String downloadUrl,
+    required String fileName,
+    required Map<String, String> headers,
+  }) async {
+    final request = http.Request('GET', Uri.parse(downloadUrl));
+    request.headers.addAll(headers);
+    final response = await _client.send(request);
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw HttpException(
+        'APK download failed with HTTP ${response.statusCode}.',
+        uri: Uri.parse(downloadUrl),
+      );
+    }
+
+    final directory = await getTemporaryDirectory();
+    final updatesDir = Directory('${directory.path}/app_updates');
+    if (!updatesDir.existsSync()) {
+      updatesDir.createSync(recursive: true);
+    }
+    final sanitized = _sanitizeFileName(fileName);
+    final file = File('${updatesDir.path}/$sanitized');
+    if (file.existsSync()) {
+      file.deleteSync();
+    }
+    final sink = file.openWrite();
+    try {
+      await response.stream.pipe(sink);
+    } finally {
+      await sink.close();
+    }
+    return file;
+  }
+
+  String _sanitizeFileName(String value) {
+    final trimmed = value.trim();
+    if (trimmed.isEmpty) {
+      return 'neoagent-update.apk';
+    }
+    return trimmed.replaceAll(RegExp(r'[^A-Za-z0-9._-]'), '_');
+  }
+}

package/flutter_app/lib/src/android_app_installer_stub.dart

@@ -0,0 +1,21 @@
+import 'android_app_installer.dart';
+
+AndroidAppInstaller createPlatformAndroidAppInstaller() =>
+    _UnsupportedAndroidAppInstaller();
+
+class _UnsupportedAndroidAppInstaller implements AndroidAppInstaller {
+  @override
+  bool get supported => false;
+
+  @override
+  Future<AndroidAppInstallResult> installApkFromUrl({
+    required String downloadUrl,
+    required String fileName,
+    Map<String, String> headers = const <String, String>{},
+  }) async {
+    return const AndroidAppInstallResult(
+      launched: false,
+      error: 'Android APK install is unavailable on this platform.',
+    );
+  }
+}

package/flutter_app/lib/src/android_auto_bridge.dart

@@ -0,0 +1,59 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+
+class AndroidAutoBridge {
+  AndroidAutoBridge._() {
+    if (!kIsWeb && defaultTargetPlatform == TargetPlatform.android) {
+      _autoChannel.setMethodCallHandler(_handleMethodCall);
+    }
+  }
+
+  static final AndroidAutoBridge instance = AndroidAutoBridge._();
+
+  static const MethodChannel _autoChannel = MethodChannel('neoagent/car_auto');
+  static const MethodChannel _telecomChannel = MethodChannel('neoagent/telecom');
+
+  VoidCallback? onStartVoiceMode;
+  VoidCallback? onStopVoiceMode;
+
+  Future<void> _handleMethodCall(MethodCall call) async {
+    switch (call.method) {
+      case 'startVoiceMode':
+        onStartVoiceMode?.call();
+        break;
+      case 'stopVoiceMode':
+        onStopVoiceMode?.call();
+        break;
+      default:
+        throw MissingPluginException();
+    }
+  }
+
+  Future<bool> startTelecomCallRouting() async {
+    if (!kIsWeb && defaultTargetPlatform == TargetPlatform.android) {
+      try {
+        await _telecomChannel.invokeMethod<void>('startCallRouting');
+        return true;
+      } on MissingPluginException {
+        return false;
+      } catch (e) {
+        debugPrint('startTelecomCallRouting Error: $e');
+        rethrow;
+      }
+    }
+    return false;
+  }
+
+  Future<bool> stopTelecomCallRouting() async {
+    if (!kIsWeb && defaultTargetPlatform == TargetPlatform.android) {
+      try {
+        await _telecomChannel.invokeMethod<void>('stopCallRouting');
+        return true;
+      } catch (e) {
+        debugPrint('stopTelecomCallRouting Error: $e');
+        return false;
+      }
+    }
+    return false;
+  }
+}

package/flutter_app/lib/src/android_launcher_bridge.dart

@@ -0,0 +1,239 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+
+class AndroidLauncherBridge {
+  AndroidLauncherBridge._();
+
+  static final AndroidLauncherBridge instance = AndroidLauncherBridge._();
+
+  static const MethodChannel _deviceChannel = MethodChannel(
+    'neoagent/launcher_device',
+  );
+  static const EventChannel _buttonChannel = EventChannel(
+    'neoagent/launcher_buttons',
+  );
+
+  Stream<LauncherHardwareButtonEvent>? _buttonEvents;
+
+  bool get supported =>
+      !kIsWeb && defaultTargetPlatform == TargetPlatform.android;
+
+  Future<LauncherVolumeState?> fetchVolumeState() async {
+    if (!supported) {
+      return null;
+    }
+    Map<String, dynamic>? raw;
+    try {
+      raw = await _deviceChannel.invokeMapMethod<String, dynamic>(
+        'getVolumeState',
+      );
+    } on MissingPluginException {
+      return null;
+    }
+    if (raw == null) {
+      return null;
+    }
+    return LauncherVolumeState.fromMap(raw);
+  }
+
+  Future<LauncherVolumeState?> setVolume(int value) async {
+    if (!supported) {
+      return null;
+    }
+    Map<String, dynamic>? raw;
+    try {
+      raw = await _deviceChannel.invokeMapMethod<String, dynamic>(
+        'setVolume',
+        <String, dynamic>{'value': value},
+      );
+    } on MissingPluginException {
+      return null;
+    }
+    if (raw == null) {
+      return null;
+    }
+    return LauncherVolumeState.fromMap(raw);
+  }
+
+  Future<LauncherVolumeState?> adjustVolume(int delta) async {
+    if (!supported) {
+      return null;
+    }
+    Map<String, dynamic>? raw;
+    try {
+      raw = await _deviceChannel.invokeMapMethod<String, dynamic>(
+        'adjustVolume',
+        <String, dynamic>{'delta': delta},
+      );
+    } on MissingPluginException {
+      return null;
+    }
+    if (raw == null) {
+      return null;
+    }
+    return LauncherVolumeState.fromMap(raw);
+  }
+
+  Future<bool> openWifiSettings() async {
+    if (!supported) {
+      return false;
+    }
+    try {
+      await _deviceChannel.invokeMethod<void>('openWifiSettings');
+      return true;
+    } on PlatformException {
+      return false;
+    } on MissingPluginException {
+      return false;
+    }
+  }
+
+  Future<bool> openTimeSettings() async {
+    if (!supported) {
+      return false;
+    }
+    try {
+      await _deviceChannel.invokeMethod<void>('openDateSettings');
+      return true;
+    } on PlatformException {
+      return false;
+    } on MissingPluginException {
+      try {
+        await _deviceChannel.invokeMethod<void>('openTimeSettings');
+        return true;
+      } on PlatformException {
+        return false;
+      } on MissingPluginException {
+        try {
+          await _deviceChannel.invokeMethod<void>('openSystemSettings');
+          return true;
+        } on MissingPluginException {
+          return false;
+        } on PlatformException {
+          return false;
+        }
+      }
+    }
+  }
+
+  Future<LauncherDeviceStatus?> fetchDeviceStatus() async {
+    if (!supported) {
+      return null;
+    }
+    Map<String, dynamic>? raw;
+    try {
+      raw = await _deviceChannel.invokeMapMethod<String, dynamic>(
+        'getDeviceStatus',
+      );
+    } on PlatformException {
+      return null;
+    } on MissingPluginException {
+      try {
+        raw = await _deviceChannel.invokeMapMethod<String, dynamic>(
+          'getBatteryState',
+        );
+      } on PlatformException {
+        return null;
+      } on MissingPluginException {
+        return null;
+      }
+    }
+    if (raw == null) {
+      return null;
+    }
+    return LauncherDeviceStatus.fromMap(raw);
+  }
+
+  Stream<LauncherHardwareButtonEvent> get buttonEvents {
+    return _buttonEvents ??= _buttonChannel
+        .receiveBroadcastStream()
+        .map((dynamic event) {
+          final map = event is Map
+              ? Map<String, dynamic>.from(event)
+              : const <String, dynamic>{};
+          return LauncherHardwareButtonEvent.fromMap(map);
+        })
+        .handleError((Object error, StackTrace stackTrace) {},
+            test: (error) => error is MissingPluginException);
+  }
+}
+
+@immutable
+class LauncherVolumeState {
+  const LauncherVolumeState({
+    required this.current,
+    required this.max,
+    required this.min,
+    required this.muted,
+  });
+
+  factory LauncherVolumeState.fromMap(Map<String, dynamic> map) {
+    return LauncherVolumeState(
+      current: (map['current'] as num?)?.round() ?? 0,
+      max: (map['max'] as num?)?.round() ?? 0,
+      min: (map['min'] as num?)?.round() ?? 0,
+      muted: map['muted'] == true,
+    );
+  }
+
+  final int current;
+  final int max;
+  final int min;
+  final bool muted;
+
+  double get normalized {
+    final span = max - min;
+    if (span <= 0) {
+      return 0;
+    }
+    return ((current - min) / span).clamp(0, 1).toDouble();
+  }
+}
+
+@immutable
+class LauncherHardwareButtonEvent {
+  const LauncherHardwareButtonEvent({
+    required this.keyCode,
+    required this.scanCode,
+    required this.action,
+    required this.repeatCount,
+    required this.eventTimeMs,
+  });
+
+  factory LauncherHardwareButtonEvent.fromMap(Map<String, dynamic> map) {
+    return LauncherHardwareButtonEvent(
+      keyCode: (map['keyCode'] as num?)?.round() ?? 0,
+      scanCode: (map['scanCode'] as num?)?.round() ?? 0,
+      action: (map['action'] ?? 'unknown').toString(),
+      repeatCount: (map['repeatCount'] as num?)?.round() ?? 0,
+      eventTimeMs: (map['eventTimeMs'] as num?)?.toInt() ?? 0,
+    );
+  }
+
+  final int keyCode;
+  final int scanCode;
+  final String action;
+  final int repeatCount;
+  final int eventTimeMs;
+
+  bool get isDown => action == 'down';
+
+  bool get isUp => action == 'up';
+}
+
+@immutable
+class LauncherDeviceStatus {
+  const LauncherDeviceStatus({required this.batteryPercent, required this.charging});
+
+  factory LauncherDeviceStatus.fromMap(Map<String, dynamic> map) {
+    return LauncherDeviceStatus(
+      batteryPercent: (map['batteryPercent'] as num?)?.round(),
+      charging: map['charging'] == true,
+    );
+  }
+
+  final int? batteryPercent;
+  final bool charging;
+}

package/flutter_app/lib/src/app_launch_bridge.dart

@@ -0,0 +1,58 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+
+class AppLaunchRequest {
+  const AppLaunchRequest({
+    required this.action,
+    this.text,
+    this.subject,
+    this.files = const <Map<String, dynamic>>[],
+  });
+
+  factory AppLaunchRequest.fromEvent(dynamic event) {
+    if (event is Map) {
+      final map = Map<String, dynamic>.from(event);
+      final files = (map['files'] is List)
+          ? (map['files'] as List)
+                .whereType<Map>()
+                .map((item) => Map<String, dynamic>.from(item))
+                .toList()
+          : const <Map<String, dynamic>>[];
+      return AppLaunchRequest(
+        action: map['action']?.toString() ?? '',
+        text: map['text']?.toString(),
+        subject: map['subject']?.toString(),
+        files: files,
+      );
+    }
+    return AppLaunchRequest(action: event?.toString() ?? '');
+  }
+
+  final String action;
+  final String? text;
+  final String? subject;
+  final List<Map<String, dynamic>> files;
+}
+
+class AppLaunchBridge {
+  static const String voiceAssistantAction = 'voice_assistant';
+  static const String shareToChatAction = 'share_to_chat';
+  static const EventChannel _events = EventChannel(
+    'neoagent/app_launch/events',
+  );
+
+  static Stream<AppLaunchRequest>? _launchRequests;
+
+  Stream<AppLaunchRequest> get launchRequests {
+    if (!_isAndroid) {
+      return const Stream<AppLaunchRequest>.empty();
+    }
+    return _launchRequests ??= _events
+        .receiveBroadcastStream()
+        .map(AppLaunchRequest.fromEvent)
+        .where((request) => request.action.trim().isNotEmpty);
+  }
+
+  bool get _isAndroid =>
+      !kIsWeb && defaultTargetPlatform == TargetPlatform.android;
+}