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

package/flutter_app/android/app/src/main/res/values/strings.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">NeoAgent</string>
+    <string name="widget_description">NeoAgent AI Widget</string>
+    <string name="widget_config_title">Choose AI Widget</string>
+    <string name="widget_config_empty_state">No synced widgets are available yet. Open NeoAgent and refresh widgets first.</string>
+    <string name="voice_widget_description">NeoAgent voice assistant widget</string>
+    <string name="voice_widget_title">Voice Mode</string>
+    <string name="voice_widget_subtitle">Open the voice assistant</string>
+    <string name="widget_tasks_label">Tasks</string>
+    <string name="task_run_now">Run Now</string>
+</resources>

package/flutter_app/android/app/src/main/res/values/styles.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is off -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

package/flutter_app/android/app/src/main/res/values-night/styles.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is on -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

package/flutter_app/android/app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <cache-path
+        name="app_updates"
+        path="app_updates/" />
+</paths>

package/flutter_app/android/app/src/main/res/xml/neoagent_ai_widget_info.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+    android:configure="com.neoagent.flutter_app.widgets.WidgetConfigActivity"
+    android:initialLayout="@layout/neoagent_ai_widget"
+    android:minHeight="120dp"
+    android:minWidth="220dp"
+    android:previewLayout="@layout/neoagent_ai_widget"
+    android:resizeMode="horizontal|vertical"
+    android:targetCellHeight="2"
+    android:targetCellWidth="3"
+    android:updatePeriodMillis="0"
+    android:widgetCategory="home_screen" />

package/flutter_app/android/app/src/main/res/xml/neoagent_voice_widget_info.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+    android:description="@string/voice_widget_description"
+    android:initialLayout="@layout/neoagent_voice_widget"
+    android:minHeight="72dp"
+    android:minWidth="180dp"
+    android:previewLayout="@layout/neoagent_voice_widget"
+    android:resizeMode="horizontal|vertical"
+    android:targetCellHeight="1"
+    android:targetCellWidth="2"
+    android:updatePeriodMillis="0"
+    android:widgetCategory="home_screen" />

package/flutter_app/android/app/src/profile/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- The INTERNET permission is required for development. Specifically,
+         the Flutter tool needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>

package/flutter_app/android/build.gradle.kts

@@ -0,0 +1,24 @@
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+val newBuildDir: Directory =
+    rootProject.layout.buildDirectory
+        .dir("../../build")
+        .get()
+rootProject.layout.buildDirectory.value(newBuildDir)
+
+subprojects {
+    val newSubprojectBuildDir: Directory = newBuildDir.dir(project.name)
+    project.layout.buildDirectory.value(newSubprojectBuildDir)
+}
+subprojects {
+    project.evaluationDependsOn(":app")
+}
+
+tasks.register<Delete>("clean") {
+    delete(rootProject.layout.buildDirectory)
+}

package/flutter_app/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-all.zip

package/flutter_app/android/gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
+android.useAndroidX=true
+android.enableJetifier=true

package/flutter_app/android/key.properties

@@ -0,0 +1,4 @@
+storePassword=neoagent-ci
+keyPassword=neoagent-ci
+keyAlias=neoagent-ci
+storeFile=ci-release.keystore

package/flutter_app/android/settings.gradle.kts

@@ -0,0 +1,26 @@
+pluginManagement {
+    val flutterSdkPath =
+        run {
+            val properties = java.util.Properties()
+            file("local.properties").inputStream().use { properties.load(it) }
+            val flutterSdkPath = properties.getProperty("flutter.sdk")
+            require(flutterSdkPath != null) { "flutter.sdk not set in local.properties" }
+            flutterSdkPath
+        }
+
+    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
+
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
+    id("com.android.application") version "8.9.1" apply false
+    id("org.jetbrains.kotlin.android") version "2.1.0" apply false
+}
+
+include(":app")

package/flutter_app/lib/features/location/location_service.dart

