react-native-gizwits-sdk-v5 1.4.57 → 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
|
@@ -27,440 +27,455 @@ import com.google.gson.annotations.SerializedName
|
|
|
27
27
|
import kotlinx.coroutines.CoroutineScope
|
|
28
28
|
import kotlinx.coroutines.Dispatchers
|
|
29
29
|
import kotlinx.coroutines.launch
|
|
30
|
+
import org.json.JSONArray
|
|
30
31
|
import org.json.JSONObject
|
|
31
32
|
|
|
32
33
|
data class GizBindParams(
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
34
|
+
@SerializedName("id")
|
|
35
|
+
override val id: String,
|
|
36
|
+
@SerializedName("alias")
|
|
37
|
+
val alias: String,
|
|
38
|
+
@SerializedName("remark")
|
|
39
|
+
val remark: String,
|
|
39
40
|
) : DeviceParams
|
|
40
41
|
|
|
41
42
|
data class UpdateDeviceInfoParams(
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
43
|
+
@SerializedName("id")
|
|
44
|
+
override val id: String,
|
|
45
|
+
@SerializedName("alias")
|
|
46
|
+
val alias: String,
|
|
47
|
+
@SerializedName("remark")
|
|
48
|
+
val remark: String,
|
|
48
49
|
) : DeviceParams
|
|
49
50
|
|
|
50
51
|
data class GizGetDPParams(
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
52
|
+
@SerializedName("id")
|
|
53
|
+
override val id: String,
|
|
54
|
+
@SerializedName("type")
|
|
55
|
+
val type: CapacityTypes,
|
|
56
|
+
@SerializedName("attrs")
|
|
57
|
+
val attrs: JsonArray?,
|
|
57
58
|
) : DeviceParams
|
|
58
59
|
|
|
59
60
|
data class GizSendDPParams(
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
61
|
+
@SerializedName("id")
|
|
62
|
+
override val id: String,
|
|
63
|
+
@SerializedName("type")
|
|
64
|
+
val type: CapacityTypes,
|
|
65
|
+
@SerializedName("data")
|
|
66
|
+
val data: String,
|
|
66
67
|
) : DeviceParams
|
|
67
68
|
|
|
68
69
|
data class GizUnBindParams(
|
|
69
|
-
|
|
70
|
-
|
|
70
|
+
@SerializedName("id")
|
|
71
|
+
override val id: String,
|
|
71
72
|
): DeviceParams
|
|
72
73
|
|
|
73
74
|
data class StopMusicalRhythmParams(
|
|
74
|
-
|
|
75
|
-
|
|
75
|
+
@SerializedName("id")
|
|
76
|
+
override val id: String,
|
|
76
77
|
): DeviceParams
|
|
77
78
|
|
|
78
79
|
data class StartMusicalRhythmParams(
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
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,
|
|
87
88
|
): DeviceParams
|
|
88
89
|
|
|
89
90
|
data class GizConnectParams(
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
91
|
+
@SerializedName("id")
|
|
92
|
+
override val id: String,
|
|
93
|
+
@SerializedName("type")
|
|
94
|
+
val type: CapacityTypes
|
|
94
95
|
): DeviceParams
|
|
95
96
|
data class GizDisConnectParams(
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
97
|
+
@SerializedName("id")
|
|
98
|
+
override val id: String,
|
|
99
|
+
@SerializedName("type")
|
|
100
|
+
val type: CapacityTypes
|
|
100
101
|
): DeviceParams
|
|
101
102
|
|
|
102
103
|
data class GizRegisterDeviceParams(
|
|
103
|
-
|
|
104
|
-
|
|
104
|
+
@SerializedName("id")
|
|
105
|
+
override val id: String,
|
|
105
106
|
): DeviceParams
|
|
106
107
|
|
|
107
108
|
data class GizProvideWiFiCredentialsParams(
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
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,
|
|
118
119
|
): DeviceParams
|
|
119
120
|
data class GizStopProvideWiFiCredentialsParams(
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
121
|
+
@SerializedName("id")
|
|
122
|
+
override val id: String,
|
|
123
|
+
@SerializedName("type")
|
|
124
|
+
val type: CapacityTypes,
|
|
124
125
|
): DeviceParams
|
|
125
126
|
|
|
126
127
|
data class GizGetDeviceInfoParams(
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
128
|
+
@SerializedName("id")
|
|
129
|
+
override val id: String,
|
|
130
|
+
@SerializedName("type")
|
|
131
|
+
val type: CapacityTypes
|
|
131
132
|
): DeviceParams
|
|
132
133
|
data class GizCheckUpdateParams(
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
134
|
+
@SerializedName("id")
|
|
135
|
+
override val id: String,
|
|
136
|
+
@SerializedName("type")
|
|
137
|
+
val type: CapacityTypes,
|
|
138
|
+
@SerializedName("firmwareType")
|
|
139
|
+
val firmwareType: GizOTAFirmwareType
|
|
139
140
|
): DeviceParams
|
|
140
141
|
data class StopUpgradeParams(
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
142
|
+
@SerializedName("id")
|
|
143
|
+
override val id: String,
|
|
144
|
+
@SerializedName("type")
|
|
145
|
+
val type: CapacityTypes,
|
|
145
146
|
): DeviceParams
|
|
146
147
|
|
|
147
148
|
|
|
148
149
|
class RNGizDeviceManagerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
150
|
+
enum class EventName(val value: String) {
|
|
151
|
+
GizOTAProgressEvent("GizOTAProgressEvent"),
|
|
152
|
+
GizProvideWiFiCredentialsEvent("GizProvideWiFiCredentialsEvent"),
|
|
153
|
+
GizMusicalRhythmEvnet("GizMusicalRhythmEvnet")
|
|
154
|
+
}
|
|
154
155
|
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
}
|
|
161
|
-
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)
|
|
162
161
|
}
|
|
162
|
+
return pairs.toTypedArray()
|
|
163
|
+
}
|
|
163
164
|
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
}
|
|
183
|
-
}
|
|
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))
|
|
184
183
|
}
|
|
184
|
+
}
|
|
185
185
|
}
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
}
|
|
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)
|
|
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)
|
|
206
205
|
}
|
|
206
|
+
}
|
|
207
207
|
}
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
219
|
-
}
|
|
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()
|
|
220
218
|
}
|
|
219
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
220
|
+
}
|
|
221
221
|
}
|
|
222
|
+
}
|
|
222
223
|
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
}
|
|
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
|
+
}
|
|
235
235
|
}
|
|
236
|
+
}
|
|
236
237
|
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
}
|
|
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
|
+
}
|
|
249
249
|
}
|
|
250
|
+
}
|
|
250
251
|
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
}
|
|
261
|
-
}
|
|
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()
|
|
262
261
|
}
|
|
262
|
+
}
|
|
263
263
|
}
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
275
|
-
}
|
|
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()
|
|
276
274
|
}
|
|
275
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
276
|
+
}
|
|
277
277
|
}
|
|
278
|
+
}
|
|
278
279
|
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
}
|
|
317
|
-
)
|
|
318
|
-
}
|
|
319
|
-
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)
|
|
309
|
+
}
|
|
310
|
+
)
|
|
311
|
+
CapacityTypes.MQTT -> device.mqttCapability.provideWiFiCredentials(
|
|
312
|
+
config.ssid,
|
|
313
|
+
config.password,
|
|
314
|
+
config.timeout,
|
|
315
|
+
processHandler = {
|
|
316
|
+
wiFiCredentialsEventHandler(it, device)
|
|
320
317
|
}
|
|
318
|
+
)
|
|
321
319
|
}
|
|
320
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
321
|
+
}
|
|
322
322
|
}
|
|
323
|
+
}
|
|
323
324
|
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
}
|
|
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
|
+
}
|
|
333
333
|
}
|
|
334
|
+
}
|
|
334
335
|
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
}
|
|
345
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
346
|
-
}
|
|
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()
|
|
347
345
|
}
|
|
346
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
347
|
+
}
|
|
348
348
|
}
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
360
|
-
}
|
|
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()
|
|
361
359
|
}
|
|
360
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
361
|
+
}
|
|
362
362
|
}
|
|
363
|
+
}
|
|
363
364
|
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
}
|
|
374
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
375
|
-
}
|
|
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)
|
|
376
374
|
}
|
|
375
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
376
|
+
}
|
|
377
377
|
}
|
|
378
|
+
}
|
|
378
379
|
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
}
|
|
409
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
410
|
-
}
|
|
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
|
+
})
|
|
411
409
|
}
|
|
410
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
411
|
+
}
|
|
412
412
|
}
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
424
|
-
}
|
|
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()
|
|
425
423
|
}
|
|
424
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = res)
|
|
425
|
+
}
|
|
426
426
|
}
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
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())
|
|
442
449
|
}
|
|
443
|
-
|
|
450
|
+
}
|
|
444
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
|
+
}
|
|
445
459
|
}
|
|
460
|
+
GizRNCallbackManager.callbackWithResult(callback = result, result = Result.success(Unit))
|
|
461
|
+
}
|
|
446
462
|
}
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
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
|
+
}
|
|
456
472
|
}
|
|
473
|
+
}
|
|
457
474
|
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
.emit(name, data)
|
|
464
|
-
}
|
|
475
|
+
fun sendEvent(name:String, data: WritableMap?) {
|
|
476
|
+
reactApplicationContext
|
|
477
|
+
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
|
|
478
|
+
.emit(name, data)
|
|
479
|
+
}
|
|
465
480
|
|
|
466
481
|
}
|
package/package.json
CHANGED