neoagent 2.3.1-beta.2 → 2.3.1-beta.21

package/flutter_app/lib/src/android_apk_drop_zone.dart

@@ -0,0 +1,32 @@
+import 'dart:typed_data';
+
+import 'package:flutter/widgets.dart';
+
+import 'android_apk_drop_zone_stub.dart'
+    if (dart.library.html) 'android_apk_drop_zone_web.dart';
+
+typedef AndroidApkInstallCallback =
+    Future<void> Function({required String filename, required Uint8List bytes});
+
+class AndroidApkDropZone extends StatelessWidget {
+  const AndroidApkDropZone({
+    super.key,
+    required this.enabled,
+    required this.busy,
+    required this.onInstall,
+  });
+
+  final bool enabled;
+  final bool busy;
+  final AndroidApkInstallCallback onInstall;
+
+  @override
+  Widget build(BuildContext context) {
+    return buildAndroidApkDropZone(
+      context,
+      enabled: enabled,
+      busy: busy,
+      onInstall: onInstall,
+    );
+  }
+}

package/flutter_app/lib/src/android_apk_drop_zone_stub.dart

@@ -0,0 +1,16 @@
+import 'dart:typed_data';
+
+import 'package:flutter/widgets.dart';
+
+Widget buildAndroidApkDropZone(
+  BuildContext context, {
+  required bool enabled,
+  required bool busy,
+  required Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall,
+}) {
+  return const SizedBox.shrink();
+}

package/flutter_app/lib/src/android_apk_drop_zone_web.dart