@@ -0,0 +1,119 @@
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:geolocator/geolocator.dart';
+import 'package:http/http.dart' as http;
+import 'package:shared_preferences/shared_preferences.dart';
+
+class LocationService {
+  static final LocationService _instance = LocationService._internal();
+  factory LocationService() => _instance;
+  LocationService._internal();
+
+  bool _isTracking = false;
+
+  Future<void> initialize(BuildContext context) async {
+    bool serviceEnabled = await Geolocator.isLocationServiceEnabled();
+    if (!serviceEnabled) {
+      // Location services are not enabled don't continue
+      return;
+    }
+
+    LocationPermission permission = await Geolocator.checkPermission();
+    if (permission == LocationPermission.denied) {
+      // Ask user for permission with a nice UI
+      bool userAgreed = await _showPermissionRationale(context);
+      if (userAgreed) {
+        permission = await Geolocator.requestPermission();
+      }
+    }
+
+    if (permission == LocationPermission.denied || permission == LocationPermission.deniedForever) {
+      return;
+    }
+
+    // Now request background permission if not granted
+    if (permission == LocationPermission.whileInUse) {
+      // Background location requires a separate request
+      // We could ask again with rationale
+    }
+  }
+
+  Future<bool> _showPermissionRationale(BuildContext context) async {
+    return await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+        title: const Text('Background Location Needed'),
+        content: const Text(
+          'NeoAgent uses your approximate background location to trigger geofence reminders (e.g. "Remind me to buy milk when I walk past the supermarket").\n\n'
+          'Your location is never tracked continuously or stored on our servers. We only use it locally to check against your active tasks.',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(false),
+            child: const Text('Not Now'),
+          ),
+          ElevatedButton(
+            style: ElevatedButton.styleFrom(
+              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(10)),
+            ),
+            onPressed: () => Navigator.of(context).pop(true),
+            child: const Text('Allow'),
+          ),
+        ],
+      ),
+    ) ?? false;
+  }
+
+  Future<void> startGeofenceTracking(String backendUrl, String token) async {
+    if (_isTracking) return;
+    _isTracking = true;
+
+    // This runs a periodic check. In a real app, you'd use flutter_background_service
+    // to keep this alive even when the app is swiped away.
+    // For simplicity, we just simulate a foreground loop here.
+    _trackLoop(backendUrl, token);
+  }
+
+  void _trackLoop(String backendUrl, String token) async {
+    while (_isTracking) {
+      try {
+        Position position = await Geolocator.getCurrentPosition(
+            desiredAccuracy: LocationAccuracy.low); // low accuracy = approx position
+
+        // Here we would normally fetch active geofences from local DB or backend
+        // and calculate the distance. If inside a geofence, we trigger:
+        
+        // Example logic:
+        // double distanceInMeters = Geolocator.distanceBetween(startLat, startLng, endLat, endLng);
+        // if (distanceInMeters < 100) { triggerBackend(position, label); }
+
+      } catch (e) {
+        debugPrint('Geofence tracking error: $e');
+      }
+      
+      // Check every 5 minutes
+      await Future.delayed(const Duration(minutes: 5));
+    }
+  }
+
+  Future<void> _triggerBackendGeofence(String backendUrl, String token, String label) async {
+    try {
+      await http.post(
+        Uri.parse('$backendUrl/api/triggers/geofence'),
+        headers: {
+          'Content-Type': 'application/json',
+          'Cookie': token,
+        },
+        body: jsonEncode({
+          'label': label,
+          'latitude': 0, // Sending 0 to respect privacy (approx position)
+          'longitude': 0,
+          'action': 'User entered geofence: $label'
+        }),
+      );
+    } catch (e) {
+      debugPrint('Failed to trigger geofence: $e');
+    }
+  }
+}

package/flutter_app/lib/features/notifications/notification_interceptor.dart

@@ -0,0 +1,97 @@
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+import 'package:notification_listener_service/notification_listener_service.dart';
+import 'package:notification_listener_service/notification_event.dart';
+
+class NotificationInterceptor {
+  static final NotificationInterceptor _instance = NotificationInterceptor._internal();
+  factory NotificationInterceptor() => _instance;
+  NotificationInterceptor._internal();
+
+  bool _isListening = false;
+  String _backendUrl = '';
+  String _token = '';
+
+  Future<void> initialize(BuildContext context, String backendUrl, String token) async {
+    _backendUrl = backendUrl;
+    _token = token;
+
+    bool isGranted = await NotificationListenerService.isPermissionGranted();
+    if (!isGranted) {
+      bool userAgreed = await _showPermissionRationale(context);
+      if (userAgreed) {
+        await NotificationListenerService.requestPermission();
+      }
+    }
+
+    isGranted = await NotificationListenerService.isPermissionGranted();
+    if (isGranted && !_isListening) {
+      _startListening();
+    }
+  }
+
+  Future<bool> _showPermissionRationale(BuildContext context) async {
+    return await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+        title: const Text('Notification Access Needed'),
+        content: const Text(
+          'NeoAgent can read your incoming notifications (like Calendar alarms or urgent messages) and proactively act on them.\n\n'
+          'For example, if you receive a reminder, NeoAgent can automatically prepare relevant context for you.',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(false),
+            child: const Text('Not Now'),
+          ),
+          ElevatedButton(
+            style: ElevatedButton.styleFrom(
+              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(10)),
+            ),
+            onPressed: () => Navigator.of(context).pop(true),
+            child: const Text('Allow Access'),
+          ),
+        ],
+      ),
+    ) ?? false;
+  }
+
+  void _startListening() {
+    _isListening = true;
+    NotificationListenerService.notificationsStream.listen((ServiceNotificationEvent event) {
+      // Filter out noisy system notifications or ongoing foreground services
+      if (event.packageName == null || event.packageName!.contains('android.system')) {
+        return;
+      }
+      
+      // We only want to intercept newly posted notifications, not removed ones
+      if (event.hasRemoved == true) return;
+
+      _sendToBackend(event);
+    });
+  }
+
+  Future<void> _sendToBackend(ServiceNotificationEvent event) async {
+    if (_backendUrl.isEmpty || _token.isEmpty) return;
+
+    try {
+      await http.post(
+        Uri.parse('$_backendUrl/api/triggers/notification'),
+        headers: {
+          'Content-Type': 'application/json',
+          'Cookie': _token,
+        },
+        body: jsonEncode({
+          'app_package': event.packageName ?? 'unknown',
+          'title': event.title ?? '',
+          'body': event.content ?? '',
+          'action_taken': 'intercepted',
+        }),
+      );
+    } catch (e) {
+      debugPrint('Failed to send notification to backend: $e');
+    }
+  }
+}