Merge pull request #8 from plgd-dev/androidsupport

support android

Author: ondrejtomcik

.gitignore

@@ -115,3 +115,5 @@ app.*.symbols
 
 # OCF Client
 **/ios/Frameworks/OCFClient.framework/*
+**/android/app/libs/*.jar
+**/android/app/libs/*.aar

android/app/build.gradle

@@ -25,6 +25,12 @@ apply plugin: 'com.android.application'
 apply plugin: 'kotlin-android'
 apply from: "$flutterRoot/packages/flutter_tools/gradle/flutter.gradle"
 
+def keystoreProperties = new Properties()
+def keystorePropertiesFile = rootProject.file('key.properties')
+if (keystorePropertiesFile.exists()) {
+    keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
+}
+
 android {
     compileSdkVersion 29
 
@@ -37,7 +43,6 @@ android {
     }
 
     defaultConfig {
-        // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
         applicationId "dev.plgd.client"
         minSdkVersion 16
         targetSdkVersion 29
@@ -46,11 +51,18 @@ android {
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
+    signingConfigs {
+       release {
+           keyAlias keystoreProperties['keyAlias']
+           keyPassword keystoreProperties['keyPassword']
+           storeFile keystoreProperties['storeFile'] ? file(keystoreProperties['storeFile']) : null
+           storePassword keystoreProperties['storePassword']
+       }
+   }
+
     buildTypes {
         release {
-            // TODO: Add your own signing config for the release build.
-            // Signing with the debug keys for now, so `flutter run --release` works.
-            signingConfig signingConfigs.debug
+            signingConfig signingConfigs.release
         }
     }
 }
@@ -68,6 +80,7 @@ repositories {
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation (name:'ocfclient', ext:'aar')
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1'
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'androidx.test:runner:1.1.1'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'

android/app/src/debug/AndroidManifest.xml

@@ -1,7 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="dev.plgd.client">
-    <!-- Flutter 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>

android/app/src/main/AndroidManifest.xml

@@ -1,10 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="dev.plgd.client">
-    <!-- io.flutter.app.FlutterApplication is an android.app.Application that
-         calls FlutterMain.startInitialization(this); in its onCreate method.
-         In most cases you can leave this as-is, but you if you want to provide
-         additional functionality it is fine to subclass or reimplement
-         FlutterApplication and put your custom class here. -->
     <application
         android:name="io.flutter.app.FlutterApplication"
         android:label="plgd"
@@ -21,8 +16,6 @@
                 <category android:name="android.intent.category.LAUNCHER"/>
             </intent-filter>
         </activity>
-        <!-- Don't delete the meta-data below.
-             This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
         <meta-data
             android:name="flutterEmbedding"
             android:value="2" />

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

@@ -0,0 +1,127 @@
+package dev.plgd.client
+
+import androidx.annotation.NonNull
+import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugins.GeneratedPluginRegistrant
+import io.flutter.plugin.common.MethodChannel
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class MainActivity: FlutterActivity() {
+    private val CHANNEL = "plgd.dev/client"
+    private var sdkClient: ocfclient.Ocfclient_? = null;
+    private val _mainScope = CoroutineScope(Dispatchers.Main)
+
+    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
+        GeneratedPluginRegistrant.registerWith(flutterEngine)
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
+            when (call.method) {
+                "initialize" -> this.initializeOCFClient(call, result)
+                "discoverDevices" -> this.discoverDevices(call, result)
+                "ownDevice" -> this.ownDevice(call, result)
+                "setAccessForCloud" -> this.setAccessForCloud(call, result)
+                "onboardDevice" -> this.onboardDevice(call, result)
+                "disownDevice" -> this.disownDevice(call, result)
+                else -> result.notImplemented()
+            }
+        }
+    }
+
+    private fun initializeOCFClient(call: MethodCall, result: MethodChannel.Result) {
+        if (sdkClient != null) {
+            result.success(true)
+            return
+        }
+
+        var accessToken = call.argument<String>("accessToken");
+        var cloudConfiguration = call.argument<String>("cloudConfiguration")
+        _mainScope.launch {
+            try {
+                sdkClient = ocfclient.Ocfclient_()
+                withContext(Dispatchers.IO) {
+                    sdkClient!!.initialize(accessToken, cloudConfiguration)
+                }
+                result.success(true)
+            } catch (e: Exception) {
+                sdkClient = null
+                result.error("-1", e.message, "")
+            }
+        }
+    }
+
+    private fun discoverDevices(call: MethodCall, result: MethodChannel.Result) {
+        var discoveryTimeout = call.arguments<Int>()
+        _mainScope.launch {
+            try {
+                var devices = withContext(Dispatchers.IO) {
+                    sdkClient!!.discover(discoveryTimeout.toLong())
+                }
+                result.success(devices)
+            } catch (e: Exception) {
+                result.error("-1", e.message, "")
+            }
+        }
+    }
+
+    private fun ownDevice(call: MethodCall, result: MethodChannel.Result) {
+        var deviceId = call.argument<String>("deviceID")
+        var accessToken = call.argument<String>("accessToken")
+        _mainScope.launch {
+            try {
+                var newDeviceId = withContext(Dispatchers.IO) {
+                    sdkClient!!.ownDevice(deviceId, accessToken)
+                }
+                result.success(newDeviceId)
+            } catch (e: Exception) {
+                result.error("-1", e.message, "")
+            }
+        }
+    }
+
+    private fun setAccessForCloud(call: MethodCall, result: MethodChannel.Result) {
+        var deviceId = call.argument<String>("deviceID")
+        _mainScope.launch {
+            try {
+                withContext(Dispatchers.IO) {
+                    sdkClient!!.setAccessForCloud(deviceId)
+                }
+                result.success(true)
+            } catch (e: Exception) {
+                result.error("-1", e.message, "")
+            }
+        }
+    }
+
+    private fun onboardDevice(call: MethodCall, result: MethodChannel.Result) {
+        var deviceId = call.argument<String>("deviceID")
+        var authCode = call.argument<String>("authCode")
+        _mainScope.launch {
+            try {
+                withContext(Dispatchers.IO) {
+                    sdkClient!!.onboardDevice(deviceId, authCode)
+                }
+                result.success(true)
+            } catch (e: Exception) {
+                result.error("-1", e.message, "")
+            }
+        }
+    }
+
+    private fun disownDevice(call: MethodCall, result: MethodChannel.Result) {
+        var deviceId = call.argument<String>("deviceID")
+        _mainScope.launch {
+            try {
+                withContext(Dispatchers.IO) {
+                    sdkClient!!.disownDevice(deviceId)
+                }
+                result.success(true)
+            } catch (e: Exception) {
+                result.error("-1", e.message, "")
+            }
+        }
+    }
+}

android/app/src/main/kotlin/dev/plgd/mobile/MainActivity.kt

@@ -1,12 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- Modify this file to customize your launch splash screen -->
 <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
     <item android:drawable="@android:color/white" />
-
-    <!-- You can insert your own image assets here -->
-    <!-- <item>
+    <item>
         <bitmap
             android:gravity="center"
-            android:src="@mipmap/launch_image" />
-    </item> -->
+            android:src="@mipmap/launch_logo" />
+    </item>
 </layer-list>