neoagent 2.3.1-beta.6 → 2.3.1-beta.60

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