@glympse-inc/com.glympse.enroute 2.105.232
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/package.json +34 -0
- package/plugin.xml +262 -0
- package/scripts/iosFixPCH.js +38 -0
- package/src/android/BootReceiver.java +13 -0
- package/src/android/EnRoutePlugin.java +1867 -0
- package/src/android/HealthCheckJobService.java +225 -0
- package/src/android/LocationAccuracyChecker.java +49 -0
- package/src/android/ManagerWrapper.java +205 -0
- package/src/android/NotificationService.java +81 -0
- package/src/android/PushReceiver.java +90 -0
- package/src/android/enroute/aars/enrouteapi-aar.gradle +17 -0
- package/src/android/enroute/aars/glympseapi-aar.gradle +17 -0
- package/src/android/enroute/aars/glympseapipush-aar.gradle +17 -0
- package/src/android/enroute/aars/glympseapitoolbox-aar.gradle +17 -0
- package/src/android/gradle/build.gradle +25 -0
- package/src/ios/EnRoutePlugin.h +128 -0
- package/src/ios/EnRoutePlugin.mm +1258 -0
- package/src/ios/EnRouteWrapper.h +30 -0
- package/src/ios/EnRouteWrapper.mm +176 -0
- package/www/Agent.js +48 -0
- package/www/AgentManager.js +422 -0
- package/www/CardMessage.js +49 -0
- package/www/ChatMessage.js +29 -0
- package/www/CustomerMessage.js +18 -0
- package/www/EnRouteManager.js +613 -0
- package/www/EtaPlanner.js +129 -0
- package/www/GlobalConfig.js +13 -0
- package/www/Invite.js +93 -0
- package/www/LatLng.js +28 -0
- package/www/Location.js +63 -0
- package/www/Native.js +215 -0
- package/www/Operation.js +67 -0
- package/www/OrderItem.js +43 -0
- package/www/OrgConfig.js +184 -0
- package/www/Organization.js +88 -0
- package/www/Pickup.js +119 -0
- package/www/PickupArrivalData.js +38 -0
- package/www/PickupManager.js +512 -0
- package/www/Place.js +33 -0
- package/www/Session.js +87 -0
- package/www/SessionManager.js +431 -0
- package/www/Task.js +106 -0
- package/www/TaskManager.js +443 -0
- package/www/Ticket.js +205 -0
- package/www/Track.js +75 -0
|
@@ -0,0 +1,1867 @@
|
|
|
1
|
+
package com.glympse.enroute.hybrid.android;
|
|
2
|
+
|
|
3
|
+
import com.glympse.android.api.*;
|
|
4
|
+
import com.glympse.android.core.*;
|
|
5
|
+
import com.glympse.android.lib.*;
|
|
6
|
+
import com.glympse.android.lib.json.*;
|
|
7
|
+
import com.glympse.android.hal.*;
|
|
8
|
+
import com.glympse.android.toolbox.listener.GSource;
|
|
9
|
+
import com.glympse.android.toolbox.listener.GListener;
|
|
10
|
+
import com.glympse.enroute.android.api.*;
|
|
11
|
+
|
|
12
|
+
import org.apache.cordova.CallbackContext;
|
|
13
|
+
import org.apache.cordova.CordovaPlugin;
|
|
14
|
+
import org.apache.cordova.PluginResult;
|
|
15
|
+
import org.apache.cordova.PluginResult.Status;
|
|
16
|
+
import org.json.JSONArray;
|
|
17
|
+
import org.json.JSONObject;
|
|
18
|
+
import org.json.JSONException;
|
|
19
|
+
|
|
20
|
+
import java.util.ArrayList;
|
|
21
|
+
import java.util.HashMap;
|
|
22
|
+
import java.util.Map;
|
|
23
|
+
import java.util.List;
|
|
24
|
+
import com.glympse.enroute.hybrid.android.ManagerWrapper;
|
|
25
|
+
import com.glympse.enroute.hybrid.android.LocationAccuracyChecker;
|
|
26
|
+
|
|
27
|
+
public class EnRoutePlugin extends CordovaPlugin implements GListener
|
|
28
|
+
{
|
|
29
|
+
private static final String COMMAND_KEY_LOGIN = "LOGIN";
|
|
30
|
+
private static final String COMMAND_KEY_LOGOUT = "LOGOUT";
|
|
31
|
+
private static final String COMMAND_KEY_START_SHIFT = "START_SHIFT";
|
|
32
|
+
private static final String COMMAND_KEY_COMPLETE_SHIFT = "COMPLETE_SHIFT";
|
|
33
|
+
|
|
34
|
+
private GGlympse _glympse;
|
|
35
|
+
|
|
36
|
+
private Map<String, CallbackContext> _callbacks = new HashMap<String, CallbackContext>();
|
|
37
|
+
private List<CallbackContext> _listeners = new ArrayList<CallbackContext>();
|
|
38
|
+
|
|
39
|
+
protected void pluginInitialize()
|
|
40
|
+
{
|
|
41
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
42
|
+
if ( null == manager )
|
|
43
|
+
{
|
|
44
|
+
ManagerWrapper.instance().create(this.cordova.getActivity().getApplicationContext());
|
|
45
|
+
}
|
|
46
|
+
else
|
|
47
|
+
{
|
|
48
|
+
subscribeToListeners();
|
|
49
|
+
}
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
public void onDestroy()
|
|
53
|
+
{
|
|
54
|
+
unsubscribeFromListeners();
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException
|
|
58
|
+
{
|
|
59
|
+
// cordova.getThreadPool().execute(new Runnable()
|
|
60
|
+
// {
|
|
61
|
+
// public void run()
|
|
62
|
+
// {
|
|
63
|
+
|
|
64
|
+
// }
|
|
65
|
+
// });
|
|
66
|
+
if (action.equals("setActive"))
|
|
67
|
+
{
|
|
68
|
+
setActive(args, callbackContext);
|
|
69
|
+
return true;
|
|
70
|
+
}
|
|
71
|
+
if (action.equals("setBaseUrl"))
|
|
72
|
+
{
|
|
73
|
+
setBaseUrl(args, callbackContext);
|
|
74
|
+
return true;
|
|
75
|
+
}
|
|
76
|
+
if (action.equals("setAuthenticationMode"))
|
|
77
|
+
{
|
|
78
|
+
setAuthenticationMode(args, callbackContext);
|
|
79
|
+
return true;
|
|
80
|
+
}
|
|
81
|
+
if (action.equals("setFetchCompletedTasks"))
|
|
82
|
+
{
|
|
83
|
+
setFetchCompletedTasks(args, callbackContext);
|
|
84
|
+
return true;
|
|
85
|
+
}
|
|
86
|
+
if (action.equals("registerDeviceToken"))
|
|
87
|
+
{
|
|
88
|
+
registerDeviceToken(args, callbackContext);
|
|
89
|
+
return true;
|
|
90
|
+
}
|
|
91
|
+
if (action.equals("handleRemoteNotification"))
|
|
92
|
+
{
|
|
93
|
+
handleRemoteNotification(args, callbackContext);
|
|
94
|
+
return true;
|
|
95
|
+
}
|
|
96
|
+
if (action.equals("registerListener"))
|
|
97
|
+
{
|
|
98
|
+
registerListener(args, callbackContext);
|
|
99
|
+
return true;
|
|
100
|
+
}
|
|
101
|
+
else if (action.equals("syncAccountState"))
|
|
102
|
+
{
|
|
103
|
+
syncAccountState(args, callbackContext);
|
|
104
|
+
return true;
|
|
105
|
+
}
|
|
106
|
+
else if (action.equals("syncHealthReport"))
|
|
107
|
+
{
|
|
108
|
+
syncHealthReport(args, callbackContext);
|
|
109
|
+
return true;
|
|
110
|
+
}
|
|
111
|
+
else if (action.equals("start"))
|
|
112
|
+
{
|
|
113
|
+
start(args, callbackContext);
|
|
114
|
+
return true;
|
|
115
|
+
}
|
|
116
|
+
else if (action.equals("loginWithCredentials"))
|
|
117
|
+
{
|
|
118
|
+
loginWithCredentials(args, callbackContext);
|
|
119
|
+
return true;
|
|
120
|
+
}
|
|
121
|
+
else if (action.equals("loginWithToken"))
|
|
122
|
+
{
|
|
123
|
+
loginWithToken(args, callbackContext);
|
|
124
|
+
return true;
|
|
125
|
+
}
|
|
126
|
+
else if (action.equals("logout"))
|
|
127
|
+
{
|
|
128
|
+
logout(args, callbackContext);
|
|
129
|
+
return true;
|
|
130
|
+
}
|
|
131
|
+
else if (action.equals("logoutWithReason"))
|
|
132
|
+
{
|
|
133
|
+
logoutWithReason(args, callbackContext);
|
|
134
|
+
return true;
|
|
135
|
+
}
|
|
136
|
+
else if (action.equals("stop"))
|
|
137
|
+
{
|
|
138
|
+
stop(args, callbackContext);
|
|
139
|
+
return true;
|
|
140
|
+
}
|
|
141
|
+
else if (action.equals("syncTasksState"))
|
|
142
|
+
{
|
|
143
|
+
syncTasksState(args, callbackContext);
|
|
144
|
+
return true;
|
|
145
|
+
}
|
|
146
|
+
else if (action.equals("syncTasksStateLight"))
|
|
147
|
+
{
|
|
148
|
+
syncTasksStateLight(args, callbackContext);
|
|
149
|
+
return true;
|
|
150
|
+
}
|
|
151
|
+
else if (action.equals("refreshTasks"))
|
|
152
|
+
{
|
|
153
|
+
refreshTasks(args, callbackContext);
|
|
154
|
+
return true;
|
|
155
|
+
}
|
|
156
|
+
else if (action.equals("startTask"))
|
|
157
|
+
{
|
|
158
|
+
startTask(args, callbackContext);
|
|
159
|
+
return true;
|
|
160
|
+
}
|
|
161
|
+
else if (action.equals("createTask"))
|
|
162
|
+
{
|
|
163
|
+
createTask(args, callbackContext);
|
|
164
|
+
return true;
|
|
165
|
+
}
|
|
166
|
+
else if (action.equals("setTaskPhase"))
|
|
167
|
+
{
|
|
168
|
+
setTaskPhase(args, callbackContext);
|
|
169
|
+
return true;
|
|
170
|
+
}
|
|
171
|
+
else if (action.equals("setTaskVisibility"))
|
|
172
|
+
{
|
|
173
|
+
setTaskVisibility(args, callbackContext);
|
|
174
|
+
return true;
|
|
175
|
+
}
|
|
176
|
+
else if (action.equals("completeTask"))
|
|
177
|
+
{
|
|
178
|
+
completeTask(args, callbackContext);
|
|
179
|
+
return true;
|
|
180
|
+
}
|
|
181
|
+
else if (action.equals("addOrUpdateMetadataItem"))
|
|
182
|
+
{
|
|
183
|
+
addOrUpdateMetadataItem(args, callbackContext);
|
|
184
|
+
return true;
|
|
185
|
+
}
|
|
186
|
+
else if (action.equals("setTravelModeForTask"))
|
|
187
|
+
{
|
|
188
|
+
setTravelModeForTask(args, callbackContext);
|
|
189
|
+
return true;
|
|
190
|
+
}
|
|
191
|
+
else if (action.equals("sendMessageToTask"))
|
|
192
|
+
{
|
|
193
|
+
sendMessageToTask(args, callbackContext);
|
|
194
|
+
return true;
|
|
195
|
+
}
|
|
196
|
+
else if (action.equals("confirmMessageRead"))
|
|
197
|
+
{
|
|
198
|
+
confirmMessageRead(args, callbackContext);
|
|
199
|
+
return true;
|
|
200
|
+
}
|
|
201
|
+
else if (action.equals("syncSessionsState"))
|
|
202
|
+
{
|
|
203
|
+
syncSessionsState(args, callbackContext);
|
|
204
|
+
return true;
|
|
205
|
+
}
|
|
206
|
+
else if (action.equals("syncSessionsStateLight"))
|
|
207
|
+
{
|
|
208
|
+
syncSessionsStateLight(args, callbackContext);
|
|
209
|
+
return true;
|
|
210
|
+
}
|
|
211
|
+
else if (action.equals("refreshSessions"))
|
|
212
|
+
{
|
|
213
|
+
refreshSessions(args, callbackContext);
|
|
214
|
+
return true;
|
|
215
|
+
}
|
|
216
|
+
else if (action.equals("updateSessionTasks"))
|
|
217
|
+
{
|
|
218
|
+
updateSessionTasks(args, callbackContext);
|
|
219
|
+
return true;
|
|
220
|
+
}
|
|
221
|
+
else if (action.equals("startEtaPlannerQuery"))
|
|
222
|
+
{
|
|
223
|
+
startEtaPlannerQuery(args, callbackContext);
|
|
224
|
+
return true;
|
|
225
|
+
}
|
|
226
|
+
else if (action.equals("abortEtaPlannerQuery"))
|
|
227
|
+
{
|
|
228
|
+
abortEtaPlannerQuery(args, callbackContext);
|
|
229
|
+
return true;
|
|
230
|
+
}
|
|
231
|
+
else if (action.equals("overrideLoggingLevels"))
|
|
232
|
+
{
|
|
233
|
+
overrideLoggingLevels(args, callbackContext);
|
|
234
|
+
return true;
|
|
235
|
+
}
|
|
236
|
+
else if (action.equals("setRemoteLoggingEnabled"))
|
|
237
|
+
{
|
|
238
|
+
setRemoteLoggingEnabled(args, callbackContext);
|
|
239
|
+
return true;
|
|
240
|
+
}
|
|
241
|
+
else if ( action.equals("refreshPickups") )
|
|
242
|
+
{
|
|
243
|
+
refreshPickups(args, callbackContext);
|
|
244
|
+
return true;
|
|
245
|
+
}
|
|
246
|
+
else if ( action.equals("setPickupPhase") )
|
|
247
|
+
{
|
|
248
|
+
setPickupPhase(args, callbackContext);
|
|
249
|
+
return true;
|
|
250
|
+
}
|
|
251
|
+
else if ( action.equals("completePickup") )
|
|
252
|
+
{
|
|
253
|
+
completePickup(args, callbackContext);
|
|
254
|
+
return true;
|
|
255
|
+
}
|
|
256
|
+
else if ( action.equals("claimPickup") )
|
|
257
|
+
{
|
|
258
|
+
claimPickup(args, callbackContext);
|
|
259
|
+
return true;
|
|
260
|
+
}
|
|
261
|
+
else if ( action.equals("unclaimPickup") )
|
|
262
|
+
{
|
|
263
|
+
unclaimPickup(args, callbackContext);
|
|
264
|
+
return true;
|
|
265
|
+
}
|
|
266
|
+
else if ( action.equals("sendMessageToPickup") )
|
|
267
|
+
{
|
|
268
|
+
sendMessageToPickup(args, callbackContext);
|
|
269
|
+
return true;
|
|
270
|
+
}
|
|
271
|
+
else if ( action.equals("markMessagesAsRead") )
|
|
272
|
+
{
|
|
273
|
+
markMessagesAsRead(args, callbackContext);
|
|
274
|
+
return true;
|
|
275
|
+
}
|
|
276
|
+
else if ( action.equals("markTaskMessagesAsRead") )
|
|
277
|
+
{
|
|
278
|
+
markTaskMessagesAsRead(args, callbackContext);
|
|
279
|
+
return true;
|
|
280
|
+
}
|
|
281
|
+
else if (action.equals("syncPickupsState"))
|
|
282
|
+
{
|
|
283
|
+
syncPickupsState(args, callbackContext);
|
|
284
|
+
return true;
|
|
285
|
+
}
|
|
286
|
+
else if (action.equals("syncPickupsStateLight"))
|
|
287
|
+
{
|
|
288
|
+
syncPickupsStateLight(args, callbackContext);
|
|
289
|
+
return true;
|
|
290
|
+
}
|
|
291
|
+
else if (action.equals("syncPickup"))
|
|
292
|
+
{
|
|
293
|
+
syncPickup(args, callbackContext);
|
|
294
|
+
return true;
|
|
295
|
+
}
|
|
296
|
+
else if (action.equals("startShift"))
|
|
297
|
+
{
|
|
298
|
+
startShift(args, callbackContext);
|
|
299
|
+
return true;
|
|
300
|
+
}
|
|
301
|
+
else if (action.equals("completeShift"))
|
|
302
|
+
{
|
|
303
|
+
completeShift(args, callbackContext);
|
|
304
|
+
return true;
|
|
305
|
+
}
|
|
306
|
+
else if (action.equals("checkGoogleLocationAccuracy"))
|
|
307
|
+
{
|
|
308
|
+
checkGoogleLocationAccuracy(args, callbackContext);
|
|
309
|
+
return true;
|
|
310
|
+
}
|
|
311
|
+
else if (action.equals("checkIsNetworkConstrained"))
|
|
312
|
+
{
|
|
313
|
+
checkIsNetworkConstrained(args, callbackContext);
|
|
314
|
+
return true;
|
|
315
|
+
}
|
|
316
|
+
else if (action.equals("checkCellularDataAvailable"))
|
|
317
|
+
{
|
|
318
|
+
checkCellularDataAvailable(args, callbackContext);
|
|
319
|
+
return true;
|
|
320
|
+
}
|
|
321
|
+
|
|
322
|
+
return false;
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
private synchronized void setActive(final JSONArray args, final CallbackContext callbackContext)
|
|
326
|
+
{
|
|
327
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
328
|
+
|
|
329
|
+
boolean active = false;
|
|
330
|
+
try
|
|
331
|
+
{
|
|
332
|
+
active = args.getBoolean(0);
|
|
333
|
+
}
|
|
334
|
+
catch (JSONException e)
|
|
335
|
+
{
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
manager.setActive(active);
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
private synchronized void setBaseUrl(final JSONArray args, final CallbackContext callbackContext)
|
|
342
|
+
{
|
|
343
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
344
|
+
|
|
345
|
+
String baseUrl = null;
|
|
346
|
+
try
|
|
347
|
+
{
|
|
348
|
+
baseUrl = args.getString(0);
|
|
349
|
+
}
|
|
350
|
+
catch (JSONException e)
|
|
351
|
+
{
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
if ( null != baseUrl )
|
|
355
|
+
{
|
|
356
|
+
manager.setBaseUrl(baseUrl);
|
|
357
|
+
}
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
private synchronized void setAuthenticationMode(final JSONArray args, final CallbackContext callbackContext)
|
|
361
|
+
{
|
|
362
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
363
|
+
|
|
364
|
+
int mode = 0;
|
|
365
|
+
try
|
|
366
|
+
{
|
|
367
|
+
mode = args.getInt(0);
|
|
368
|
+
}
|
|
369
|
+
catch (JSONException e)
|
|
370
|
+
{
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
manager.setAuthenticationMode(mode);
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
private synchronized void setFetchCompletedTasks(final JSONArray args, final CallbackContext callbackContext)
|
|
377
|
+
{
|
|
378
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
379
|
+
|
|
380
|
+
boolean enabled = false;
|
|
381
|
+
try
|
|
382
|
+
{
|
|
383
|
+
enabled = args.getBoolean(0);
|
|
384
|
+
}
|
|
385
|
+
catch (JSONException e)
|
|
386
|
+
{
|
|
387
|
+
}
|
|
388
|
+
|
|
389
|
+
manager.getTaskManager().setFetchCompletedTasks(enabled);
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
private synchronized void registerDeviceToken(final JSONArray args, final CallbackContext callbackContext)
|
|
393
|
+
{
|
|
394
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
395
|
+
|
|
396
|
+
String tokenType = null;
|
|
397
|
+
String deviceToken = null;
|
|
398
|
+
try
|
|
399
|
+
{
|
|
400
|
+
tokenType = args.getString(0);
|
|
401
|
+
deviceToken = args.getString(1);
|
|
402
|
+
}
|
|
403
|
+
catch (JSONException e)
|
|
404
|
+
{
|
|
405
|
+
}
|
|
406
|
+
|
|
407
|
+
if ( null != tokenType && null != deviceToken )
|
|
408
|
+
{
|
|
409
|
+
manager.registerDeviceToken(tokenType, deviceToken);
|
|
410
|
+
}
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
private synchronized void handleRemoteNotification(final JSONArray args, final CallbackContext callbackContext)
|
|
414
|
+
{
|
|
415
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
416
|
+
|
|
417
|
+
String payload = null;
|
|
418
|
+
String deviceToken = null;
|
|
419
|
+
try
|
|
420
|
+
{
|
|
421
|
+
payload = args.getString(0);
|
|
422
|
+
deviceToken = args.getString(1);
|
|
423
|
+
}
|
|
424
|
+
catch (JSONException e)
|
|
425
|
+
{
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
if ( null != payload )
|
|
429
|
+
{
|
|
430
|
+
manager.handleRemoteNotification(payload);
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
|
|
434
|
+
private synchronized void registerListener(final JSONArray args, final CallbackContext callbackContext)
|
|
435
|
+
{
|
|
436
|
+
_listeners.add(callbackContext);
|
|
437
|
+
}
|
|
438
|
+
|
|
439
|
+
private synchronized void syncAccountState(final JSONArray args, final CallbackContext callbackContext)
|
|
440
|
+
{
|
|
441
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
442
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
443
|
+
|
|
444
|
+
result.put("loginNeeded", manager.isLoginNeeded());
|
|
445
|
+
result.put("started", manager.isStarted());
|
|
446
|
+
|
|
447
|
+
GAgent agent = manager.getLoggedInAgent();
|
|
448
|
+
if ( null != agent )
|
|
449
|
+
{
|
|
450
|
+
GPrimitive agentPrimitive = commonObjToPrimitive(agent);
|
|
451
|
+
result.put("loggedInAgent", agentPrimitive);
|
|
452
|
+
result.put("onShiftModified", agent.getOnShiftModified());
|
|
453
|
+
}
|
|
454
|
+
|
|
455
|
+
GOrganization org = manager.getOrganization();
|
|
456
|
+
if ( null != org )
|
|
457
|
+
{
|
|
458
|
+
GPrimitive orgPrimitive = commonObjToPrimitive(org);
|
|
459
|
+
result.put("loggedInOrg", orgPrimitive);
|
|
460
|
+
}
|
|
461
|
+
|
|
462
|
+
String authToken = manager.getEnRouteToken();
|
|
463
|
+
if ( null != authToken )
|
|
464
|
+
{
|
|
465
|
+
result.put("authToken", authToken);
|
|
466
|
+
}
|
|
467
|
+
|
|
468
|
+
String baseUrl = manager.getBaseUrl();
|
|
469
|
+
if ( null != baseUrl )
|
|
470
|
+
{
|
|
471
|
+
result.put("baseUrl", baseUrl);
|
|
472
|
+
}
|
|
473
|
+
|
|
474
|
+
GGlympse glympse = manager.getGlympse();
|
|
475
|
+
if ( null != glympse )
|
|
476
|
+
{
|
|
477
|
+
GLocationManager locationManager = manager.getGlympse().getLocationManager();
|
|
478
|
+
int locationAccuracyAuth = locationManager.getLocationAccuracyAuthorization();
|
|
479
|
+
result.put("isLocationAccuracyAuthFull", locationAccuracyAuth == CoreConstants.LOCATION_ACCURACY_AUTH_FULL);
|
|
480
|
+
}
|
|
481
|
+
|
|
482
|
+
result.put("authenticationMode", manager.getAuthenticationMode());
|
|
483
|
+
result.put("isOnShift", manager.isOnShift());
|
|
484
|
+
|
|
485
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
486
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
487
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
488
|
+
}
|
|
489
|
+
|
|
490
|
+
private synchronized void syncHealthReport(final JSONArray args, final CallbackContext callbackContext)
|
|
491
|
+
{
|
|
492
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
493
|
+
GEnRouteHealthCheck enRouteHealthCheck = manager.getEnRouteHealthCheck();
|
|
494
|
+
GCoreHealthCheck coreHealthCheck = manager.getGlympse().getCoreHealthCheck();
|
|
495
|
+
|
|
496
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
497
|
+
|
|
498
|
+
// En Route checks
|
|
499
|
+
GHealthReport healthReport = enRouteHealthCheck.checkLoggedInState();
|
|
500
|
+
GPrimitive value = healthReport.getValue();
|
|
501
|
+
result.put("isLoginNeeded", value.getBool());
|
|
502
|
+
|
|
503
|
+
healthReport = enRouteHealthCheck.checkSharingCompliance();
|
|
504
|
+
value = healthReport.getValue();
|
|
505
|
+
result.put("sharingCompliance", value.getBool());
|
|
506
|
+
|
|
507
|
+
// Core checks
|
|
508
|
+
healthReport = coreHealthCheck.checkLocationAuth();
|
|
509
|
+
value = healthReport.getValue();
|
|
510
|
+
result.put("locationAuth", value.getLong());
|
|
511
|
+
|
|
512
|
+
healthReport = coreHealthCheck.checkNotificationAuth();
|
|
513
|
+
value = healthReport.getValue();
|
|
514
|
+
result.put("notificationAuth", value.getLong());
|
|
515
|
+
|
|
516
|
+
healthReport = coreHealthCheck.checkBatteryOptimization();
|
|
517
|
+
value = healthReport.getValue();
|
|
518
|
+
result.put("batteryOptimization", value.getBool());
|
|
519
|
+
|
|
520
|
+
healthReport = coreHealthCheck.checkLocationAccuracyAuth();
|
|
521
|
+
value = healthReport.getValue();
|
|
522
|
+
result.put("locationAccuracy", value.getLong());
|
|
523
|
+
|
|
524
|
+
healthReport = coreHealthCheck.checkMobileDataAvailability();
|
|
525
|
+
value = healthReport.getValue();
|
|
526
|
+
result.put("mobileData", value.getLong());
|
|
527
|
+
|
|
528
|
+
healthReport = coreHealthCheck.checkRestrictBackgroundStatus();
|
|
529
|
+
value = healthReport.getValue();
|
|
530
|
+
result.put("restrictBackground", value.getLong());
|
|
531
|
+
|
|
532
|
+
healthReport = coreHealthCheck.checkIsWifiScanningEnabled();
|
|
533
|
+
value = healthReport.getValue();
|
|
534
|
+
result.put("wifiScanning", value.getBool());
|
|
535
|
+
|
|
536
|
+
healthReport = coreHealthCheck.checkIsBluetoothScanningEnabled();
|
|
537
|
+
value = healthReport.getValue();
|
|
538
|
+
result.put("btScanning", value.getBool());
|
|
539
|
+
|
|
540
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
541
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
542
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
543
|
+
}
|
|
544
|
+
|
|
545
|
+
private synchronized void start(final JSONArray args, final CallbackContext callbackContext)
|
|
546
|
+
{
|
|
547
|
+
subscribeToListeners();
|
|
548
|
+
ManagerWrapper.instance().manager().start();
|
|
549
|
+
}
|
|
550
|
+
|
|
551
|
+
private synchronized void loginWithCredentials(final JSONArray args, final CallbackContext callbackContext)
|
|
552
|
+
{
|
|
553
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
554
|
+
_callbacks.put(COMMAND_KEY_LOGIN, callbackContext);
|
|
555
|
+
|
|
556
|
+
String username = null;
|
|
557
|
+
String password = null;
|
|
558
|
+
try
|
|
559
|
+
{
|
|
560
|
+
username = args.getString(0);
|
|
561
|
+
password = args.getString(1);
|
|
562
|
+
}
|
|
563
|
+
catch (JSONException e)
|
|
564
|
+
{
|
|
565
|
+
}
|
|
566
|
+
|
|
567
|
+
boolean result = manager.loginWithCredentials(username, password);
|
|
568
|
+
if ( !result )
|
|
569
|
+
{
|
|
570
|
+
loginCompleted(false, "loginWithCredentials() failed validation");
|
|
571
|
+
}
|
|
572
|
+
}
|
|
573
|
+
|
|
574
|
+
private synchronized void loginWithToken(final JSONArray args, final CallbackContext callbackContext)
|
|
575
|
+
{
|
|
576
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
577
|
+
_callbacks.put(COMMAND_KEY_LOGIN, callbackContext);
|
|
578
|
+
|
|
579
|
+
String token = null;
|
|
580
|
+
long expireTime = 0;
|
|
581
|
+
try
|
|
582
|
+
{
|
|
583
|
+
token = args.getString(0);
|
|
584
|
+
expireTime = args.getLong(1);
|
|
585
|
+
}
|
|
586
|
+
catch (JSONException e)
|
|
587
|
+
{
|
|
588
|
+
}
|
|
589
|
+
|
|
590
|
+
boolean result = manager.loginWithToken(token, expireTime);
|
|
591
|
+
if ( !result )
|
|
592
|
+
{
|
|
593
|
+
loginCompleted(false, "loginWithToken() failed validation");
|
|
594
|
+
}
|
|
595
|
+
}
|
|
596
|
+
|
|
597
|
+
private synchronized void logout(final JSONArray args, final CallbackContext callbackContext)
|
|
598
|
+
{
|
|
599
|
+
_callbacks.put(COMMAND_KEY_LOGOUT, callbackContext);
|
|
600
|
+
|
|
601
|
+
ManagerWrapper.instance().logout();
|
|
602
|
+
}
|
|
603
|
+
|
|
604
|
+
private synchronized void logoutWithReason(final JSONArray args, final CallbackContext callbackContext)
|
|
605
|
+
{
|
|
606
|
+
_callbacks.put(COMMAND_KEY_LOGOUT, callbackContext);
|
|
607
|
+
|
|
608
|
+
int reason = EnRouteConstants.LOGOUT_REASON_UNKNOWN;
|
|
609
|
+
try
|
|
610
|
+
{
|
|
611
|
+
reason = args.getInt(0);
|
|
612
|
+
}
|
|
613
|
+
catch(JSONException e)
|
|
614
|
+
{
|
|
615
|
+
}
|
|
616
|
+
|
|
617
|
+
ManagerWrapper.instance().logout(reason);
|
|
618
|
+
}
|
|
619
|
+
|
|
620
|
+
private synchronized void stop(final JSONArray args, final CallbackContext callbackContext)
|
|
621
|
+
{
|
|
622
|
+
ManagerWrapper.instance().manager().stop();
|
|
623
|
+
}
|
|
624
|
+
|
|
625
|
+
private synchronized void syncTasksState(final JSONArray args, final CallbackContext callbackContext)
|
|
626
|
+
{
|
|
627
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
628
|
+
|
|
629
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
630
|
+
|
|
631
|
+
if ( manager.isStarted() )
|
|
632
|
+
{
|
|
633
|
+
GArray<GTask> tasks = manager.getTaskManager().getTasks();
|
|
634
|
+
if ( null != tasks )
|
|
635
|
+
{
|
|
636
|
+
GPrimitive tasksPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_ARRAY);
|
|
637
|
+
|
|
638
|
+
GPrimitive config = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
639
|
+
config.put("truncate_locations", true);
|
|
640
|
+
|
|
641
|
+
GChatManager chatManager = manager.getGlympse().getChatManager();
|
|
642
|
+
for ( GTask task : tasks )
|
|
643
|
+
{
|
|
644
|
+
GPrimitive taskPrimitive = commonObjToPrimitive(task, config);
|
|
645
|
+
|
|
646
|
+
String chatRoomId = task.getChatRoomId();
|
|
647
|
+
if ( null != chatRoomId )
|
|
648
|
+
{
|
|
649
|
+
GChatRoom chatRoom = chatManager.getChatRoom(chatRoomId);
|
|
650
|
+
if ( null != chatRoom )
|
|
651
|
+
{
|
|
652
|
+
GArray<GChatMessage> messages = chatRoom.getChatMessages();
|
|
653
|
+
|
|
654
|
+
GPrimitive chatMessagesPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_ARRAY);
|
|
655
|
+
for ( GChatMessage chatMessage : messages )
|
|
656
|
+
{
|
|
657
|
+
GPrimitive chatMessagePrimitive = commonObjToPrimitive(chatMessage);
|
|
658
|
+
chatMessagesPrimitive.put(chatMessagePrimitive);
|
|
659
|
+
}
|
|
660
|
+
|
|
661
|
+
taskPrimitive.put("chatMessages", chatMessagesPrimitive);
|
|
662
|
+
taskPrimitive.put("lastReadSequenceNumber", chatRoom.getLastReadSequenceNumber());
|
|
663
|
+
}
|
|
664
|
+
}
|
|
665
|
+
|
|
666
|
+
String travelMode = manager.getTaskManager().getTravelModeForTask(task);
|
|
667
|
+
taskPrimitive.put("travelMode", travelMode);
|
|
668
|
+
|
|
669
|
+
tasksPrimitive.put(taskPrimitive);
|
|
670
|
+
}
|
|
671
|
+
|
|
672
|
+
result.put("tasks", tasksPrimitive);
|
|
673
|
+
}
|
|
674
|
+
}
|
|
675
|
+
|
|
676
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
677
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
678
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
679
|
+
}
|
|
680
|
+
|
|
681
|
+
private synchronized void syncTasksStateLight(final JSONArray args, final CallbackContext callbackContext)
|
|
682
|
+
{
|
|
683
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
684
|
+
|
|
685
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
686
|
+
|
|
687
|
+
if ( manager.isStarted() )
|
|
688
|
+
{
|
|
689
|
+
GArray<GTask> tasks = manager.getTaskManager().getTasks();
|
|
690
|
+
if ( null != tasks )
|
|
691
|
+
{
|
|
692
|
+
GPrimitive tasksPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
693
|
+
|
|
694
|
+
GPrimitive config = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
695
|
+
config.put("truncate_locations", true);
|
|
696
|
+
config.put("ticket_light", true);
|
|
697
|
+
|
|
698
|
+
for ( GTask task : tasks )
|
|
699
|
+
{
|
|
700
|
+
GOperation operation = task.getOperation();
|
|
701
|
+
|
|
702
|
+
if ( null != operation )
|
|
703
|
+
{
|
|
704
|
+
GPrimitive taskData = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
705
|
+
taskData.put("phase", task.getPhase());
|
|
706
|
+
|
|
707
|
+
GTicket ticket = operation.getTicket();
|
|
708
|
+
if ( null != ticket )
|
|
709
|
+
{
|
|
710
|
+
taskData.put("ticket", commonObjToPrimitive(operation.getTicket(), config));
|
|
711
|
+
}
|
|
712
|
+
taskData.put("ticketVisible", operation.isTicketVisible());
|
|
713
|
+
tasksPrimitive.put("" + task.getId(), taskData);
|
|
714
|
+
}
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
result.put("tasks_data", tasksPrimitive);
|
|
718
|
+
}
|
|
719
|
+
}
|
|
720
|
+
|
|
721
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
722
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
723
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
724
|
+
}
|
|
725
|
+
|
|
726
|
+
private synchronized void refreshTasks(final JSONArray args, final CallbackContext callbackContext)
|
|
727
|
+
{
|
|
728
|
+
ManagerWrapper.instance().manager().refresh();
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
private synchronized void startTask(final JSONArray args, final CallbackContext callbackContext)
|
|
732
|
+
{
|
|
733
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
734
|
+
long taskId = -1;
|
|
735
|
+
int duration = 4 * 60 * 60 * 1000;
|
|
736
|
+
try
|
|
737
|
+
{
|
|
738
|
+
taskId = args.getLong(0);
|
|
739
|
+
duration = args.getInt(1);
|
|
740
|
+
}
|
|
741
|
+
catch (JSONException e)
|
|
742
|
+
{
|
|
743
|
+
}
|
|
744
|
+
|
|
745
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
746
|
+
if ( null == task )
|
|
747
|
+
{
|
|
748
|
+
return;
|
|
749
|
+
}
|
|
750
|
+
|
|
751
|
+
manager.getTaskManager().startTask(task, duration);
|
|
752
|
+
}
|
|
753
|
+
|
|
754
|
+
private synchronized void createTask(final JSONArray args, final CallbackContext callbackContext)
|
|
755
|
+
{
|
|
756
|
+
|
|
757
|
+
GPrimitive taskData = null;
|
|
758
|
+
|
|
759
|
+
try
|
|
760
|
+
{
|
|
761
|
+
String valueString = args.getString(0);
|
|
762
|
+
taskData = CoreTools.stringToPrimitive(valueString);
|
|
763
|
+
}
|
|
764
|
+
catch (JSONException e)
|
|
765
|
+
{
|
|
766
|
+
}
|
|
767
|
+
|
|
768
|
+
if ( null == taskData )
|
|
769
|
+
{
|
|
770
|
+
return;
|
|
771
|
+
}
|
|
772
|
+
|
|
773
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
774
|
+
manager.getTaskManager().createTask(taskData, true);
|
|
775
|
+
}
|
|
776
|
+
|
|
777
|
+
private synchronized void setTaskPhase(final JSONArray args, final CallbackContext callbackContext)
|
|
778
|
+
{
|
|
779
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
780
|
+
long taskId = -1;
|
|
781
|
+
String phase = "";
|
|
782
|
+
|
|
783
|
+
try
|
|
784
|
+
{
|
|
785
|
+
taskId = args.getLong(0);
|
|
786
|
+
phase = args.getString(1);
|
|
787
|
+
}
|
|
788
|
+
catch (JSONException e)
|
|
789
|
+
{
|
|
790
|
+
}
|
|
791
|
+
|
|
792
|
+
if ( "".equals(phase) )
|
|
793
|
+
{
|
|
794
|
+
return;
|
|
795
|
+
}
|
|
796
|
+
|
|
797
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
798
|
+
if ( null == task )
|
|
799
|
+
{
|
|
800
|
+
return;
|
|
801
|
+
}
|
|
802
|
+
|
|
803
|
+
manager.getTaskManager().setTaskPhase(task, phase);
|
|
804
|
+
}
|
|
805
|
+
|
|
806
|
+
private synchronized void setTaskVisibility(final JSONArray args, final CallbackContext callbackContext)
|
|
807
|
+
{
|
|
808
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
809
|
+
long taskId = args.optLong(0, -1);
|
|
810
|
+
String visibleString = args.optString(1, "");
|
|
811
|
+
|
|
812
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
813
|
+
if ( null == task )
|
|
814
|
+
{
|
|
815
|
+
return;
|
|
816
|
+
}
|
|
817
|
+
|
|
818
|
+
GOperation operation = task.getOperation();
|
|
819
|
+
if ( null == operation )
|
|
820
|
+
{
|
|
821
|
+
return;
|
|
822
|
+
}
|
|
823
|
+
|
|
824
|
+
operation.setTicketVisible(visibleString);
|
|
825
|
+
}
|
|
826
|
+
|
|
827
|
+
private synchronized void completeTask(final JSONArray args, final CallbackContext callbackContext)
|
|
828
|
+
{
|
|
829
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
830
|
+
long taskId = -1;
|
|
831
|
+
|
|
832
|
+
try
|
|
833
|
+
{
|
|
834
|
+
taskId = args.getLong(0);
|
|
835
|
+
}
|
|
836
|
+
catch (JSONException e)
|
|
837
|
+
{
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
841
|
+
if ( null == task )
|
|
842
|
+
{
|
|
843
|
+
return;
|
|
844
|
+
}
|
|
845
|
+
|
|
846
|
+
GOperation operation = task.getOperation();
|
|
847
|
+
if ( null == operation )
|
|
848
|
+
{
|
|
849
|
+
return;
|
|
850
|
+
}
|
|
851
|
+
|
|
852
|
+
manager.getTaskManager().completeOperation(operation);
|
|
853
|
+
}
|
|
854
|
+
|
|
855
|
+
private synchronized void addOrUpdateMetadataItem(final JSONArray args, final CallbackContext callbackContext)
|
|
856
|
+
{
|
|
857
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
858
|
+
long taskId = -1;
|
|
859
|
+
String key = null;
|
|
860
|
+
GPrimitive valuePrim = null;
|
|
861
|
+
|
|
862
|
+
try
|
|
863
|
+
{
|
|
864
|
+
taskId = args.getLong(0);
|
|
865
|
+
key = args.getString(1);
|
|
866
|
+
valuePrim = commonObjToPrimitive(args.get(2));
|
|
867
|
+
}
|
|
868
|
+
catch (JSONException e)
|
|
869
|
+
{
|
|
870
|
+
}
|
|
871
|
+
|
|
872
|
+
if ( null == key || null == valuePrim )
|
|
873
|
+
{
|
|
874
|
+
return;
|
|
875
|
+
}
|
|
876
|
+
|
|
877
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
878
|
+
if ( null == task )
|
|
879
|
+
{
|
|
880
|
+
return;
|
|
881
|
+
}
|
|
882
|
+
|
|
883
|
+
manager.getTaskManager().addOrUpdateMetadataItem(task, key, valuePrim);
|
|
884
|
+
}
|
|
885
|
+
|
|
886
|
+
private synchronized void setTravelModeForTask(final JSONArray args, final CallbackContext callbackContext)
|
|
887
|
+
{
|
|
888
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
889
|
+
long taskId = -1;
|
|
890
|
+
String travelMode = null;
|
|
891
|
+
|
|
892
|
+
try
|
|
893
|
+
{
|
|
894
|
+
taskId = args.getLong(0);
|
|
895
|
+
travelMode = args.getString(1);
|
|
896
|
+
}
|
|
897
|
+
catch (JSONException e)
|
|
898
|
+
{
|
|
899
|
+
}
|
|
900
|
+
|
|
901
|
+
if ( null == travelMode )
|
|
902
|
+
{
|
|
903
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
904
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
905
|
+
return;
|
|
906
|
+
}
|
|
907
|
+
|
|
908
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
909
|
+
if ( null == task )
|
|
910
|
+
{
|
|
911
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
912
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
913
|
+
return;
|
|
914
|
+
}
|
|
915
|
+
|
|
916
|
+
manager.getTaskManager().setTravelModeForTask(task, travelMode);
|
|
917
|
+
}
|
|
918
|
+
|
|
919
|
+
private synchronized void sendMessageToTask(final JSONArray args, final CallbackContext callbackContext)
|
|
920
|
+
{
|
|
921
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
922
|
+
long taskId = -1;
|
|
923
|
+
String message = null;
|
|
924
|
+
long predefinedMessageId = -1;
|
|
925
|
+
|
|
926
|
+
try
|
|
927
|
+
{
|
|
928
|
+
taskId = args.getLong(0);
|
|
929
|
+
message = args.getString(1);
|
|
930
|
+
predefinedMessageId = args.getLong(2);
|
|
931
|
+
}
|
|
932
|
+
catch (JSONException e)
|
|
933
|
+
{
|
|
934
|
+
}
|
|
935
|
+
|
|
936
|
+
if ( null == message )
|
|
937
|
+
{
|
|
938
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
939
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
940
|
+
return;
|
|
941
|
+
}
|
|
942
|
+
|
|
943
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
944
|
+
if ( null == task )
|
|
945
|
+
{
|
|
946
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
947
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
948
|
+
return;
|
|
949
|
+
}
|
|
950
|
+
|
|
951
|
+
boolean result = manager.getTaskManager().sendMessage(task, message, predefinedMessageId);
|
|
952
|
+
if ( !result )
|
|
953
|
+
{
|
|
954
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
955
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
956
|
+
return;
|
|
957
|
+
}
|
|
958
|
+
|
|
959
|
+
PluginResult pluginResult = new PluginResult(Status.OK);
|
|
960
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
961
|
+
}
|
|
962
|
+
|
|
963
|
+
private synchronized void markTaskMessagesAsRead(final JSONArray args, final CallbackContext callbackContext)
|
|
964
|
+
{
|
|
965
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
966
|
+
long taskId = -1;
|
|
967
|
+
|
|
968
|
+
try
|
|
969
|
+
{
|
|
970
|
+
taskId = args.getLong(0);
|
|
971
|
+
}
|
|
972
|
+
catch (JSONException e)
|
|
973
|
+
{
|
|
974
|
+
}
|
|
975
|
+
|
|
976
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
977
|
+
if ( null == task )
|
|
978
|
+
{
|
|
979
|
+
return;
|
|
980
|
+
}
|
|
981
|
+
|
|
982
|
+
String chatRoomId = task.getChatRoomId();
|
|
983
|
+
if ( null == chatRoomId )
|
|
984
|
+
{
|
|
985
|
+
return;
|
|
986
|
+
}
|
|
987
|
+
|
|
988
|
+
GChatManager chatManager = manager.getGlympse().getChatManager();
|
|
989
|
+
chatManager.setRoomAsRead(chatRoomId);
|
|
990
|
+
}
|
|
991
|
+
|
|
992
|
+
// Deprecated
|
|
993
|
+
private synchronized void confirmMessageRead(final JSONArray args, final CallbackContext callbackContext)
|
|
994
|
+
{
|
|
995
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
996
|
+
long taskId = -1;
|
|
997
|
+
String messageId = null;
|
|
998
|
+
|
|
999
|
+
try
|
|
1000
|
+
{
|
|
1001
|
+
taskId = args.getLong(0);
|
|
1002
|
+
messageId = args.getString(1);
|
|
1003
|
+
}
|
|
1004
|
+
catch (JSONException e)
|
|
1005
|
+
{
|
|
1006
|
+
}
|
|
1007
|
+
|
|
1008
|
+
if ( null == messageId )
|
|
1009
|
+
{
|
|
1010
|
+
return;
|
|
1011
|
+
}
|
|
1012
|
+
|
|
1013
|
+
GTask task = manager.getTaskManager().findTaskById(taskId);
|
|
1014
|
+
if ( null == task )
|
|
1015
|
+
{
|
|
1016
|
+
return;
|
|
1017
|
+
}
|
|
1018
|
+
|
|
1019
|
+
GCardMessages cardMessages = manager.getTaskManager().getCardMessagesForTask(task);
|
|
1020
|
+
if ( null == cardMessages )
|
|
1021
|
+
{
|
|
1022
|
+
return;
|
|
1023
|
+
}
|
|
1024
|
+
|
|
1025
|
+
cardMessages.confirmRead(messageId);
|
|
1026
|
+
}
|
|
1027
|
+
|
|
1028
|
+
private synchronized void syncSessionsState(final JSONArray args, final CallbackContext callbackContext)
|
|
1029
|
+
{
|
|
1030
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1031
|
+
|
|
1032
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1033
|
+
|
|
1034
|
+
if ( manager.isStarted() )
|
|
1035
|
+
{
|
|
1036
|
+
GSessionManager sessionManager = manager.getSessionManager();
|
|
1037
|
+
if ( null != sessionManager )
|
|
1038
|
+
{
|
|
1039
|
+
GArray<GSession> sessions = sessionManager.getSessions();
|
|
1040
|
+
if ( null != sessions )
|
|
1041
|
+
{
|
|
1042
|
+
GPrimitive sessionsPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_ARRAY);
|
|
1043
|
+
|
|
1044
|
+
for ( GSession session : sessions )
|
|
1045
|
+
{
|
|
1046
|
+
GPrimitive sessionPrimitive = commonObjToPrimitive(session);
|
|
1047
|
+
sessionsPrimitive.put(sessionPrimitive);
|
|
1048
|
+
}
|
|
1049
|
+
|
|
1050
|
+
result.put("sessions", sessionsPrimitive);
|
|
1051
|
+
}
|
|
1052
|
+
}
|
|
1053
|
+
}
|
|
1054
|
+
|
|
1055
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
1056
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
1057
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1058
|
+
}
|
|
1059
|
+
|
|
1060
|
+
private synchronized void syncSessionsStateLight(final JSONArray args, final CallbackContext callbackContext)
|
|
1061
|
+
{
|
|
1062
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1063
|
+
|
|
1064
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1065
|
+
|
|
1066
|
+
if ( manager.isStarted() )
|
|
1067
|
+
{
|
|
1068
|
+
GSessionManager sessionManager = manager.getSessionManager();
|
|
1069
|
+
if ( null != sessionManager )
|
|
1070
|
+
{
|
|
1071
|
+
GArray<GSession> sessions = sessionManager.getSessions();
|
|
1072
|
+
if ( null != sessions )
|
|
1073
|
+
{
|
|
1074
|
+
GPrimitive sessionsPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1075
|
+
|
|
1076
|
+
for ( GSession session : sessions )
|
|
1077
|
+
{
|
|
1078
|
+
GOperation operation = session.getOperation();
|
|
1079
|
+
if ( null != operation )
|
|
1080
|
+
{
|
|
1081
|
+
GPrimitive sessionData = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1082
|
+
|
|
1083
|
+
GTicket ticket = operation.getTicket();
|
|
1084
|
+
if ( null != ticket )
|
|
1085
|
+
{
|
|
1086
|
+
sessionData.put("ticket", commonObjToPrimitive(operation.getTicket()));
|
|
1087
|
+
}
|
|
1088
|
+
|
|
1089
|
+
sessionData.put("ticketVisible", operation.isTicketVisible());
|
|
1090
|
+
|
|
1091
|
+
sessionsPrimitive.put("" + session.getId(), sessionData);
|
|
1092
|
+
}
|
|
1093
|
+
}
|
|
1094
|
+
|
|
1095
|
+
result.put("sessions_data", sessionsPrimitive);
|
|
1096
|
+
}
|
|
1097
|
+
}
|
|
1098
|
+
}
|
|
1099
|
+
|
|
1100
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
1101
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
1102
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1103
|
+
}
|
|
1104
|
+
|
|
1105
|
+
private synchronized void refreshSessions(final JSONArray args, final CallbackContext callbackContext)
|
|
1106
|
+
{
|
|
1107
|
+
// TODO: Should we be refreshing just the session manager, or should we refresh EnRouteManager and let it decide to refresh tasks or sessions?
|
|
1108
|
+
GSessionManager sessionManager = ManagerWrapper.instance().manager().getSessionManager();
|
|
1109
|
+
if ( null != sessionManager )
|
|
1110
|
+
{
|
|
1111
|
+
sessionManager.refresh();
|
|
1112
|
+
}
|
|
1113
|
+
}
|
|
1114
|
+
|
|
1115
|
+
private synchronized void updateSessionTasks(final JSONArray args, final CallbackContext callbackContext)
|
|
1116
|
+
{
|
|
1117
|
+
GSessionManager sessionManager = ManagerWrapper.instance().manager().getSessionManager();
|
|
1118
|
+
if ( null == sessionManager )
|
|
1119
|
+
{
|
|
1120
|
+
return;
|
|
1121
|
+
}
|
|
1122
|
+
|
|
1123
|
+
long sessionId = args.optLong(0, -1);
|
|
1124
|
+
GSession session = sessionManager.findSessionById(sessionId);
|
|
1125
|
+
if ( null == session )
|
|
1126
|
+
{
|
|
1127
|
+
return;
|
|
1128
|
+
}
|
|
1129
|
+
|
|
1130
|
+
JSONArray taskArray = args.optJSONArray(1);
|
|
1131
|
+
|
|
1132
|
+
GVector<Object> tasks = CoreFactory.createVector();
|
|
1133
|
+
|
|
1134
|
+
for ( int i = 0; i < taskArray.length(); i++ )
|
|
1135
|
+
{
|
|
1136
|
+
long taskId = taskArray.optLong(i, -1);
|
|
1137
|
+
GTask task = ManagerWrapper.instance().manager().getTaskManager().findTaskById(taskId);
|
|
1138
|
+
tasks.addElement(task);
|
|
1139
|
+
}
|
|
1140
|
+
|
|
1141
|
+
sessionManager.updateSessionTasks(session, tasks);
|
|
1142
|
+
}
|
|
1143
|
+
|
|
1144
|
+
private synchronized void startEtaPlannerQuery(final JSONArray args, final CallbackContext callbackContext)
|
|
1145
|
+
{
|
|
1146
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1147
|
+
GEtaPlanner etaPlanner = manager.getEtaPlanner();
|
|
1148
|
+
etaPlanner.addListener(this);
|
|
1149
|
+
|
|
1150
|
+
JSONObject initial = args.optJSONObject(0);
|
|
1151
|
+
JSONArray places = args.optJSONArray(1);
|
|
1152
|
+
long stopoverTime = args.optLong(2, 0);
|
|
1153
|
+
|
|
1154
|
+
if ( null != initial && null != places )
|
|
1155
|
+
{
|
|
1156
|
+
double lat = initial.optDouble("latitude", 0);
|
|
1157
|
+
double lng = initial.optDouble("longitude", 0);
|
|
1158
|
+
|
|
1159
|
+
GLatLng start = CoreFactory.createLocation(lat, lng);
|
|
1160
|
+
GVector<Object> stops = CoreFactory.createVector();
|
|
1161
|
+
|
|
1162
|
+
for ( int i = 0; i < places.length(); i++ )
|
|
1163
|
+
{
|
|
1164
|
+
JSONObject place = places.optJSONObject(i);
|
|
1165
|
+
|
|
1166
|
+
lat = place.optDouble("latitude", 0);
|
|
1167
|
+
lng = place.optDouble("longitude", 0);
|
|
1168
|
+
|
|
1169
|
+
GLatLng stop = CoreFactory.createLocation(lat, lng);
|
|
1170
|
+
stops.addElement(stop);
|
|
1171
|
+
}
|
|
1172
|
+
|
|
1173
|
+
etaPlanner.query(start, stops, stopoverTime);
|
|
1174
|
+
}
|
|
1175
|
+
}
|
|
1176
|
+
|
|
1177
|
+
private synchronized void abortEtaPlannerQuery(final JSONArray args, final CallbackContext callbackContext)
|
|
1178
|
+
{
|
|
1179
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1180
|
+
GEtaPlanner etaPlanner = manager.getEtaPlanner();
|
|
1181
|
+
etaPlanner.removeListener(this);
|
|
1182
|
+
|
|
1183
|
+
etaPlanner.abort();
|
|
1184
|
+
}
|
|
1185
|
+
|
|
1186
|
+
private synchronized void overrideLoggingLevels(final JSONArray args, final CallbackContext callbackContext)
|
|
1187
|
+
{
|
|
1188
|
+
int fileLogLevel = CoreConstants.NONE;
|
|
1189
|
+
int debugLogLevel = CoreConstants.NONE;
|
|
1190
|
+
try
|
|
1191
|
+
{
|
|
1192
|
+
fileLogLevel = args.getInt(0);
|
|
1193
|
+
debugLogLevel = args.getInt(1);
|
|
1194
|
+
}
|
|
1195
|
+
catch (JSONException e)
|
|
1196
|
+
{
|
|
1197
|
+
}
|
|
1198
|
+
ManagerWrapper.instance().manager().overrideLoggingLevels(fileLogLevel, debugLogLevel);
|
|
1199
|
+
}
|
|
1200
|
+
|
|
1201
|
+
private synchronized void setRemoteLoggingEnabled(final JSONArray args, final CallbackContext callbackContext)
|
|
1202
|
+
{
|
|
1203
|
+
boolean enabled = false;
|
|
1204
|
+
try
|
|
1205
|
+
{
|
|
1206
|
+
enabled = args.getBoolean(0);
|
|
1207
|
+
}
|
|
1208
|
+
catch (JSONException e)
|
|
1209
|
+
{
|
|
1210
|
+
}
|
|
1211
|
+
ManagerWrapper.instance().manager().setRemoteLoggingEnabled(enabled);
|
|
1212
|
+
}
|
|
1213
|
+
|
|
1214
|
+
private synchronized void refreshPickups(final JSONArray args, final CallbackContext callbackContext)
|
|
1215
|
+
{
|
|
1216
|
+
GPickupManager pickupManager = ManagerWrapper.instance().manager().getPickupManager();
|
|
1217
|
+
if ( null != pickupManager )
|
|
1218
|
+
{
|
|
1219
|
+
pickupManager.refresh();
|
|
1220
|
+
}
|
|
1221
|
+
}
|
|
1222
|
+
|
|
1223
|
+
private synchronized void setPickupPhase(final JSONArray args, final CallbackContext callbackContext)
|
|
1224
|
+
{
|
|
1225
|
+
GPickupManager pickupManager = ManagerWrapper.instance().manager().getPickupManager();
|
|
1226
|
+
if ( null == pickupManager )
|
|
1227
|
+
{
|
|
1228
|
+
return;
|
|
1229
|
+
}
|
|
1230
|
+
String pickupId = null;
|
|
1231
|
+
String phase = "";
|
|
1232
|
+
|
|
1233
|
+
try
|
|
1234
|
+
{
|
|
1235
|
+
pickupId = args.getString(0);
|
|
1236
|
+
phase = args.getString(1);
|
|
1237
|
+
}
|
|
1238
|
+
catch (JSONException e)
|
|
1239
|
+
{
|
|
1240
|
+
}
|
|
1241
|
+
|
|
1242
|
+
if ( "".equals(phase) )
|
|
1243
|
+
{
|
|
1244
|
+
return;
|
|
1245
|
+
}
|
|
1246
|
+
|
|
1247
|
+
GPickup pickup = pickupManager.findPickupById(pickupId);
|
|
1248
|
+
if ( null == pickup )
|
|
1249
|
+
{
|
|
1250
|
+
return;
|
|
1251
|
+
}
|
|
1252
|
+
|
|
1253
|
+
pickupManager.setPickupPhase(pickup, phase);
|
|
1254
|
+
}
|
|
1255
|
+
|
|
1256
|
+
private synchronized void completePickup(final JSONArray args, final CallbackContext callbackContext)
|
|
1257
|
+
{
|
|
1258
|
+
GPickupManager pickupManager = ManagerWrapper.instance().manager().getPickupManager();
|
|
1259
|
+
if ( null == pickupManager )
|
|
1260
|
+
{
|
|
1261
|
+
return;
|
|
1262
|
+
}
|
|
1263
|
+
String pickupId = null;
|
|
1264
|
+
|
|
1265
|
+
try
|
|
1266
|
+
{
|
|
1267
|
+
pickupId = args.getString(0);
|
|
1268
|
+
}
|
|
1269
|
+
catch (JSONException e)
|
|
1270
|
+
{
|
|
1271
|
+
}
|
|
1272
|
+
|
|
1273
|
+
GPickup pickup = pickupManager.findPickupById(pickupId);
|
|
1274
|
+
if ( null == pickup )
|
|
1275
|
+
{
|
|
1276
|
+
return;
|
|
1277
|
+
}
|
|
1278
|
+
|
|
1279
|
+
pickupManager.completePickup(pickup);
|
|
1280
|
+
}
|
|
1281
|
+
|
|
1282
|
+
private synchronized void claimPickup(final JSONArray args, final CallbackContext callbackContext)
|
|
1283
|
+
{
|
|
1284
|
+
GPickupManager pickupManager = ManagerWrapper.instance().manager().getPickupManager();
|
|
1285
|
+
if ( null == pickupManager )
|
|
1286
|
+
{
|
|
1287
|
+
return;
|
|
1288
|
+
}
|
|
1289
|
+
String pickupId = null;
|
|
1290
|
+
|
|
1291
|
+
try
|
|
1292
|
+
{
|
|
1293
|
+
pickupId = args.getString(0);
|
|
1294
|
+
}
|
|
1295
|
+
catch (JSONException e)
|
|
1296
|
+
{
|
|
1297
|
+
}
|
|
1298
|
+
|
|
1299
|
+
GPickup pickup = pickupManager.findPickupById(pickupId);
|
|
1300
|
+
if ( null == pickup )
|
|
1301
|
+
{
|
|
1302
|
+
return;
|
|
1303
|
+
}
|
|
1304
|
+
|
|
1305
|
+
pickupManager.claimPickup(pickup);
|
|
1306
|
+
}
|
|
1307
|
+
|
|
1308
|
+
private synchronized void unclaimPickup(final JSONArray args, final CallbackContext callbackContext)
|
|
1309
|
+
{
|
|
1310
|
+
GPickupManager pickupManager = ManagerWrapper.instance().manager().getPickupManager();
|
|
1311
|
+
if ( null == pickupManager )
|
|
1312
|
+
{
|
|
1313
|
+
return;
|
|
1314
|
+
}
|
|
1315
|
+
String pickupId = null;
|
|
1316
|
+
|
|
1317
|
+
try
|
|
1318
|
+
{
|
|
1319
|
+
pickupId = args.getString(0);
|
|
1320
|
+
}
|
|
1321
|
+
catch (JSONException e)
|
|
1322
|
+
{
|
|
1323
|
+
}
|
|
1324
|
+
|
|
1325
|
+
GPickup pickup = pickupManager.findPickupById(pickupId);
|
|
1326
|
+
if ( null == pickup )
|
|
1327
|
+
{
|
|
1328
|
+
return;
|
|
1329
|
+
}
|
|
1330
|
+
|
|
1331
|
+
pickupManager.unclaimPickup(pickup);
|
|
1332
|
+
}
|
|
1333
|
+
|
|
1334
|
+
private synchronized void sendMessageToPickup(final JSONArray args, final CallbackContext callbackContext)
|
|
1335
|
+
{
|
|
1336
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1337
|
+
String pickupId = null;
|
|
1338
|
+
String message = null;
|
|
1339
|
+
long predefinedMessageId = -1;
|
|
1340
|
+
|
|
1341
|
+
try
|
|
1342
|
+
{
|
|
1343
|
+
pickupId = args.getString(0);
|
|
1344
|
+
message = args.getString(1);
|
|
1345
|
+
predefinedMessageId = args.getLong(2);
|
|
1346
|
+
}
|
|
1347
|
+
catch (JSONException e)
|
|
1348
|
+
{
|
|
1349
|
+
}
|
|
1350
|
+
|
|
1351
|
+
if ( null == message )
|
|
1352
|
+
{
|
|
1353
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1354
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1355
|
+
return;
|
|
1356
|
+
}
|
|
1357
|
+
|
|
1358
|
+
GPickup pickup = manager.getPickupManager().findPickupById(pickupId);
|
|
1359
|
+
if ( null == pickup )
|
|
1360
|
+
{
|
|
1361
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1362
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1363
|
+
return;
|
|
1364
|
+
}
|
|
1365
|
+
|
|
1366
|
+
boolean result = manager.getPickupManager().sendMessage(pickup, message, predefinedMessageId);
|
|
1367
|
+
if ( !result )
|
|
1368
|
+
{
|
|
1369
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1370
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1371
|
+
return;
|
|
1372
|
+
}
|
|
1373
|
+
|
|
1374
|
+
// Next: We might need to do something like task messaging where we generate a unique id and save the callback for later
|
|
1375
|
+
PluginResult pluginResult = new PluginResult(Status.OK);
|
|
1376
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1377
|
+
}
|
|
1378
|
+
|
|
1379
|
+
private synchronized void markMessagesAsRead(final JSONArray args, final CallbackContext callbackContext)
|
|
1380
|
+
{
|
|
1381
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1382
|
+
String pickupId = null;
|
|
1383
|
+
|
|
1384
|
+
try
|
|
1385
|
+
{
|
|
1386
|
+
pickupId = args.getString(0);
|
|
1387
|
+
}
|
|
1388
|
+
catch (JSONException e)
|
|
1389
|
+
{
|
|
1390
|
+
}
|
|
1391
|
+
|
|
1392
|
+
GPickup pickup = manager.getPickupManager().findPickupById(pickupId);
|
|
1393
|
+
if ( null == pickup )
|
|
1394
|
+
{
|
|
1395
|
+
return;
|
|
1396
|
+
}
|
|
1397
|
+
|
|
1398
|
+
String chatRoomId = pickup.getChatRoomId();
|
|
1399
|
+
if ( null == chatRoomId )
|
|
1400
|
+
{
|
|
1401
|
+
return;
|
|
1402
|
+
}
|
|
1403
|
+
|
|
1404
|
+
GChatManager chatManager = manager.getGlympse().getChatManager();
|
|
1405
|
+
chatManager.setRoomAsRead(chatRoomId);
|
|
1406
|
+
}
|
|
1407
|
+
|
|
1408
|
+
private synchronized void syncPickupsState(final JSONArray args, final CallbackContext callbackContext)
|
|
1409
|
+
{
|
|
1410
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1411
|
+
|
|
1412
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1413
|
+
|
|
1414
|
+
if ( manager.isStarted() )
|
|
1415
|
+
{
|
|
1416
|
+
GArray<GPickup> pickups = manager.getPickupManager().getPickups();
|
|
1417
|
+
if ( null != pickups )
|
|
1418
|
+
{
|
|
1419
|
+
GPrimitive pickupsPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_ARRAY);
|
|
1420
|
+
|
|
1421
|
+
GPrimitive config = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1422
|
+
config.put("with_items", true);
|
|
1423
|
+
|
|
1424
|
+
GChatManager chatManager = manager.getGlympse().getChatManager();
|
|
1425
|
+
|
|
1426
|
+
for ( GPickup pickup : pickups )
|
|
1427
|
+
{
|
|
1428
|
+
GPrimitive pickupPrimitive = commonObjToPrimitive(pickup, config);
|
|
1429
|
+
|
|
1430
|
+
String chatRoomId = pickup.getChatRoomId();
|
|
1431
|
+
if ( null != chatRoomId )
|
|
1432
|
+
{
|
|
1433
|
+
GChatRoom chatRoom = chatManager.getChatRoom(chatRoomId);
|
|
1434
|
+
if ( null != chatRoom )
|
|
1435
|
+
{
|
|
1436
|
+
GArray<GChatMessage> messages = chatRoom.getChatMessages();
|
|
1437
|
+
|
|
1438
|
+
GPrimitive chatMessagesPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_ARRAY);
|
|
1439
|
+
for ( GChatMessage chatMessage : messages )
|
|
1440
|
+
{
|
|
1441
|
+
GPrimitive chatMessagePrimitive = commonObjToPrimitive(chatMessage);
|
|
1442
|
+
chatMessagesPrimitive.put(chatMessagePrimitive);
|
|
1443
|
+
}
|
|
1444
|
+
|
|
1445
|
+
pickupPrimitive.put("chatMessages", chatMessagesPrimitive);
|
|
1446
|
+
pickupPrimitive.put("lastReadSequenceNumber", chatRoom.getLastReadSequenceNumber());
|
|
1447
|
+
}
|
|
1448
|
+
}
|
|
1449
|
+
|
|
1450
|
+
pickupsPrimitive.put(pickupPrimitive);
|
|
1451
|
+
}
|
|
1452
|
+
|
|
1453
|
+
result.put("pickups", pickupsPrimitive);
|
|
1454
|
+
}
|
|
1455
|
+
}
|
|
1456
|
+
|
|
1457
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
1458
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
1459
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1460
|
+
}
|
|
1461
|
+
|
|
1462
|
+
private synchronized void syncPickupsStateLight(final JSONArray args, final CallbackContext callbackContext)
|
|
1463
|
+
{
|
|
1464
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1465
|
+
|
|
1466
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1467
|
+
|
|
1468
|
+
if ( manager.isStarted() )
|
|
1469
|
+
{
|
|
1470
|
+
GArray<GPickup> pickups = manager.getPickupManager().getPickups();
|
|
1471
|
+
if ( null != pickups )
|
|
1472
|
+
{
|
|
1473
|
+
GPrimitive pickupsPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1474
|
+
|
|
1475
|
+
GPrimitive config = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1476
|
+
config.put("truncate_locations", true);
|
|
1477
|
+
config.put("ticket_light", true);
|
|
1478
|
+
|
|
1479
|
+
for ( GPickup pickup : pickups )
|
|
1480
|
+
{
|
|
1481
|
+
GPrimitive pickupData = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1482
|
+
pickupData.put("phase", pickup.getPhase());
|
|
1483
|
+
pickupData.put("agentId", pickup.getAgentId());
|
|
1484
|
+
|
|
1485
|
+
GTicket ticket = pickup.getCustomerTicket();
|
|
1486
|
+
if ( null != ticket )
|
|
1487
|
+
{
|
|
1488
|
+
pickupData.put("customerTicket", commonObjToPrimitive(ticket, config));
|
|
1489
|
+
}
|
|
1490
|
+
|
|
1491
|
+
pickupsPrimitive.put("" + pickup.getId(), pickupData);
|
|
1492
|
+
}
|
|
1493
|
+
|
|
1494
|
+
result.put("pickups_data", pickupsPrimitive);
|
|
1495
|
+
}
|
|
1496
|
+
}
|
|
1497
|
+
|
|
1498
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
1499
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
1500
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1501
|
+
}
|
|
1502
|
+
|
|
1503
|
+
private synchronized void syncPickup(final JSONArray args, final CallbackContext callbackContext)
|
|
1504
|
+
{
|
|
1505
|
+
String pickupId = null;
|
|
1506
|
+
|
|
1507
|
+
try
|
|
1508
|
+
{
|
|
1509
|
+
pickupId = args.getString(0);
|
|
1510
|
+
}
|
|
1511
|
+
catch (JSONException e)
|
|
1512
|
+
{
|
|
1513
|
+
}
|
|
1514
|
+
|
|
1515
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1516
|
+
GPickup pickup = manager.getPickupManager().findPickupById(pickupId);
|
|
1517
|
+
if ( null == pickup )
|
|
1518
|
+
{
|
|
1519
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1520
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1521
|
+
return;
|
|
1522
|
+
}
|
|
1523
|
+
|
|
1524
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1525
|
+
GPrimitive config = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1526
|
+
config.put("with_items", true);
|
|
1527
|
+
|
|
1528
|
+
GPrimitive pickupPrimitive = commonObjToPrimitive(pickup, config);
|
|
1529
|
+
|
|
1530
|
+
// Add message data
|
|
1531
|
+
String chatRoomId = pickup.getChatRoomId();
|
|
1532
|
+
if ( null != chatRoomId )
|
|
1533
|
+
{
|
|
1534
|
+
GChatManager chatManager = manager.getGlympse().getChatManager();
|
|
1535
|
+
GChatRoom chatRoom = chatManager.getChatRoom(chatRoomId);
|
|
1536
|
+
if ( null != chatRoom )
|
|
1537
|
+
{
|
|
1538
|
+
GArray<GChatMessage> messages = chatRoom.getChatMessages();
|
|
1539
|
+
|
|
1540
|
+
GPrimitive chatMessagesPrimitive = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_ARRAY);
|
|
1541
|
+
for ( GChatMessage chatMessage : messages )
|
|
1542
|
+
{
|
|
1543
|
+
GPrimitive chatMessagePrimitive = commonObjToPrimitive(chatMessage);
|
|
1544
|
+
chatMessagesPrimitive.put(chatMessagePrimitive);
|
|
1545
|
+
}
|
|
1546
|
+
|
|
1547
|
+
pickupPrimitive.put("chatMessages", chatMessagesPrimitive);
|
|
1548
|
+
pickupPrimitive.put("lastReadSequenceNumber", chatRoom.getLastReadSequenceNumber());
|
|
1549
|
+
}
|
|
1550
|
+
}
|
|
1551
|
+
|
|
1552
|
+
result.put("pickup_data", pickupPrimitive);
|
|
1553
|
+
|
|
1554
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
1555
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
1556
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1557
|
+
}
|
|
1558
|
+
|
|
1559
|
+
private synchronized void startShift(final JSONArray args, final CallbackContext callbackContext)
|
|
1560
|
+
{
|
|
1561
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1562
|
+
boolean result = manager.toggleOnShift(true);
|
|
1563
|
+
|
|
1564
|
+
if ( !result )
|
|
1565
|
+
{
|
|
1566
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1567
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1568
|
+
}
|
|
1569
|
+
else
|
|
1570
|
+
{
|
|
1571
|
+
// Save callback for when server responds
|
|
1572
|
+
_callbacks.put(COMMAND_KEY_START_SHIFT, callbackContext);
|
|
1573
|
+
}
|
|
1574
|
+
}
|
|
1575
|
+
|
|
1576
|
+
private synchronized void completeShift(final JSONArray args, final CallbackContext callbackContext)
|
|
1577
|
+
{
|
|
1578
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1579
|
+
boolean result = manager.toggleOnShift(false);
|
|
1580
|
+
|
|
1581
|
+
if ( !result )
|
|
1582
|
+
{
|
|
1583
|
+
PluginResult pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1584
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1585
|
+
}
|
|
1586
|
+
else
|
|
1587
|
+
{
|
|
1588
|
+
// Save callback for when server responds
|
|
1589
|
+
_callbacks.put(COMMAND_KEY_COMPLETE_SHIFT, callbackContext);
|
|
1590
|
+
}
|
|
1591
|
+
}
|
|
1592
|
+
|
|
1593
|
+
private synchronized void checkGoogleLocationAccuracy(final JSONArray args, final CallbackContext callbackContext)
|
|
1594
|
+
{
|
|
1595
|
+
LocationAccuracyChecker.requestLocationAccuracy(this.cordova.getContext(), callbackContext);
|
|
1596
|
+
}
|
|
1597
|
+
|
|
1598
|
+
private synchronized void checkIsNetworkConstrained(final JSONArray args, final CallbackContext callbackContext)
|
|
1599
|
+
{
|
|
1600
|
+
PluginResult pluginResult = new PluginResult(Status.OK, true);
|
|
1601
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1602
|
+
}
|
|
1603
|
+
|
|
1604
|
+
private synchronized void checkCellularDataAvailable(final JSONArray args, final CallbackContext callbackContext)
|
|
1605
|
+
{
|
|
1606
|
+
PluginResult pluginResult = new PluginResult(Status.OK, true);
|
|
1607
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1608
|
+
}
|
|
1609
|
+
|
|
1610
|
+
public void eventsOccurred(GSource source, int listener, int events, Object param1, Object param2)
|
|
1611
|
+
{
|
|
1612
|
+
GPrimitive result = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_OBJECT);
|
|
1613
|
+
|
|
1614
|
+
result.put("listener", listener);
|
|
1615
|
+
result.put("events", events);
|
|
1616
|
+
|
|
1617
|
+
if ( null != param1 )
|
|
1618
|
+
{
|
|
1619
|
+
GPrimitive primitive1 = commonObjToPrimitive(param1);
|
|
1620
|
+
if ( null != primitive1 )
|
|
1621
|
+
{
|
|
1622
|
+
result.put("param1", primitive1);
|
|
1623
|
+
}
|
|
1624
|
+
}
|
|
1625
|
+
|
|
1626
|
+
if ( null != param2 )
|
|
1627
|
+
{
|
|
1628
|
+
GPrimitive primitive2 = commonObjToPrimitive(param2);
|
|
1629
|
+
if ( null != primitive2 )
|
|
1630
|
+
{
|
|
1631
|
+
result.put("param2", primitive2);
|
|
1632
|
+
}
|
|
1633
|
+
}
|
|
1634
|
+
|
|
1635
|
+
String jsonString = CoreTools.primitiveToString(result);
|
|
1636
|
+
|
|
1637
|
+
for ( CallbackContext callbackContext : _listeners )
|
|
1638
|
+
{
|
|
1639
|
+
PluginResult pluginResult = new PluginResult(Status.OK, jsonString);
|
|
1640
|
+
pluginResult.setKeepCallback(true);
|
|
1641
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1642
|
+
}
|
|
1643
|
+
|
|
1644
|
+
if ( EE.LISTENER_ENROUTE_MANAGER == listener )
|
|
1645
|
+
{
|
|
1646
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_STARTED & events ) )
|
|
1647
|
+
{
|
|
1648
|
+
started();
|
|
1649
|
+
}
|
|
1650
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_STOPPED & events ) )
|
|
1651
|
+
{
|
|
1652
|
+
stopped();
|
|
1653
|
+
}
|
|
1654
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_LOGIN_COMPLETED & events ) )
|
|
1655
|
+
{
|
|
1656
|
+
boolean success = ( param1 == null );
|
|
1657
|
+
loginCompleted(success, (String)param1);
|
|
1658
|
+
}
|
|
1659
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_LOGGED_OUT & events ) )
|
|
1660
|
+
{
|
|
1661
|
+
logoutCompleted(true);
|
|
1662
|
+
}
|
|
1663
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_SYNCED & events ) )
|
|
1664
|
+
{
|
|
1665
|
+
synced();
|
|
1666
|
+
}
|
|
1667
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_SHIFT_STARTED & events ) )
|
|
1668
|
+
{
|
|
1669
|
+
shiftToggleCompleted(true, true);
|
|
1670
|
+
}
|
|
1671
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_SHIFT_COMPLETED & events ) )
|
|
1672
|
+
{
|
|
1673
|
+
shiftToggleCompleted(false, true);
|
|
1674
|
+
}
|
|
1675
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_SHIFT_START_FAILED & events ) )
|
|
1676
|
+
{
|
|
1677
|
+
shiftToggleCompleted(true, false);
|
|
1678
|
+
}
|
|
1679
|
+
if ( 0 != ( EE.ENROUTE_MANAGER_SHIFT_COMPLETE_FAILED & events ) )
|
|
1680
|
+
{
|
|
1681
|
+
shiftToggleCompleted(false, false);
|
|
1682
|
+
}
|
|
1683
|
+
}
|
|
1684
|
+
if ( EE.LISTENER_TASKS == listener )
|
|
1685
|
+
{
|
|
1686
|
+
if ( 0 != ( EE.TASKS_TASK_LIST_CHANGED & events ) )
|
|
1687
|
+
{
|
|
1688
|
+
boolean success = ( param1 == null );
|
|
1689
|
+
tasksChanged(success);
|
|
1690
|
+
}
|
|
1691
|
+
if ( 0 != ( EE.TASKS_TASK_CARD_MESSAGE_STATUS & events ) )
|
|
1692
|
+
{
|
|
1693
|
+
String eventId = (String) param1;
|
|
1694
|
+
String uniqueId = (String) param2;
|
|
1695
|
+
if ( null != uniqueId )
|
|
1696
|
+
{
|
|
1697
|
+
CallbackContext callbackContext = _callbacks.get(uniqueId);
|
|
1698
|
+
if ( null != callbackContext )
|
|
1699
|
+
{
|
|
1700
|
+
// Send status result
|
|
1701
|
+
PluginResult pluginResult;
|
|
1702
|
+
if ( null != eventId )
|
|
1703
|
+
{
|
|
1704
|
+
pluginResult = new PluginResult(Status.OK, eventId);
|
|
1705
|
+
}
|
|
1706
|
+
else
|
|
1707
|
+
{
|
|
1708
|
+
pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1709
|
+
}
|
|
1710
|
+
|
|
1711
|
+
pluginResult.setKeepCallback(false);
|
|
1712
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1713
|
+
|
|
1714
|
+
// No longer expecting updates for this message
|
|
1715
|
+
_callbacks.remove(uniqueId);
|
|
1716
|
+
}
|
|
1717
|
+
}
|
|
1718
|
+
}
|
|
1719
|
+
}
|
|
1720
|
+
}
|
|
1721
|
+
|
|
1722
|
+
public GPrimitive commonObjToPrimitive(Object obj)
|
|
1723
|
+
{
|
|
1724
|
+
return commonObjToPrimitive(obj, null);
|
|
1725
|
+
}
|
|
1726
|
+
|
|
1727
|
+
public GPrimitive commonObjToPrimitive(Object obj, GPrimitive config)
|
|
1728
|
+
{
|
|
1729
|
+
if ( obj instanceof GVector )
|
|
1730
|
+
{
|
|
1731
|
+
GVector vector = (GVector)obj;
|
|
1732
|
+
GPrimitive longArray = CoreFactory.createPrimitive(CC.PRIMITIVE_TYPE_ARRAY);
|
|
1733
|
+
boolean valid = true;
|
|
1734
|
+
|
|
1735
|
+
for (Object vectorObject : vector)
|
|
1736
|
+
{
|
|
1737
|
+
if ( vectorObject instanceof Long )
|
|
1738
|
+
{
|
|
1739
|
+
Long longObject = (Long)vectorObject;
|
|
1740
|
+
longArray.put(longObject.longValue());
|
|
1741
|
+
}
|
|
1742
|
+
else
|
|
1743
|
+
{
|
|
1744
|
+
valid = false;
|
|
1745
|
+
}
|
|
1746
|
+
}
|
|
1747
|
+
|
|
1748
|
+
if ( valid )
|
|
1749
|
+
{
|
|
1750
|
+
return longArray;
|
|
1751
|
+
}
|
|
1752
|
+
}
|
|
1753
|
+
|
|
1754
|
+
return ObjectEncoder.valueToPrimitive(obj, config);
|
|
1755
|
+
}
|
|
1756
|
+
|
|
1757
|
+
public void subscribeToListeners()
|
|
1758
|
+
{
|
|
1759
|
+
ManagerWrapper.instance().manager().addListener(this);
|
|
1760
|
+
}
|
|
1761
|
+
|
|
1762
|
+
public void unsubscribeFromListeners()
|
|
1763
|
+
{
|
|
1764
|
+
ManagerWrapper.instance().manager().removeListener(this);
|
|
1765
|
+
}
|
|
1766
|
+
|
|
1767
|
+
public void loginCompleted(boolean success, String error)
|
|
1768
|
+
{
|
|
1769
|
+
GEnRouteManager manager = ManagerWrapper.instance().manager();
|
|
1770
|
+
CallbackContext callbackContext = _callbacks.get(COMMAND_KEY_LOGIN);
|
|
1771
|
+
if ( null == callbackContext )
|
|
1772
|
+
{
|
|
1773
|
+
return;
|
|
1774
|
+
}
|
|
1775
|
+
_callbacks.remove(COMMAND_KEY_LOGIN);
|
|
1776
|
+
|
|
1777
|
+
PluginResult pluginResult;
|
|
1778
|
+
if ( success )
|
|
1779
|
+
{
|
|
1780
|
+
pluginResult = new PluginResult(Status.OK);
|
|
1781
|
+
}
|
|
1782
|
+
else
|
|
1783
|
+
{
|
|
1784
|
+
pluginResult = new PluginResult(Status.ERROR, error);
|
|
1785
|
+
}
|
|
1786
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1787
|
+
}
|
|
1788
|
+
|
|
1789
|
+
public void logoutCompleted(boolean success)
|
|
1790
|
+
{
|
|
1791
|
+
CallbackContext callbackContext = _callbacks.get(COMMAND_KEY_LOGOUT);
|
|
1792
|
+
if ( null == callbackContext )
|
|
1793
|
+
{
|
|
1794
|
+
return;
|
|
1795
|
+
}
|
|
1796
|
+
_callbacks.remove(COMMAND_KEY_LOGOUT);
|
|
1797
|
+
|
|
1798
|
+
PluginResult pluginResult;
|
|
1799
|
+
if ( success )
|
|
1800
|
+
{
|
|
1801
|
+
pluginResult = new PluginResult(Status.OK);
|
|
1802
|
+
}
|
|
1803
|
+
else
|
|
1804
|
+
{
|
|
1805
|
+
pluginResult = new PluginResult(Status.ERROR, "logout failed");
|
|
1806
|
+
}
|
|
1807
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1808
|
+
}
|
|
1809
|
+
|
|
1810
|
+
public void tasksChanged(boolean success)
|
|
1811
|
+
{
|
|
1812
|
+
|
|
1813
|
+
}
|
|
1814
|
+
|
|
1815
|
+
public void started()
|
|
1816
|
+
{
|
|
1817
|
+
|
|
1818
|
+
}
|
|
1819
|
+
|
|
1820
|
+
public void stopped()
|
|
1821
|
+
{
|
|
1822
|
+
|
|
1823
|
+
}
|
|
1824
|
+
|
|
1825
|
+
public void synced()
|
|
1826
|
+
{
|
|
1827
|
+
GTaskManager taskManager = ManagerWrapper.instance().manager().getTaskManager();
|
|
1828
|
+
if ( null != taskManager )
|
|
1829
|
+
{
|
|
1830
|
+
taskManager.addListener(this);
|
|
1831
|
+
}
|
|
1832
|
+
|
|
1833
|
+
GSessionManager sessionManager = ManagerWrapper.instance().manager().getSessionManager();
|
|
1834
|
+
if ( null != sessionManager )
|
|
1835
|
+
{
|
|
1836
|
+
sessionManager.addListener(this);
|
|
1837
|
+
}
|
|
1838
|
+
|
|
1839
|
+
GPickupManager pickupManager = ManagerWrapper.instance().manager().getPickupManager();
|
|
1840
|
+
if ( null != pickupManager )
|
|
1841
|
+
{
|
|
1842
|
+
pickupManager.addListener(this);
|
|
1843
|
+
}
|
|
1844
|
+
}
|
|
1845
|
+
|
|
1846
|
+
public void shiftToggleCompleted(boolean onShift, boolean success)
|
|
1847
|
+
{
|
|
1848
|
+
String key = onShift ? COMMAND_KEY_START_SHIFT : COMMAND_KEY_COMPLETE_SHIFT;
|
|
1849
|
+
CallbackContext callbackContext = _callbacks.get(key);
|
|
1850
|
+
if ( null == callbackContext )
|
|
1851
|
+
{
|
|
1852
|
+
return;
|
|
1853
|
+
}
|
|
1854
|
+
_callbacks.remove(key);
|
|
1855
|
+
|
|
1856
|
+
PluginResult pluginResult;
|
|
1857
|
+
if ( success )
|
|
1858
|
+
{
|
|
1859
|
+
pluginResult = new PluginResult(Status.OK);
|
|
1860
|
+
}
|
|
1861
|
+
else
|
|
1862
|
+
{
|
|
1863
|
+
pluginResult = new PluginResult(Status.ERROR, "failed");
|
|
1864
|
+
}
|
|
1865
|
+
callbackContext.sendPluginResult(pluginResult);
|
|
1866
|
+
}
|
|
1867
|
+
}
|