@@ -0,0 +1,348 @@
+// ignore_for_file: avoid_web_libraries_in_flutter, deprecated_member_use
+
+import 'dart:async';
+import 'dart:html' as html;
+import 'dart:typed_data';
+import 'dart:ui_web' as ui_web;
+
+import 'package:flutter/material.dart';
+
+int _androidApkDropZoneViewId = 0;
+const Set<String> _supportedAndroidInstallExtensions = <String>{
+  '.apk',
+  '.apks',
+};
+
+Widget buildAndroidApkDropZone(
+  BuildContext context, {
+  required bool enabled,
+  required bool busy,
+  required Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall,
+}) {
+  return _AndroidApkDropZoneWeb(
+    enabled: enabled,
+    busy: busy,
+    onInstall: onInstall,
+  );
+}
+
+class _AndroidApkDropZoneWeb extends StatefulWidget {
+  const _AndroidApkDropZoneWeb({
+    required this.enabled,
+    required this.busy,
+    required this.onInstall,
+  });
+
+  final bool enabled;
+  final bool busy;
+  final Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall;
+
+  @override
+  State<_AndroidApkDropZoneWeb> createState() => _AndroidApkDropZoneWebState();
+}
+
+class _AndroidApkDropZoneWebState extends State<_AndroidApkDropZoneWeb> {
+  late final String _viewType;
+  late final html.DivElement _dropElement;
+  late final html.FileUploadInputElement _fileInput;
+  final List<StreamSubscription<dynamic>> _subscriptions =
+      <StreamSubscription<dynamic>>[];
+  bool _dragActive = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _viewType = 'neoagent-android-apk-drop-zone-${_androidApkDropZoneViewId++}';
+    _dropElement = html.DivElement()
+      ..setAttribute('role', 'button')
+      ..setAttribute(
+        'aria-label',
+        'Drop an APK or APK bundle here to install it',
+      )
+      ..tabIndex = 0
+      ..style.width = '100%'
+      ..style.height = '100%'
+      ..style.display = 'block'
+      ..style.background = 'rgba(0, 0, 0, 0.001)'
+      ..style.cursor = 'pointer';
+    _fileInput = html.FileUploadInputElement()
+      ..accept = '.apk,.apks'
+      ..multiple = false
+      ..style.display = 'none';
+    _dropElement.append(_fileInput);
+
+    _subscriptions.addAll(<StreamSubscription<dynamic>>[
+      _dropElement.onClick.listen((_) => _openPicker()),
+      _dropElement.onKeyDown.listen((event) {
+        if (event.key == 'Enter' || event.key == ' ') {
+          event.preventDefault();
+          _openPicker();
+        }
+      }),
+      _dropElement.onDragEnter.listen((event) {
+        event.preventDefault();
+        if (!_dragActive && mounted) {
+          setState(() => _dragActive = true);
+        }
+      }),
+      _dropElement.onDragOver.listen((event) {
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'copy';
+        if (!_dragActive && mounted) {
+          setState(() => _dragActive = true);
+        }
+      }),
+      _dropElement.onDragLeave.listen((event) {
+        event.preventDefault();
+        if (_dragActive && mounted) {
+          setState(() => _dragActive = false);
+        }
+      }),
+      _dropElement.onDrop.listen((event) {
+        event.preventDefault();
+        if (_dragActive && mounted) {
+          setState(() => _dragActive = false);
+        }
+        final files = event.dataTransfer.files;
+        if (files == null || files.isEmpty) {
+          return;
+        }
+        unawaited(_handleFile(files.first));
+      }),
+      _fileInput.onChange.listen((_) {
+        final files = _fileInput.files;
+        if (files == null || files.isEmpty) {
+          return;
+        }
+        unawaited(_handleFile(files.first));
+      }),
+    ]);
+
+    ui_web.platformViewRegistry.registerViewFactory(_viewType, (int _) {
+      return _dropElement;
+    });
+  }
+
+  @override
+  void dispose() {
+    for (final subscription in _subscriptions) {
+      subscription.cancel();
+    }
+    _dropElement.remove();
+    super.dispose();
+  }
+
+  void _openPicker() {
+    if (!widget.enabled || widget.busy) {
+      return;
+    }
+    _fileInput.value = '';
+    _fileInput.click();
+  }
+
+  Future<void> _handleFile(html.File file) async {
+    if (!widget.enabled || widget.busy) {
+      return;
+    }
+    if (!_isSupportedInstallFile(file.name)) {
+      _showError('Only .apk or .apks files can be installed.');
+      return;
+    }
+    try {
+      final bytes = await _readFileBytes(file);
+      if (!mounted) {
+        return;
+      }
+      await widget.onInstall(filename: file.name, bytes: bytes);
+    } catch (error) {
+      _showError(error.toString().replaceFirst('Exception: ', ''));
+    }
+  }
+
+  Future<Uint8List> _readFileBytes(html.File file) {
+    final completer = Completer<Uint8List>();
+    final reader = html.FileReader();
+    reader.onLoad.listen((_) {
+      final result = reader.result;
+      if (result is ByteBuffer) {
+        completer.complete(Uint8List.view(result));
+        return;
+      }
+      if (result is Uint8List) {
+        completer.complete(result);
+        return;
+      }
+      if (!completer.isCompleted) {
+        completer.completeError(
+          StateError('Could not read the Android app package.'),
+        );
+      }
+    });
+    reader.onError.listen((_) {
+      if (!completer.isCompleted) {
+        completer.completeError(
+          reader.error ?? StateError('Could not read the Android app package.'),
+        );
+      }
+    });
+    reader.readAsArrayBuffer(file);
+    return completer.future;
+  }
+
+  void _showError(String message) {
+    if (!mounted) {
+      return;
+    }
+    final messenger = ScaffoldMessenger.maybeOf(context);
+    if (messenger == null) {
+      return;
+    }
+    messenger.showSnackBar(SnackBar(content: Text(message)));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+    final cardColor = theme.cardTheme.color ?? colorScheme.surface;
+    final onSurface = colorScheme.onSurface;
+    final outline = colorScheme.outlineVariant;
+    final primary = colorScheme.primary;
+    final activeBorderColor = _dragActive ? primary : outline;
+    final background = _dragActive
+        ? primary.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.14 : 0.10,
+          )
+        : widget.enabled
+        ? cardColor
+        : colorScheme.surfaceContainerHighest.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.84 : 0.92,
+          );
+    final iconBackground = _dragActive
+        ? primary.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.18 : 0.14,
+          )
+        : colorScheme.surfaceContainerHighest.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.72 : 0.92,
+          );
+    final titleColor = onSurface;
+    final subtitleColor = colorScheme.onSurfaceVariant;
+    final dropZoneBorderColor = _dragActive ? primary : outline;
+    final dropZoneBackground = _dragActive
+        ? primary.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.10 : 0.08,
+          )
+        : colorScheme.surface.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.18 : 0.72,
+          );
+    final subtitle = widget.busy
+        ? 'Installing app package on the phone...'
+        : widget.enabled
+        ? 'Drag and drop a .apk or .apks file here, or click to browse.'
+        : 'Start the Android phone first, then drop a .apk or .apks file here.';
+
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.all(14),
+      decoration: BoxDecoration(
+        color: background,
+        borderRadius: BorderRadius.circular(18),
+        border: Border.all(color: activeBorderColor),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: <Widget>[
+          Row(
+            children: <Widget>[
+              Container(
+                width: 38,
+                height: 38,
+                decoration: BoxDecoration(
+                  color: iconBackground,
+                  borderRadius: BorderRadius.circular(12),
+                ),
+                child: Icon(
+                  Icons.install_mobile_outlined,
+                  color: _dragActive ? primary : titleColor,
+                ),
+              ),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: <Widget>[
+                    Text(
+                      'Install APK / Bundle',
+                      style: theme.textTheme.titleMedium?.copyWith(
+                        color: titleColor,
+                        fontWeight: FontWeight.w700,
+                      ),
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      subtitle,
+                      style: theme.textTheme.bodyMedium?.copyWith(
+                        color: subtitleColor,
+                        height: 1.4,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+          const SizedBox(height: 12),
+          SizedBox(
+            height: 92,
+            child: Stack(
+              children: <Widget>[
+                Positioned.fill(
+                  child: DecoratedBox(
+                    decoration: BoxDecoration(
+                      borderRadius: BorderRadius.circular(14),
+                      border: Border.all(color: dropZoneBorderColor),
+                      color: dropZoneBackground,
+                    ),
+                    child: Center(
+                      child: Text(
+                        widget.busy
+                            ? 'Installing...'
+                            : _dragActive
+                            ? 'Release to install this package'
+                            : 'Drop APK or .apks Here',
+                        style: theme.textTheme.titleSmall?.copyWith(
+                          color: titleColor,
+                          fontWeight: FontWeight.w700,
+                          letterSpacing: 0.2,
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+                Positioned.fill(
+                  child: ClipRRect(
+                    borderRadius: BorderRadius.circular(14),
+                    child: HtmlElementView(viewType: _viewType),
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+bool _isSupportedInstallFile(String filename) {
+  final normalized = filename.toLowerCase();
+  return _supportedAndroidInstallExtensions.any(normalized.endsWith);
+}

package/flutter_app/lib/src/android_app_installer.dart

@@ -0,0 +1,22 @@
+import 'android_app_installer_stub.dart'
+    if (dart.library.io) 'android_app_installer_io.dart';
+
+AndroidAppInstaller createAndroidAppInstaller() =>
+    createPlatformAndroidAppInstaller();
+
+abstract class AndroidAppInstaller {
+  bool get supported;
+
+  Future<AndroidAppInstallResult> installApkFromUrl({
+    required String downloadUrl,
+    required String fileName,
+    Map<String, String> headers = const <String, String>{},
+  });
+}
+
+class AndroidAppInstallResult {
+  const AndroidAppInstallResult({required this.launched, this.error});
+
+  final bool launched;
+  final String? error;
+}

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.',
+    );
+  }
+}