react-native-gizwits-sdk-v5 1.4.56 → 1.4.58
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/android/build.gradle
CHANGED
|
@@ -63,10 +63,12 @@ dependencies {
|
|
|
63
63
|
|
|
64
64
|
implementation "androidx.startup:startup-runtime:$startup_version"
|
|
65
65
|
|
|
66
|
-
implementation
|
|
67
|
-
|
|
68
|
-
implementation("io.github.gizwits:sdk
|
|
69
|
-
implementation("io.github.gizwits:sdk-
|
|
66
|
+
implementation 'com.github.wendykierp:JTransforms:3.1'
|
|
67
|
+
|
|
68
|
+
implementation("io.github.gizwits:sdk:1.3.0")
|
|
69
|
+
implementation("io.github.gizwits:sdk-bluetooth:1.3.0")
|
|
70
|
+
implementation("io.github.gizwits:sdk-lan:1.3.0")
|
|
71
|
+
implementation("io.github.gizwits:sdk-mqtt:1.3.0")
|
|
70
72
|
// implementation files('libs/sdk-release.aar', 'libs/sdk-bluetooth-release.aar', 'libs/sdk-lan-release.aar', 'libs/sdk-mqtt-release.aar')
|
|
71
73
|
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutine_version")
|
|
72
74
|
// retrofit
|
package/android/src/main/java/com/gizwits/reactnativegizwitssdkv5/RNGizDeviceManagerModule.kt
CHANGED
|
@@ -16,6 +16,7 @@ import com.gizwits.smart.sdk.core.capacity.CapacityTypes
|
|
|
16
16
|
import com.gizwits.smart.sdk.exception.GizException
|
|
17
17
|
import com.gizwits.smart.sdk.lan.lanCapability
|
|
18
18
|
import com.gizwits.smart.sdk.mqtt.mqttCapability
|
|
19
|
+
import com.gizwits.smart.sdk.light.MusicalRhythmParseMode
|
|
19
20
|
import com.gizwits.smart.sdk.mqtt.queryBoundDevices
|
|
20
21
|
import com.gizwits.smart.sdk.ota.GizOTAFirmwareType
|
|
21
22
|
import com.gizwits.smart.sdk.ota.OTAProgressData
|
|
@@ -26,391 +27,455 @@ import com.google.gson.annotations.SerializedName
|
|
|
26
27
|
import kotlinx.coroutines.CoroutineScope
|
|
27
28
|
import kotlinx.coroutines.Dispatchers
|
|
28
29
|
import kotlinx.coroutines.launch
|
|
30
|
+
import org.json.JSONArray
|
|
29
31
|
import org.json.JSONObject
|
|
30
32
|
|
|
31
33
|
data class GizBindParams(
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
34
|
+
@SerializedName("id")
|
|
35
|
+
override val id: String,
|
|
36
|
+
@SerializedName("alias")
|
|
37
|
+
val alias: String,
|
|
38
|
+
@SerializedName("remark")
|
|
39
|
+
val remark: String,
|
|
38
40
|
) : DeviceParams
|
|
39
41
|
|
|
40
42
|
data class UpdateDeviceInfoParams(
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
43
|
+
@SerializedName("id")
|
|
44
|
+
override val id: String,
|
|
45
|
+
@SerializedName("alias")
|
|
46
|
+
val alias: String,
|
|
47
|
+
@SerializedName("remark")
|
|
48
|
+
val remark: String,
|
|
47
49
|
) : DeviceParams
|
|
48
50
|
|
|
49
51
|
data class GizGetDPParams(
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
52
|
+
@SerializedName("id")
|
|
53
|
+
override val id: String,
|
|
54
|
+
@SerializedName("type")
|
|
55
|
+
val type: CapacityTypes,
|
|
56
|
+
@SerializedName("attrs")
|
|
57
|
+
val attrs: JsonArray?,
|
|
56
58
|
) : DeviceParams
|
|
57
59
|
|
|
58
60
|
data class GizSendDPParams(
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
61
|
+
@SerializedName("id")
|
|
62
|
+
override val id: String,
|
|
63
|
+
@SerializedName("type")
|
|
64
|
+
val type: CapacityTypes,
|
|
65
|
+
@SerializedName("data")
|
|
66
|
+
val data: String,
|
|
65
67
|
) : DeviceParams
|
|
66
68
|
|
|
67
69
|
data class GizUnBindParams(
|
|
68
|
-
|
|
69
|
-
|
|
70
|
+
@SerializedName("id")
|
|
71
|
+
override val id: String,
|
|
72
|
+
): DeviceParams
|
|
73
|
+
|
|
74
|
+
data class StopMusicalRhythmParams(
|
|
75
|
+
@SerializedName("id")
|
|
76
|
+
override val id: String,
|
|
77
|
+
): DeviceParams
|
|
78
|
+
|
|
79
|
+
data class StartMusicalRhythmParams(
|
|
80
|
+
@SerializedName("id")
|
|
81
|
+
override val id: String,
|
|
82
|
+
@SerializedName("needMonitor")
|
|
83
|
+
val needMonitor: Boolean,
|
|
84
|
+
@SerializedName("sensitivity")
|
|
85
|
+
val sensitivity: Int,
|
|
86
|
+
@SerializedName("mode")
|
|
87
|
+
val mode: MusicalRhythmParseMode,
|
|
70
88
|
): DeviceParams
|
|
71
89
|
|
|
72
90
|
data class GizConnectParams(
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
91
|
+
@SerializedName("id")
|
|
92
|
+
override val id: String,
|
|
93
|
+
@SerializedName("type")
|
|
94
|
+
val type: CapacityTypes
|
|
77
95
|
): DeviceParams
|
|
78
96
|
data class GizDisConnectParams(
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
97
|
+
@SerializedName("id")
|
|
98
|
+
override val id: String,
|
|
99
|
+
@SerializedName("type")
|
|
100
|
+
val type: CapacityTypes
|
|
83
101
|
): DeviceParams
|
|
84
102
|
|
|
85
103
|
data class GizRegisterDeviceParams(
|
|
86
|
-
|
|
87
|
-
|
|
104
|
+
@SerializedName("id")
|
|
105
|
+
override val id: String,
|
|
88
106
|
): DeviceParams
|
|
89
107
|
|
|
90
108
|
data class GizProvideWiFiCredentialsParams(
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
109
|
+
@SerializedName("id")
|
|
110
|
+
override val id: String,
|
|
111
|
+
@SerializedName("type")
|
|
112
|
+
val type: CapacityTypes,
|
|
113
|
+
@SerializedName("ssid")
|
|
114
|
+
val ssid: String,
|
|
115
|
+
@SerializedName("password")
|
|
116
|
+
val password: String,
|
|
117
|
+
@SerializedName("timeout")
|
|
118
|
+
val timeout: Long,
|
|
101
119
|
): DeviceParams
|
|
102
120
|
data class GizStopProvideWiFiCredentialsParams(
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
121
|
+
@SerializedName("id")
|
|
122
|
+
override val id: String,
|
|
123
|
+
@SerializedName("type")
|
|
124
|
+
val type: CapacityTypes,
|
|
107
125
|
): DeviceParams
|
|
108
126
|
|
|
109
127
|
data class GizGetDeviceInfoParams(
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
128
|
+
@SerializedName("id")
|
|
129
|
+
override val id: String,
|
|
130
|
+
@SerializedName("type")
|
|
131
|
+
val type: CapacityTypes
|
|
114
132
|
): DeviceParams
|
|
115
133
|
data class GizCheckUpdateParams(
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
134
|
+
@SerializedName("id")
|
|
135
|
+
override val id: String,
|
|
136
|
+
@SerializedName("type")
|
|
137
|
+
val type: CapacityTypes,
|
|
138
|
+
@SerializedName("firmwareType")
|
|
139
|
+
val firmwareType: GizOTAFirmwareType
|
|
122
140
|
): DeviceParams
|
|
123
141
|
data class StopUpgradeParams(
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
142
|
+
@SerializedName("id")
|
|
143
|
+
override val id: String,
|
|
144
|
+
@SerializedName("type")
|
|
145
|
+
val type: CapacityTypes,
|
|
128
146
|
): DeviceParams
|
|
129
147
|
|
|
130
148
|
|
|
131
149
|
class RNGizDeviceManagerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
150
|
+
enum class EventName(val value: String) {
|
|
151
|
+
GizOTAProgressEvent("GizOTAProgressEvent"),
|
|
152
|
+
GizProvideWiFiCredentialsEvent("GizProvideWiFiCredentialsEvent"),
|
|
153
|
+
GizMusicalRhythmEvnet("GizMusicalRhythmEvnet")
|
|
154
|
+
}
|
|
136
155
|
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
}
|
|
143
|
-
return pairs.toTypedArray()
|
|
156
|
+
fun jsonObjectToPairs(jsonObject: JsonObject): Array<Pair<String, Any>> {
|
|
157
|
+
val pairs = mutableListOf<Pair<String, Any>>()
|
|
158
|
+
for ((key, value) in jsonObject.entrySet()) {
|
|
159
|
+
val pair = key to value
|
|
160
|
+
pairs.add(pair)
|
|
144
161
|
}
|
|
162
|
+
return pairs.toTypedArray()
|
|
163
|
+
}
|
|
145
164
|
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
}
|
|
165
|
-
}
|
|
165
|
+
override fun getName() = "RNGizDeviceManagerModule"
|
|
166
|
+
@ReactMethod
|
|
167
|
+
fun sendDp(options: ReadableMap, result: Callback) {
|
|
168
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizSendDPParams::class.java)
|
|
169
|
+
if (config !=null && device !=null) {
|
|
170
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
171
|
+
try {
|
|
172
|
+
val gson = Gson()
|
|
173
|
+
val jsonObject = gson.fromJson(config.data, JsonObject::class.java)
|
|
174
|
+
val attrs = jsonObjectToPairs(jsonObject)
|
|
175
|
+
val res = when(config.type) {
|
|
176
|
+
CapacityTypes.BLE -> device.bleCapability.sendDp(*attrs)
|
|
177
|
+
CapacityTypes.LAN -> device.lanCapability.sendDp(*attrs)
|
|
178
|
+
CapacityTypes.MQTT -> device.mqttCapability.sendDp(*attrs)
|
|
179
|
+
}
|
|
180
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
181
|
+
}catch (e: Exception) {
|
|
182
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = Result.failure<Unit>(e))
|
|
166
183
|
}
|
|
184
|
+
}
|
|
167
185
|
}
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
if (res.isSuccess) {
|
|
179
|
-
var jsonObject = res.getOrNull() ?: JSONObject()
|
|
180
|
-
val newRes = JSONObject()
|
|
181
|
-
newRes.put("success", true)
|
|
182
|
-
newRes.put("data", JSONObject(jsonObject.toString()))
|
|
183
|
-
result.invoke(null, GizRNCallbackManager.jsonObject2WriteableMap(newRes))
|
|
184
|
-
} else {
|
|
185
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
186
|
-
}
|
|
187
|
-
}
|
|
186
|
+
}
|
|
187
|
+
@ReactMethod
|
|
188
|
+
fun getDp(options: ReadableMap, result: Callback) {
|
|
189
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizGetDPParams::class.java)
|
|
190
|
+
if (config !=null && device !=null) {
|
|
191
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
192
|
+
var res = when(config.type) {
|
|
193
|
+
CapacityTypes.BLE -> device.bleCapability.getDp(config.attrs)
|
|
194
|
+
CapacityTypes.LAN -> device.lanCapability.getDp(config.attrs)
|
|
195
|
+
CapacityTypes.MQTT -> device.mqttCapability.getDp(config.attrs)
|
|
188
196
|
}
|
|
197
|
+
if (res.isSuccess) {
|
|
198
|
+
var jsonObject = res.getOrNull() ?: JSONObject()
|
|
199
|
+
val newRes = JSONObject()
|
|
200
|
+
newRes.put("success", true)
|
|
201
|
+
newRes.put("data", JSONObject(jsonObject.toString()))
|
|
202
|
+
result.invoke(null, GizRNCallbackManager.jsonObject2WriteableMap(newRes))
|
|
203
|
+
} else {
|
|
204
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
205
|
+
}
|
|
206
|
+
}
|
|
189
207
|
}
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
201
|
-
}
|
|
208
|
+
}
|
|
209
|
+
@ReactMethod
|
|
210
|
+
fun getDeviceInfo(options: ReadableMap, result: Callback) {
|
|
211
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizGetDeviceInfoParams::class.java)
|
|
212
|
+
if (config !=null && device !=null) {
|
|
213
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
214
|
+
val res = when(config.type) {
|
|
215
|
+
CapacityTypes.BLE -> device.bleCapability.getDeviceInfo()
|
|
216
|
+
CapacityTypes.LAN -> device.lanCapability.getDeviceInfo()
|
|
217
|
+
CapacityTypes.MQTT -> device.mqttCapability.getDeviceInfo()
|
|
202
218
|
}
|
|
219
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
220
|
+
}
|
|
203
221
|
}
|
|
222
|
+
}
|
|
204
223
|
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
}
|
|
224
|
+
@ReactMethod
|
|
225
|
+
fun updateDeviceInfo(options: ReadableMap, result: Callback) {
|
|
226
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, UpdateDeviceInfoParams::class.java)
|
|
227
|
+
if (config !=null && device !=null) {
|
|
228
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
229
|
+
val res = device.updateDeviceInfo(config.alias, config.remark)
|
|
230
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
231
|
+
// if (res.isSuccess) {
|
|
232
|
+
// GizSDKManager.queryBoundDevices()
|
|
233
|
+
// }
|
|
234
|
+
}
|
|
217
235
|
}
|
|
236
|
+
}
|
|
218
237
|
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
}
|
|
238
|
+
@ReactMethod
|
|
239
|
+
fun bind(options: ReadableMap, result: Callback) {
|
|
240
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizBindParams::class.java)
|
|
241
|
+
if (config !=null && device !=null) {
|
|
242
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
243
|
+
val res = device.bind(config.alias, config.remark)
|
|
244
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
245
|
+
// if (res.isSuccess) {
|
|
246
|
+
// GizSDKManager.queryBoundDevices()
|
|
247
|
+
// }
|
|
248
|
+
}
|
|
231
249
|
}
|
|
250
|
+
}
|
|
232
251
|
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
}
|
|
243
|
-
}
|
|
252
|
+
@ReactMethod
|
|
253
|
+
fun unBind(options: ReadableMap, result: Callback) {
|
|
254
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizUnBindParams::class.java)
|
|
255
|
+
if (config !=null && device !=null) {
|
|
256
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
257
|
+
val res = device.unBind()
|
|
258
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
259
|
+
if (res.isSuccess) {
|
|
260
|
+
GizSDKManager.queryBoundDevices()
|
|
244
261
|
}
|
|
262
|
+
}
|
|
245
263
|
}
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
257
|
-
}
|
|
264
|
+
}
|
|
265
|
+
@ReactMethod
|
|
266
|
+
fun stopProvideWiFiCredentials(options: ReadableMap, result: Callback) {
|
|
267
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizStopProvideWiFiCredentialsParams::class.java)
|
|
268
|
+
if (config !=null && device !=null) {
|
|
269
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
270
|
+
val res = when(config.type) {
|
|
271
|
+
CapacityTypes.BLE -> device.bleCapability.stopProvideWiFiCredentials()
|
|
272
|
+
CapacityTypes.LAN -> device.lanCapability.stopProvideWiFiCredentials()
|
|
273
|
+
CapacityTypes.MQTT -> device.mqttCapability.stopProvideWiFiCredentials()
|
|
258
274
|
}
|
|
275
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
276
|
+
}
|
|
259
277
|
}
|
|
278
|
+
}
|
|
260
279
|
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
}
|
|
291
|
-
)
|
|
292
|
-
CapacityTypes.MQTT -> device.mqttCapability.provideWiFiCredentials(
|
|
293
|
-
config.ssid,
|
|
294
|
-
config.password,
|
|
295
|
-
config.timeout,
|
|
296
|
-
processHandler = {
|
|
297
|
-
wiFiCredentialsEventHandler(it, device)
|
|
298
|
-
}
|
|
299
|
-
)
|
|
300
|
-
}
|
|
301
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
280
|
+
fun wiFiCredentialsEventHandler(event: ProvideWiFiCredentialsEvent, device: GizDevice) {
|
|
281
|
+
val jsonObject = JSONObject()
|
|
282
|
+
jsonObject.put("data", event.toString())
|
|
283
|
+
jsonObject.put("device", device.toJsonObject())
|
|
284
|
+
sendEvent(
|
|
285
|
+
EventName.GizProvideWiFiCredentialsEvent.name,
|
|
286
|
+
GizRNCallbackManager.jsonObject2WriteableMap(jsonObject)
|
|
287
|
+
)
|
|
288
|
+
}
|
|
289
|
+
@ReactMethod
|
|
290
|
+
fun provideWiFiCredentials(options: ReadableMap, result: Callback) {
|
|
291
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizProvideWiFiCredentialsParams::class.java)
|
|
292
|
+
if (config !=null && device !=null) {
|
|
293
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
294
|
+
val res = when(config.type) {
|
|
295
|
+
CapacityTypes.BLE -> device.bleCapability.provideWiFiCredentials(
|
|
296
|
+
config.ssid,
|
|
297
|
+
config.password,
|
|
298
|
+
config.timeout,
|
|
299
|
+
processHandler = {
|
|
300
|
+
wiFiCredentialsEventHandler(it, device)
|
|
301
|
+
}
|
|
302
|
+
)
|
|
303
|
+
CapacityTypes.LAN -> device.lanCapability.provideWiFiCredentials(
|
|
304
|
+
config.ssid,
|
|
305
|
+
config.password,
|
|
306
|
+
config.timeout,
|
|
307
|
+
processHandler = {
|
|
308
|
+
wiFiCredentialsEventHandler(it, device)
|
|
302
309
|
}
|
|
310
|
+
)
|
|
311
|
+
CapacityTypes.MQTT -> device.mqttCapability.provideWiFiCredentials(
|
|
312
|
+
config.ssid,
|
|
313
|
+
config.password,
|
|
314
|
+
config.timeout,
|
|
315
|
+
processHandler = {
|
|
316
|
+
wiFiCredentialsEventHandler(it, device)
|
|
317
|
+
}
|
|
318
|
+
)
|
|
303
319
|
}
|
|
320
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
321
|
+
}
|
|
304
322
|
}
|
|
323
|
+
}
|
|
305
324
|
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
}
|
|
325
|
+
@ReactMethod
|
|
326
|
+
fun register(options: ReadableMap, result: Callback) {
|
|
327
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizRegisterDeviceParams::class.java)
|
|
328
|
+
if (config !=null && device !=null) {
|
|
329
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
330
|
+
val res = device.register()
|
|
331
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
332
|
+
}
|
|
315
333
|
}
|
|
334
|
+
}
|
|
316
335
|
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
}
|
|
327
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
328
|
-
}
|
|
336
|
+
@ReactMethod
|
|
337
|
+
fun connect(options: ReadableMap, result: Callback) {
|
|
338
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizConnectParams::class.java)
|
|
339
|
+
if (config !=null && device !=null) {
|
|
340
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
341
|
+
val res = when(config.type) {
|
|
342
|
+
CapacityTypes.BLE -> device.bleCapability.connect()
|
|
343
|
+
CapacityTypes.LAN -> device.lanCapability.connect()
|
|
344
|
+
CapacityTypes.MQTT -> device.mqttCapability.connect()
|
|
329
345
|
}
|
|
346
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
347
|
+
}
|
|
330
348
|
}
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
342
|
-
}
|
|
349
|
+
}
|
|
350
|
+
@ReactMethod
|
|
351
|
+
fun disConnect(options: ReadableMap, result: Callback) {
|
|
352
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizDisConnectParams::class.java)
|
|
353
|
+
if (config !=null && device !=null) {
|
|
354
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
355
|
+
val res = when(config.type) {
|
|
356
|
+
CapacityTypes.BLE -> device.bleCapability.disConnect()
|
|
357
|
+
CapacityTypes.LAN -> device.lanCapability.disConnect()
|
|
358
|
+
CapacityTypes.MQTT -> device.mqttCapability.disConnect()
|
|
343
359
|
}
|
|
360
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
361
|
+
}
|
|
344
362
|
}
|
|
363
|
+
}
|
|
345
364
|
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
}
|
|
356
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
357
|
-
}
|
|
365
|
+
@ReactMethod
|
|
366
|
+
fun checkUpdate(options: ReadableMap, result: Callback) {
|
|
367
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizCheckUpdateParams::class.java)
|
|
368
|
+
if (config !=null && device !=null) {
|
|
369
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
370
|
+
val res = when(config.type) {
|
|
371
|
+
CapacityTypes.BLE -> device.bleCapability.checkUpdate(config.firmwareType)
|
|
372
|
+
CapacityTypes.LAN -> device.lanCapability.checkUpdate(config.firmwareType)
|
|
373
|
+
CapacityTypes.MQTT -> device.mqttCapability.checkUpdate(config.firmwareType)
|
|
358
374
|
}
|
|
375
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
376
|
+
}
|
|
359
377
|
}
|
|
378
|
+
}
|
|
360
379
|
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
380
|
+
fun handleStartUpgradeProgress(event: OTAProgressData, device: GizDevice) {
|
|
381
|
+
val jsonObject = JSONObject()
|
|
382
|
+
val dataObject = JSONObject()
|
|
383
|
+
dataObject.put("percentage", event.percentage)
|
|
384
|
+
dataObject.put("event", event.event.value)
|
|
385
|
+
jsonObject.put("data", dataObject)
|
|
386
|
+
jsonObject.put("device", device.toJsonObject())
|
|
387
|
+
sendEvent(
|
|
388
|
+
EventName.GizOTAProgressEvent.name,
|
|
389
|
+
GizRNCallbackManager.jsonObject2WriteableMap(jsonObject)
|
|
390
|
+
)
|
|
391
|
+
}
|
|
392
|
+
@ReactMethod
|
|
393
|
+
fun startUpgrade(options: ReadableMap, result: Callback) {
|
|
394
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizCheckUpdateParams::class.java)
|
|
395
|
+
if (config !=null && device !=null) {
|
|
396
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
397
|
+
val res = when(config.type) {
|
|
398
|
+
CapacityTypes.BLE -> {
|
|
399
|
+
device.bleCapability.startUpgrade(config.firmwareType, processHandler = {
|
|
400
|
+
handleStartUpgradeProgress(it, device)
|
|
401
|
+
})
|
|
402
|
+
}
|
|
403
|
+
CapacityTypes.LAN -> device.lanCapability.startUpgrade(config.firmwareType, processHandler = {
|
|
404
|
+
handleStartUpgradeProgress(it, device)
|
|
405
|
+
})
|
|
406
|
+
CapacityTypes.MQTT -> device.mqttCapability.startUpgrade(config.firmwareType, processHandler = {
|
|
407
|
+
handleStartUpgradeProgress(it, device)
|
|
408
|
+
})
|
|
409
|
+
}
|
|
410
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
411
|
+
}
|
|
372
412
|
}
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
}
|
|
384
|
-
CapacityTypes.LAN -> device.lanCapability.startUpgrade(config.firmwareType, processHandler = {
|
|
385
|
-
handleStartUpgradeProgress(it, device)
|
|
386
|
-
})
|
|
387
|
-
CapacityTypes.MQTT -> device.mqttCapability.startUpgrade(config.firmwareType, processHandler = {
|
|
388
|
-
handleStartUpgradeProgress(it, device)
|
|
389
|
-
})
|
|
390
|
-
}
|
|
391
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
392
|
-
}
|
|
413
|
+
}
|
|
414
|
+
@ReactMethod
|
|
415
|
+
fun cancelUpgrade(options: ReadableMap, result: Callback) {
|
|
416
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, StopUpgradeParams::class.java)
|
|
417
|
+
if (config !=null && device !=null) {
|
|
418
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
419
|
+
val res = when(config.type) {
|
|
420
|
+
CapacityTypes.BLE -> device.bleCapability.cancelUpgrade()
|
|
421
|
+
CapacityTypes.LAN -> device.lanCapability.cancelUpgrade()
|
|
422
|
+
CapacityTypes.MQTT -> device.mqttCapability.cancelUpgrade()
|
|
393
423
|
}
|
|
424
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
425
|
+
}
|
|
394
426
|
}
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
427
|
+
}
|
|
428
|
+
@ReactMethod
|
|
429
|
+
fun startMusicalRhythm(options: ReadableMap, result: Callback) {
|
|
430
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, StartMusicalRhythmParams::class.java)
|
|
431
|
+
print("startMusicalRhythm ${config}")
|
|
432
|
+
if (config !=null && device !=null) {
|
|
433
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
434
|
+
val res = device.startMusicalRhythm(config.sensitivity, config.mode) { data ->
|
|
435
|
+
if (config.needMonitor) {
|
|
436
|
+
val jsonObject = JSONObject()
|
|
437
|
+
val jsonData = JSONObject()
|
|
438
|
+
|
|
439
|
+
jsonData.put("bpm",data.bpm)
|
|
440
|
+
jsonData.put("isBeat",data.isBeat)
|
|
441
|
+
jsonData.put("midiValue",data.midiValue)
|
|
442
|
+
jsonData.put("hue",data.hue)
|
|
443
|
+
jsonData.put("powerLevel",data.powerLevel)
|
|
444
|
+
|
|
445
|
+
val fftJsonArray = data.fft?.let { fftArray ->
|
|
446
|
+
JSONArray().apply {
|
|
447
|
+
for (value in fftArray) {
|
|
448
|
+
put(value.toDouble())
|
|
404
449
|
}
|
|
405
|
-
|
|
450
|
+
}
|
|
406
451
|
}
|
|
452
|
+
jsonData.put("fft", fftJsonArray)
|
|
453
|
+
|
|
454
|
+
|
|
455
|
+
jsonObject.put("data", jsonData)
|
|
456
|
+
jsonObject.put("deviceID", config.id)
|
|
457
|
+
sendEvent(EventName.GizMusicalRhythmEvnet.name, GizRNCallbackManager.jsonObject2WriteableMap(jsonObject))
|
|
458
|
+
}
|
|
407
459
|
}
|
|
460
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = Result.success(Unit))
|
|
461
|
+
}
|
|
408
462
|
}
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
463
|
+
}
|
|
464
|
+
@ReactMethod
|
|
465
|
+
fun stopMusicalRhythm(options: ReadableMap, result: Callback) {
|
|
466
|
+
val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, StopMusicalRhythmParams::class.java)
|
|
467
|
+
if (config !=null && device !=null) {
|
|
468
|
+
CoroutineScope(Dispatchers.IO).launch {
|
|
469
|
+
val res = device.stopMusicalRhythm();
|
|
470
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = Result.success(Unit))
|
|
471
|
+
}
|
|
414
472
|
}
|
|
473
|
+
}
|
|
474
|
+
|
|
475
|
+
fun sendEvent(name:String, data: WritableMap?) {
|
|
476
|
+
reactApplicationContext
|
|
477
|
+
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
|
|
478
|
+
.emit(name, data)
|
|
479
|
+
}
|
|
415
480
|
|
|
416
481
|
}
|
package/package.json
CHANGED