react-native-flic2 0.3.26 → 2.0.0-alpha.39

package/android/build.gradle

@@ -1,149 +1,81 @@
-// android/build.gradle
-
-// based on:
-//
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/build.gradle
-//
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/app/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/app/build.gradle
-
-def DEFAULT_COMPILE_SDK_VERSION = 28
-def DEFAULT_BUILD_TOOLS_VERSION = '28.0.3'
-def DEFAULT_MIN_SDK_VERSION = 23
-def DEFAULT_TARGET_SDK_VERSION = 28
-
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-}
-
 buildscript {
-    // The Android Gradle plugin is only required when opening the android folder stand-alone.
-    // This avoids unnecessary downloads and potential conflicts when the library is included as a
-    // module dependency in an application project.
-    // ref: https://docs.gradle.org/current/userguide/tutorial_using_tasks.html#sec:build_script_external_dependencies
-    if (project == rootProject) {
-        repositories {
-            google()
-        }
-        dependencies {
-            classpath 'com.android.tools.build:gradle:3.4.1'
-        }
-    }
-}
-
-apply plugin: 'com.android.library'
-apply plugin: 'maven-publish'
-
-android {
-    compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
-    buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
-    defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
-        targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
-        versionCode 1
-        versionName "1.0"
-    }
-    lintOptions {
-        abortOnError false
-    }
-}
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Flic2_' + name]
+  }
 
