More

Author: cedafiso0403

android/app/src/main/kotlin/com/example/testing_application/MainActivity.kt

@@ -1,24 +1,37 @@
 package com.example.testing_application
 
+import android.annotation.SuppressLint
+import android.os.Handler
+import android.os.Looper
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.EventChannel
 import io.flutter.plugin.common.MethodChannel
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
 import java.util.*
 
 
 class MainActivity: FlutterActivity() {
 
 
     private val CHANNEL = "testing_channel"
+    private val EVENTCHANNEL = "on_device_found"
 
-    private lateinit var bluetoothController: AndroidBluetoothController
 
+    lateinit var bluetoothController: AndroidBluetoothController
+
+    @SuppressLint("MissingPermission")
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
 
         // Initialize the Bluetooth controller
         bluetoothController = AndroidBluetoothController(context)
 
+        EventChannel(flutterEngine.dartExecutor.binaryMessenger, EVENTCHANNEL).setStreamHandler(
+            OnDeviceFoundHandler(bluetoothController)
+        )
+
         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
             when (call.method) {
                 "startBluetoothDiscovery" -> {
@@ -50,13 +63,63 @@ class MainActivity: FlutterActivity() {
         }
     }
 
+    override fun onResume() {
+        super.onResume()
+    }
+
     override fun onDestroy() {
         super.onDestroy()
         // Release resources when the activity is destroyed
         bluetoothController.release()
     }
 
+    class OnDeviceFoundHandler(private val bluetoothController: AndroidBluetoothController) : EventChannel.StreamHandler {
+
+        // Declare our eventSink later it will be initialized
+        private var eventSink: EventChannel.EventSink? = null
+
+        @SuppressLint("SimpleDateFormat")
+        override fun onListen(p0: Any?, sink: EventChannel.EventSink) {
+            println("CALLED")
+            eventSink = sink
+            val customScope = CoroutineScope(Dispatchers.Default + Job())
+            var hashMap : HashMap<String?, String>
+                    = HashMap<String?, String> ()
+            val _state = MutableStateFlow(DevicesState())
+            val state = combine(bluetoothController.scannedDevices, _state) { scannedDevices, state ->
+                println("MONDAAAAA")
+                state.copy(
+                    scannedDevices = scannedDevices
+                )
+            }.stateIn(
+                scope = customScope,
+                started = SharingStarted.WhileSubscribed(5000),
+                initialValue = _state.value
+            )
+
+            val job = customScope.launch {
+                state.collect { scannedDeviceState ->
+                    scannedDeviceState.scannedDevices.forEach { device ->
+                        hashMap[device.name] = device.address
+                    }
+                    withContext(Dispatchers.Main) {
+                        eventSink?.success(hashMap)
+                    }
+                }
+            }
+
+        }
 
+        override fun onCancel(p0: Any?) {
+            eventSink = null
+        }
+    }
+
+    data class DevicesState(
+        val scannedDevices: List<BluetoothDevice> = emptyList()
+    )
 }
 
 
+
+

lib/cubit/headlessApp/headless_function.dart

@@ -1,46 +1,63 @@
+import 'dart:io';
 import 'dart:isolate';
 
 class HeadLessApp {
   SendPort? sendPort;
-
   dynamic message;
 
-  void startHeadlessTask() async {
+  void startHeadlessTask(Function startTime, Function currentTime) async {
     final ReceivePort receivePort = ReceivePort();
     final isolate = await Isolate.spawn(
       _isolateEntryPoint,
       receivePort.sendPort,
     );
 
+    startTime(DateTime.now());
+
     receivePort.listen(
       (message) {
         sendPort = message is SendPort ? message : null;
-        print('Received message: $message');
+        print('Headless Received message: $message');
+        if (message is DateTime) {
+          print("Headless Received time: $message");
+          currentTime(message);
+        }
       },
     );
 
-    sendPort?.send("Hello!");
+    sendPort?.send("Headless Hello!");
   }
 
   void sendInfoToHeadlessTask(dynamic message) {
+    print("Headless Sending message to headless isolate: $message");
     sendPort?.send(message);
   }
 
   // This function runs in the separate isolate
-  static void _isolateEntryPoint(SendPort sendPort) {
+  static void _isolateEntryPoint(
+    SendPort sendPort,
+  ) {
     final ReceivePort receivePort = ReceivePort();
     sendPort.send(receivePort.sendPort);
 
-    receivePort.listen((message) {
-      print("Received message in headless isolate: $message");
-      sendPort.send("Hello from headless isolate!");
-      // Call your headless task function here
-      myHeadlessTask();
-    });
+    receivePort.listen(
+      (message) {
+        print("Headless Received message in headless isolate: $message");
+        // Call your headless task function here
+        myHeadlessTask(sendPort);
+      },
+    );
   }
 
-  static void myHeadlessTask() {
+  static void myHeadlessTask(SendPort sendPort) {
     // Your background logic here
-    print("Headless task is running...");
+    while (true) {
+      print("Headless Time now: ${DateTime.now()}");
+      sendPort.send(DateTime.now());
+      sleep(
+        const Duration(seconds: 5),
+      );
+    }
+    ;
   }
 }

lib/cubit/test_cubit.dart

@@ -1,15 +1,18 @@
-import 'package:bloc/bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:hydrated_bloc/hydrated_bloc.dart';
 
-part 'test_state.dart';
 part 'test_cubit.freezed.dart';
+part 'test_cubit.g.dart';
+part 'test_state.dart';
 
-class TestCubit extends Cubit<TestState> {
+class TestCubit extends HydratedCubit<TestState> {
   TestCubit()
       : super(
           const TestState.initial(
             running: false,
             count: 0,
+            startTime: null,
+            currentTime: null,
           ),
         );
 
@@ -29,6 +32,22 @@ class TestCubit extends Cubit<TestState> {
     }
   }
 
+  void setStartTime(DateTime dateTime) {
+    emit(
+      state.copyWith(
+        startTime: dateTime,
+      ),
+    );
+  }
+
+  void setCurrentTime(DateTime dateTime) {
+    emit(
+      state.copyWith(
+        currentTime: dateTime,
+      ),
+    );
+  }
+
   void start() {
     emit(
       state.copyWith(
@@ -45,4 +64,10 @@ class TestCubit extends Cubit<TestState> {
       ),
     );
   }
+
+  @override
+  TestState? fromJson(Map<String, dynamic> json) => TestState.fromJson(json);
+
+  @override
+  Map<String, dynamic> toJson(TestState state) => state.toJson();
 }