Initialize ESPProvisioningProvider with the proper realm (from URL or…

ORLib/src/main/java/io/openremote/orlib/service/ESPProvisionProvider.kt

@@ -38,7 +38,7 @@ object ESPProvisionProviderActions {
     const val EXIT_PROVISIONING = "EXIT_PROVISIONING"
 }
 
-class ESPProvisionProvider(val context: Context, val apiURL: URL = URL("http://localhost:8080/api/master")) {
+class ESPProvisionProvider(val context: Context) {
     @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
     val deviceRegistry: DeviceRegistry
     var deviceConnection: DeviceConnection? = null
@@ -269,10 +269,10 @@ class ESPProvisionProvider(val context: Context, val apiURL: URL = URL("http://l
 
     // OR Configuration
 
-    fun provisionDevice(userToken: String) {
-        val deviceProvision = DeviceProvision(deviceConnection, deviceRegistry.callbackChannel, apiURL)
+    fun provisionDevice(apiURL: URL = URL("http://localhost:8080/api/master"), userToken: String) {
+        val deviceProvision = DeviceProvision(deviceConnection, deviceRegistry.callbackChannel)
         CoroutineScope(Dispatchers.IO).launch {
-            deviceProvision.provision(userToken)
+            deviceProvision.provision(apiURL, userToken)
         }
     }
 

ORLib/src/main/java/io/openremote/orlib/service/espprovision/DeviceProvision.kt

@@ -14,16 +14,16 @@ import java.util.Locale
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
-class DeviceProvision(var deviceConnection: DeviceConnection?, var callbackChannel: CallbackChannel?, var apiURL: URL) {
+class DeviceProvision(var deviceConnection: DeviceConnection?, var callbackChannel: CallbackChannel?) {
     var deviceProvisionAPI: DeviceProvisionAPI
 
     var backendConnectionTimeoutMillis = 60_000
 
     init {
-        deviceProvisionAPI = DeviceProvisionAPIREST(apiURL)
+        deviceProvisionAPI = DeviceProvisionAPIREST()
     }
 
-    suspend fun provision(userToken: String) {
+    suspend fun provision(apiURL: URL, userToken: String) {
         if (deviceConnection == null || !deviceConnection!!.isConnected) {
             sendProvisionDeviceStatus(false, ESPProviderErrorCode.NOT_CONNECTED, "No connection established to device")
         }
@@ -34,11 +34,11 @@ class DeviceProvision(var deviceConnection: DeviceConnection?, var callbackChann
 
             val password = generatePassword()
 
-            val result = deviceProvisionAPI.provision(deviceInfo.modelName, deviceInfo.deviceId, password, userToken)
+            val result = deviceProvisionAPI.provision(apiURL, deviceInfo.modelName, deviceInfo.deviceId, password, userToken)
             val userName = deviceInfo.deviceId.lowercase(Locale("en"))
 
             deviceConnection?.sendOpenRemoteConfig(
-                mqttBrokerUrl = mqttURL,
+                mqttBrokerUrl = "mqtts://${apiURL.host ?: "localhost"}:8883",
                 mqttUser = userName,
                 mqttPassword = password,
                 assetId = result.assetId,
@@ -116,10 +116,4 @@ class DeviceProvision(var deviceConnection: DeviceConnection?, var callbackChann
             .build()
             .generate()
     }
-
-    private val mqttURL: String
-        get() {
-            // TODO: is this OK or do we want to get the mqtt url from the server?
-            return "mqtts://${apiURL.host ?: "localhost"}:8883"
-        }
 }

ORLib/src/main/java/io/openremote/orlib/service/espprovision/DeviceProvisionAPI.kt

@@ -13,21 +13,21 @@ import java.net.HttpURLConnection
 import java.net.URL
 
 interface DeviceProvisionAPI {
-    suspend fun provision(modelName: String, deviceId: String, password: String, token: String): ProvisionResult
+    suspend fun provision(apiURL: URL, modelName: String, deviceId: String, password: String, token: String): ProvisionResult
 }
 
 data class ProvisionResult(
     val assetId: String,
     val properties: Map<String, String>
 )
 
-class DeviceProvisionAPIREST(private val apiURL: URL) : DeviceProvisionAPI {
+class DeviceProvisionAPIREST() : DeviceProvisionAPI {
 
-    companion object {
+  companion object {
         private const val TAG = "DeviceProvisionAPIREST"
     }
 
-    override suspend fun provision(modelName: String, deviceId: String, password: String, token: String): ProvisionResult = withContext(Dispatchers.IO) {
+    override suspend fun provision(apiURL: URL, modelName: String, deviceId: String, password: String, token: String): ProvisionResult = withContext(Dispatchers.IO) {
         Log.d(ESPProvisionProvider.TAG, "apiURL $apiURL")
         val uri = Uri.parse(apiURL.toString()).buildUpon()
             .appendPath("rest")

ORLib/src/main/java/io/openremote/orlib/ui/OrMainActivity.kt

@@ -966,11 +966,7 @@ open class OrMainActivity : Activity() {
         private fun handleESPProvisionProviderMessage(data: JSONObject) {
             val action = data.getString("action")
             if (espProvisionProvider == null) {
-                if (baseUrl != null) {
-                    espProvisionProvider = ESPProvisionProvider(activity, URL(URL(baseUrl), "/api/master"))
-                } else {
-                    espProvisionProvider = ESPProvisionProvider(activity)
-                }
+                espProvisionProvider = ESPProvisionProvider(activity)
             }
             when {
                 action.equals(ESPProvisionProviderActions.PROVIDER_INIT, ignoreCase = true) -> {
@@ -1049,7 +1045,12 @@ open class OrMainActivity : Activity() {
                 action.equals(ESPProvisionProviderActions.PROVISION_DEVICE) -> {
                     val userToken = data.optString("userToken")
                     if (!userToken.isNullOrEmpty()) {
-                        espProvisionProvider?.provisionDevice(userToken)
+                        if (baseUrl != null) {
+                            val realm = getESPProvisionRealm()
+                            espProvisionProvider?.provisionDevice(getESPProvisionApiURL(baseUrl!!, realm), userToken)
+                        } else {
+                            espProvisionProvider?.provisionDevice(userToken = userToken)
+                        }
                     } else {
                         val payload: Map<String, Any> = hashMapOf(
                             "action" to action,
@@ -1061,6 +1062,27 @@ open class OrMainActivity : Activity() {
                 }
             }
         }
+
+        private fun getESPProvisionRealm(): String {
+            return baseUrl
+                ?.let { Uri.parse(it).getQueryParameter(ORConstants.REALM_KEY) }
+                ?.takeIf { it.isNotBlank() }
+                ?: sharedPreferences.getString(ORConstants.REALM_KEY, null)
+                    ?.takeIf { it.isNotBlank() }
+                ?: "master"
+        }
+
+        private fun getESPProvisionApiURL(baseUrl: String, realm: String): URL {
+            val appUri = Uri.parse(baseUrl)
+            val apiUri = Uri.Builder()
+                .scheme(appUri.scheme)
+                .encodedAuthority(appUri.encodedAuthority)
+                .appendPath("api")
+                .appendPath(realm)
+                .build()
+
+            return URL(apiUri.toString())
+        }
     }
 
     private fun notifyClient(data: Map<String, Any?>?) {