-repositories {
-    // ref: https://www.baeldung.com/maven-local-repository
-    mavenLocal()
-    maven {
-        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-        url "$rootDir/../node_modules/react-native/android"
-    }
-    maven {
-        // Android JSC is installed from npm
-        url "$rootDir/../node_modules/jsc-android/dist"
-    }
-    maven { url 'https://jitpack.io' }
+  repositories {
     google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
 }
 
-dependencies {
-    //noinspection GradleDynamicVersion
-    implementation 'com.facebook.react:react-native:+'  // From node_modules
-    implementation 'com.github.50ButtonsEach:flic2lib-android:1.3.1'
 
-    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
-    implementation 'io.reactivex.rxjava2:rxjava:2.2.13'
-}
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
 
-def configureReactNativePom(def pom) {
-    def packageJson = new groovy.json.JsonSlurper().parseText(file('../package.json').text)
-
-    pom.project {
-        name packageJson.title
-        artifactId packageJson.name
-        version = packageJson.version
-        group = "nl.xguard.flic2"
-        description packageJson.description
-        url packageJson.repository.baseUrl
-
-        licenses {
-            license {
-                name packageJson.license
-                url packageJson.repository.baseUrl + '/blob/master/' + packageJson.licenseFilename
-                distribution 'repo'
-            }
-        }
-
-        developers {
-            developer {
-                id packageJson.author
-                name packageJson.author
-            }
-        }
-    }
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Flic2_" + name]).toInteger()
 }
 
-afterEvaluate { project ->
-    // some Gradle build hooks ref:
-    // https://www.oreilly.com/library/view/gradle-beyond-the/9781449373801/ch03.html
-    task androidJavadoc(type: Javadoc) {
-        source = android.sourceSets.main.java.srcDirs
-        classpath += files(android.bootClasspath)
-        project.getConfigurations().getByName('implementation').setCanBeResolved(true)
-        classpath += files(project.getConfigurations().getByName('implementation').asList())
-        include '**/*.java'
-    }
+android {
+  namespace "com.flic2"
 
-    task androidJavadocJar(type: Jar, dependsOn: androidJavadoc) {
-        classifier = 'javadoc'
-        from androidJavadoc.destinationDir
-    }
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
-    task androidSourcesJar(type: Jar) {
-        classifier = 'sources'
-        from android.sourceSets.main.java.srcDirs
-        include '**/*.java'
-    }
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
 
-    android.libraryVariants.all { variant ->
-        def name = variant.name.capitalize()
-        def javaCompileTask = variant.javaCompileProvider.get()
+  buildFeatures {
+    buildConfig true
+  }
 
-        task "jar${name}"(type: Jar, dependsOn: javaCompileTask) {
-            from javaCompileTask.destinationDir
-        }
+  buildTypes {
+    release {
+      minifyEnabled false
     }
-
-    artifacts {
-        archives androidSourcesJar
-        archives androidJavadocJar
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
     }
+  }
+}
 
-   publishing {
-        repositories {
-            maven {
-                url = uri("${rootProject.projectDir}/maven-repo")
-            }
-        }
-   }
+repositories {
+  mavenCentral()
+  google()
+  maven { url 'https://jitpack.io' }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation 'com.github.50ButtonsEach:flic2lib-android:1.+'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
 }

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Flic2_kotlinVersion=2.0.21
+Flic2_minSdkVersion=24
+Flic2_targetSdkVersion=34
+Flic2_compileSdkVersion=35
+Flic2_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -1,39 +1,27 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="nl.xguard.flic2">
+    xmlns:tools="http://schemas.android.com/tools">
 
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <!-- Bluetooth permissions for API < 31 -->
+    <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />
+
+    <!-- Bluetooth permissions for API >= 31 -->
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN"
+        android:usesPermissionFlags="neverForLocation"
+        tools:targetApi="s" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+
+    <!-- Foreground service permission -->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" />
 
     <application>
         <service
-            android:name="nl.xguard.flic2.service.Flic2Service"
-            android:enabled="true"
-            android:exported="false" />
-
-        <receiver
-            android:name="nl.xguard.flic2.service.Flic2Service$BootUpReceiver"
-            android:enabled="true"
-            android:permission="android.permission.RECEIVE_BOOT_COMPLETED"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-                <category android:name="android.intent.category.DEFAULT" />
-            </intent-filter>
-        </receiver>
-
-        <receiver
-            android:name="nl.xguard.flic2.service.Flic2Service$UpdateReceiver"
+            android:name=".Flic2Service"
             android:enabled="true"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="android.intent.action.PACKAGE_REPLACED" />
-                <data
-                    android:path="nl.xguard.flic2"
-                    android:scheme="package" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </receiver>
+            android:exported="false"
+            android:foregroundServiceType="connectedDevice" />
     </application>
 
 </manifest>

package/android/src/main/java/com/flic2/Flic2ButtonListener.kt

@@ -0,0 +1,132 @@
+package com.flic2
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import io.flic.flic2libandroid.BatteryLevel
+import io.flic.flic2libandroid.Flic2Button
+import io.flic.flic2libandroid.Flic2ButtonListener
+
+class Flic2ButtonEventListener(
+    private val emitEvent: (WritableMap) -> Unit
+) : Flic2ButtonListener() {
+
+    // Map Android library's onConnect() to emit "connected" (matches iOS)
+    override fun onConnect(button: Flic2Button) {
+        emitEvent(createButtonEvent(button, "connected"))
+    }
+
+    // Map Android library's onReady() to emit "ready" (matches iOS)
+    override fun onReady(button: Flic2Button, timestamp: Long) {
+        emitEvent(createButtonEvent(button, "ready"))
+    }
+
+    // Map Android library's onDisconnect() to emit "disconnected" (matches iOS)
+    override fun onDisconnect(button: Flic2Button) {
+        emitEvent(createButtonEvent(button, "disconnected"))
+    }
+
+    // Map Android library's onFailure() to emit "connectionFailed" (matches iOS)
+    override fun onFailure(button: Flic2Button, errorCode: Int, subCode: Int) {
+        emitEvent(createButtonEvent(button, "connectionFailed").apply {
+            putMap("error", Arguments.createMap().apply {
+                putInt("code", errorCode)
+                putInt("subCode", subCode)
+                putString("message", "Connection failed: code=$errorCode, subCode=$subCode")
+            })
+        })
+    }
+
+    override fun onButtonUpOrDown(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isUp: Boolean,
+        isDown: Boolean
+    ) {
+        val event = if (isDown) "buttonDown" else "buttonUp"
+        emitEvent(createButtonEvent(button, event).apply {
+            putBoolean("queued", wasQueued)
+            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
+        })
+    }
+
+    override fun onButtonClickOrHold(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isClick: Boolean,
+        isHold: Boolean
+    ) {
+        val event = if (isClick) "click" else "hold"
+        emitEvent(createButtonEvent(button, event).apply {
+            putBoolean("queued", wasQueued)
+            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
+        })
+    }
+
+    override fun onButtonSingleOrDoubleClick(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isSingleClick: Boolean,
+        isDoubleClick: Boolean
+    ) {
+        val event = if (isSingleClick) "click" else "doubleClick"
+        emitEvent(createButtonEvent(button, event).apply {
+            putBoolean("queued", wasQueued)
+            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
+        })
+    }
+
+    override fun onButtonSingleOrDoubleClickOrHold(
+        button: Flic2Button,
+        wasQueued: Boolean,
+        lastQueued: Boolean,
+        timestamp: Long,
+        isSingleClick: Boolean,
+        isDoubleClick: Boolean,
+        isHold: Boolean
+    ) {
+        val event = when {
+            isSingleClick -> "click"
+            isDoubleClick -> "doubleClick"
+            isHold -> "hold"
+            else -> "unknown"
+        }
+        emitEvent(createButtonEvent(button, event).apply {
+            putBoolean("queued", wasQueued)
+            putDouble("age", System.currentTimeMillis() - timestamp.toDouble())
+        })
+    }
+
+    // Map Android library's onUnpaired() to emit "unpaired" (matches iOS)
+    override fun onUnpaired(button: Flic2Button) {
+        emitEvent(createButtonEvent(button, "unpaired"))
+    }
+
+    // Map Android library's onBatteryLevelUpdated() to emit "batteryUpdate" (matches iOS)
+    override fun onBatteryLevelUpdated(button: Flic2Button, level: BatteryLevel) {
+        emitEvent(createButtonEvent(button, "batteryUpdate").apply {
+            putDouble("voltage", level.voltage.toDouble())
+        })
+    }
+
+    // Map Android library's onNameUpdated() to emit "nicknameUpdate" (matches iOS)
+    override fun onNameUpdated(button: Flic2Button, newName: String) {
+        emitEvent(createButtonEvent(button, "nicknameUpdate").apply {
+            putString("nickname", newName)
+        })
+    }
+
+    private fun createButtonEvent(button: Flic2Button, event: String): WritableMap {
+        return Arguments.createMap().apply {
+            putString("uuid", button.uuid)
+            putString("event", event)
+            putMap("button", Flic2Converter.buttonToMap(button))
+        }
+    }
+}
+

package/android/src/main/java/com/flic2/Flic2Converter.kt

@@ -0,0 +1,103 @@
+package com.flic2
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import io.flic.flic2libandroid.Flic2Button
+
+object Flic2Converter {
+
+    fun buttonToMap(button: Flic2Button): WritableMap {
+        return Arguments.createMap().apply {
+            putString("uuid", button.uuid)
+            putString("identifier", button.uuid) // Android uses UUID as identifier
+            putString("name", button.getName() ?: "")
+            putString("nickname", button.getName() ?: "")
+            putString("bluetoothAddress", button.getBdAddr() ?: "")
+            putString("serialNumber", button.getSerialNumber() ?: "")
+
+            // Use connection state constants instead of enum
+            val connState = button.getConnectionState()
+            putInt("state", connectionStateToInt(connState))
+            putString("stateName", connectionStateToString(connState))
+
+            // iOS-only: Return defaults for trigger/latency mode (not supported in Android v1.1.0+)
+            putInt("triggerMode", 0)
+            putString("triggerModeName", "")
+            putInt("latencyMode", 0)
+            putString("latencyModeName", "")
+
+            putInt("pressCount", button.getPressCount())
+            putInt("firmwareRevision", button.getFirmwareVersion())
+
+            // Check if ready by comparing connection state
+            val isReady = connState == Flic2Button.CONNECTION_STATE_CONNECTED_READY
+            putBoolean("isReady", isReady)
+
+            // Get battery level from BatteryLevel object
+            val batteryLevel = button.getLastKnownBatteryLevel()
+            putDouble("batteryVoltage", batteryLevel?.voltage?.toDouble() ?: 0.0)
+
+            putBoolean("isUnpaired", button.isUnpaired())
+        }
+    }
+
+    fun buttonsToArray(buttons: List<Flic2Button>): WritableArray {
+        return Arguments.createArray().apply {
+            buttons.forEach { button ->
+                pushMap(buttonToMap(button))
+            }
+        }
+    }
+
+    private fun connectionStateToInt(state: Int): Int {
+        return when (state) {
+            Flic2Button.CONNECTION_STATE_DISCONNECTED -> 0
+            Flic2Button.CONNECTION_STATE_CONNECTING -> 1
+            Flic2Button.CONNECTION_STATE_CONNECTED_STARTING -> 2
+            Flic2Button.CONNECTION_STATE_CONNECTED_READY -> 3
+            else -> 0
+        }
+    }
+
+    private fun connectionStateToString(state: Int): String {
+        return when (state) {
+            Flic2Button.CONNECTION_STATE_DISCONNECTED -> "disconnected"
+            Flic2Button.CONNECTION_STATE_CONNECTING -> "connecting"
+            Flic2Button.CONNECTION_STATE_CONNECTED_STARTING -> "connected"
+            Flic2Button.CONNECTION_STATE_CONNECTED_READY -> "connected"
+            else -> "disconnected"
+        }
+    }
+
+    // Trigger mode and latency mode are iOS-only features (removed from Android library v1.1.0+)
+
+    fun scanResultToString(result: Int): String {
+        return when (result) {
+            0 -> "success"
+            1 -> "alreadyRunning"
+            2 -> "bluetoothNotActivated"
+            3 -> "unknown"
+            4 -> "noPublicButtonDiscovered"
+            5 -> "alreadyConnectedToAnotherDevice"
+            6 -> "connectionTimeout"
+            7 -> "invalidVerifier"
+            8 -> "blePairingFailedPreviousPairingAlreadyExisting"
+            9 -> "blePairingFailedUserCanceled"
+            10 -> "blePairingFailedUnknownReason"
+            11 -> "appCredentialsDontMatch"
+            12 -> "userCanceled"
+            13 -> "invalidBluetoothAddress"
+            14 -> "genuineCheckFailed"
+            15 -> "tooManyApps"
+            16 -> "couldNotSetBluetoothNotify"
+            17 -> "couldNotDiscoverBluetoothServices"
+            18 -> "buttonDisconnectedDuringVerification"
+            19 -> "failedToEstablish"
+            20 -> "connectionLimitReached"
+            21 -> "notInPublicMode"
+            else -> "unknown"
+        }
+    }
+}
+