feat: added android extensions to support sensors, locations, and camera events inside actors

Author: Adriano Santos

settings.gradle.kts

@@ -17,6 +17,7 @@ rootProject.name = "synapsys"
 include("synapsys-bom")
 include("synapsys-core")
 include("synapsys-examples")
+include("synapsys-android-extensions")
 include("synapsys-store-room")
 include("synapsys-store-mysql")
 include("synapsys-store-postgres")

synapsys-android-extensions/build.gradle.kts

@@ -0,0 +1,52 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.multiplatform")
+}
+
+android {
+    namespace = "io.eigr.synapsys.extensions.android.sensors"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 21
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    buildFeatures {
+        viewBinding = true
+    }
+}
+
+kotlin {
+    androidTarget {
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+
+    jvmToolchain(17)
+
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation(project.dependencies.platform(project(":synapsys-bom")))
+                implementation(project(":synapsys-core"))
+            }
+        }
+
+        val androidMain by getting {
+            dependencies {
+                implementation("androidx.room:room-runtime")
+                implementation("androidx.room:room-ktx")
+                implementation("androidx.sqlite:sqlite-ktx")
+                //ksp("androidx.room:room-compiler")
+            }
+        }
+    }
+}

synapsys-android-extensions/src/main/kotlin/io/eigr/synapsys/extensions/android/sensors/actor/SensorActor.kt

@@ -0,0 +1,89 @@
+package io.eigr.synapsys.extensions.android.sensors.actor
+
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import io.eigr.synapsys.core.actor.Actor
+import io.eigr.synapsys.core.actor.ActorPointer
+import io.eigr.synapsys.extensions.android.sensors.events.SensorData
+import io.eigr.synapsys.extensions.android.sensors.internals.ActorHandler
+import kotlinx.coroutines.runBlocking
+import android.content.Context as AndroidContext
+import io.eigr.synapsys.core.actor.Context as ActorContext
+
+open class SensorActor<S : Any, M : SensorData>(
+    id: String,
+    initialState: S?,
+    private val androidContext: AndroidContext,
+    private val sensorType: Int,
+    private val samplingPeriod: Int = SensorManager.SENSOR_DELAY_NORMAL,
+) : Actor<S, M, Unit>(
+    id = "sensor-actor-${id}-${sensorType}",
+    initialState = initialState
+),
+    SensorEventListener {
+
+    private val sensorManager by lazy {
+        androidContext.getSystemService(AndroidContext.SENSOR_SERVICE) as SensorManager
+    }
+
+    private lateinit var targetActor: ActorPointer<*>
+
+    override fun onStart(ctx: ActorContext<S>): ActorContext<S> {
+        targetActor = ctx.system.actorOf(
+            id = "processor-$id",
+            initialState = initialState!!) {id, state -> ActorHandler(id, state) }
+
+        val sensor = sensorManager.getDefaultSensor(sensorType)
+        sensor?.let {
+            sensorManager.registerListener(this, it, samplingPeriod)
+        } ?: {
+            //ctx.system.log.error("Sensor $sensorType not available")
+        }
+
+        return ctx
+    }
+
+    override fun onStop() {
+        sensorManager.unregisterListener(this)
+    }
+
+    override fun onReceive(message: M, ctx: ActorContext<S>): Pair<ActorContext<S>, Unit> {
+        return ctx to Unit
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun onSensorChanged(event: SensorEvent) {
+        val message = when (event.sensor.type) {
+            Sensor.TYPE_ACCELEROMETER -> SensorData.AccelerometerData(
+                x = event.values[0],
+                y = event.values[1],
+                z = event.values[2],
+                timestamp = event.timestamp
+            )
+
+            Sensor.TYPE_GYROSCOPE -> SensorData.GyroscopeData(
+                x = event.values[0],
+                y = event.values[1],
+                z = event.values[2],
+                timestamp = event.timestamp
+            )
+
+            Sensor.TYPE_HEART_RATE -> SensorData.HeartRateData(
+                bpm = event.values[0],
+                timestamp = event.timestamp
+            )
+
+            else -> SensorData.RawSensorData(
+                sensorType = event.sensor.type,
+                values = event.values.copyOf(),
+                timestamp = event.timestamp
+            )
+        }
+
+        runBlocking { targetActor.send(message as M) }
+    }
+
+    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+}

synapsys-android-extensions/src/main/kotlin/io/eigr/synapsys/extensions/android/sensors/events/SensorData.kt

@@ -0,0 +1,79 @@
+package io.eigr.synapsys.extensions.android.sensors.events
+
+sealed class SensorData{
+    abstract val timestamp: Long
+
+    data class AccelerometerData(
+        val x: Float,
+        val y: Float,
+        val z: Float,
+        override val timestamp: Long
+    ) : SensorData()
+
+    data class GyroscopeData(
+        val x: Float,
+        val y: Float,
+        val z: Float,
+        override val timestamp: Long
+    ) : SensorData()
+
+    data class HeartRateData(
+        val bpm: Float,
+        override val timestamp: Long
+    ) : SensorData()
+
+    data class StepCounterData(
+        val steps: Int,
+        override val timestamp: Long
+    ) : SensorData()
+
+    data class GpsData(
+        val latitude: Double,
+        val longitude: Double,
+        val altitude: Double? = null,
+        val accuracy: Float? = null,
+        val speed: Float? = null,
+        val bearing: Float? = null,
+        override val timestamp: Long
+    ) : SensorData() {
+
+        /*override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (javaClass != other?.javaClass) return false
+
+            other as Gps
+
+            return latitude == other.latitude &&
+                    longitude == other.longitude &&
+                    altitude == other.altitude &&
+                    accuracy == other.accuracy &&
+                    speed == other.speed &&
+                    bearing == other.bearing &&
+                    timestamp == other.timestamp
+        }*/
+
+        override fun hashCode(): Int {
+            var result = latitude.hashCode()
+            result = 31 * result + longitude.hashCode()
+            result = 31 * result + (altitude?.hashCode() ?: 0)
+            result = 31 * result + (accuracy?.hashCode() ?: 0)
+            result = 31 * result + (speed?.hashCode() ?: 0)
+            result = 31 * result + (bearing?.hashCode() ?: 0)
+            result = 31 * result + timestamp.hashCode()
+            return result
+        }
+    }
+
+    data class RawSensorData(
+        val sensorType: Int,
+        val values: FloatArray,
+        override val timestamp: Long
+    ) : SensorData() {
+        override fun hashCode(): Int {
+            var result = sensorType
+            result = 31 * result + values.contentHashCode()
+            result = 31 * result + timestamp.hashCode()
+            return result
+        }
+    }
+}

synapsys-android-extensions/src/main/kotlin/io/eigr/synapsys/extensions/android/sensors/internals/ActorHandler.kt

@@ -0,0 +1,19 @@
+package io.eigr.synapsys.extensions.android.sensors.internals
+
+import io.eigr.synapsys.core.actor.Actor
+import io.eigr.synapsys.core.actor.Context
+import io.eigr.synapsys.extensions.android.sensors.actor.SensorActor
+import io.eigr.synapsys.extensions.android.sensors.events.SensorData
+
+class ActorHandler<S : Any, M : SensorData>(id: String?, initialState: S) : Actor<S, M, Unit>(id, initialState) {
+
+    private lateinit var parentActor: SensorActor<S,M>
+
+    internal fun setParentActor(parent: SensorActor<S,M>) {
+        this.parentActor = parent
+    }
+
+    override fun onReceive(message: M, ctx: Context<S>): Pair<Context<S>, Unit> {
+        return parentActor.onReceive(message, ctx)
+    }
+}

synapsys-android-extensions/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <logger name="io.eigr.synapsys" level="INFO"/>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT"/>
+    </root>
+</configuration>

synapsys-core/src/main/kotlin/io/eigr/synapsys/core/actor/Actor.kt

@@ -20,13 +20,15 @@ import io.eigr.synapsys.core.internals.store.Store
  * @see Context
  * @see Store
  */
-abstract class Actor<S : Any, M : Any, R>(val id: String?, private var initialState: S?) {
+abstract class Actor<S : Any, M : Any, R>(val id: String?, var initialState: S?) {
     private val log = loggerFor(Actor::class.java)
+    private lateinit var system: ActorSystem
+
     /**
      * Current operational context containing the actor's state.
      * Initialized with either the provided initial state or loaded from persistence.
      */
-    var state: Context<S> = Context(this.initialState)
+    var state: Context<S> = Context(this.initialState, system)
 
     private val stateClass: Class<S>? = initialState?.javaClass
 
@@ -37,6 +39,12 @@ abstract class Actor<S : Any, M : Any, R>(val id: String?, private var initialSt
      */
     internal var store: Store<S>? = null
 
+    open fun onStart(ctx: Context<S>): Context<S> {
+        return ctx
+    }
+
+    open fun onStop() {}
+
     /**
      * Core message handling method that must be implemented by concrete actors.
      *
@@ -57,10 +65,10 @@ abstract class Actor<S : Any, M : Any, R>(val id: String?, private var initialSt
         log.info("[{}] Rehydrating actor state", id)
         val oldState = store?.load(id!!, stateClass!!)
         if (oldState != null) {
-            this.state = Context(oldState)
+            this.state = Context(oldState, system)
             this.state
         } else {
-            this.state = Context(this.initialState)
+            this.state = Context(this.initialState, system)
             this.state
         }
 
@@ -75,7 +83,7 @@ abstract class Actor<S : Any, M : Any, R>(val id: String?, private var initialSt
      * @throws IllegalStateException If id is null when attempting to save state
      */
     internal suspend fun mutate(state: S): S {
-        this.state = Context(state)
+        this.state = Context(state, system)
         store?.save(id!!, state)
         return state
     }

synapsys-core/src/main/kotlin/io/eigr/synapsys/core/actor/Context.kt

@@ -12,14 +12,18 @@ package io.eigr.synapsys.core.actor
  *
  * @see Actor
  */
-class Context<S : Any>(private var internalState: S?) {
+class Context<S : Any>(private var internalState: S?, private val actorSystem : ActorSystem) {
 
     /**
      * Read-only access to the current state value.
      * Returns null if state hasn't been initialized.
      */
     val state get() = internalState
 
+
+
+    val system get() = actorSystem
+
     /**
      * Creates a new Context instance with updated state while maintaining immutability.
      * Original instance remains unchanged.