• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15var global = globalThis
16mockSystemPlugin()
17function mockSystemPlugin () {
18  global.systemplugin = {
19    notification:{},
20    vibrator: {},
21    sensor: {},
22    geolocation: {},
23    network: {},
24    brightness: {
25      argsV: {
26        value: 80
27      },
28      argsM: {
29        mode: 0
30      }
31    },
32    volume: {
33      args: {value: 0.5}
34    },
35    battery: {},
36    systemPackage: {},
37    wifi: {},
38    bluetooth: {},
39    tts: {},
40    alarm: {},
41    request: {},
42    fetch: {},
43    storage: {},
44    file: {}
45  }
46  mockNotification()
47  mockFetch()
48  mockRequest()
49  mockStorage()
50  mockFile()
51  mockVibrator()
52  mockSensor()
53  mockGeolocation()
54  mockNetwork()
55  mockBrightness()
56  mockVolume()
57  mockBattery()
58  mockSystemPackage()
59}
60
61function mockNotification () {
62  global.systemplugin.notification = {
63    show: function () {}
64  }
65}
66
67function mockVibrator () {
68  global.systemplugin.vibrator = {
69    vibrate: function () {
70      arguments[0].success()
71      isComplete(arguments[0].complete)
72    }
73  }
74}
75
76function mockSensor () {
77  mockAccelerometer()
78  mockCompass()
79  mockProximity()
80  mockLight()
81  mockStepCounter()
82  mockBarometer()
83  mockHeartRate()
84  mockOnBodyState()
85}
86
87function mockAccelerometer () {
88  Object.assign(global.systemplugin.sensor, {
89    subscribeAccelerometer: function () {
90      const time = {
91        normal: 200,
92        game: 20,
93        ui: 60
94      }
95      let ret = {}
96      let timer = 0
97      if(!arguments[0].interval) {
98        timer = time.normal
99      } else {
100        timer = time[arguments[0].interval]
101      }
102      this.unsubscribeAccelerometer()
103      this.unsubscribeAcc = setInterval(() => {
104        ret.x = Math.ceil(Math.random() * 10)
105        ret.y = Math.ceil(Math.random() * 10)
106        ret.z = Math.ceil(Math.random() * 10)
107        arguments[0].success(ret)
108      }, timer)
109    },
110    unsubscribeAccelerometer: function () {
111      clearInterval(this.unsubscribeAcc)
112      delete this.unsubscribeAcc
113    }
114  })
115}
116
117function mockCompass () {
118  Object.assign(global.systemplugin.sensor, {
119    subscribeCompass: function () {
120      if(!this.unsubscribeDirection) {
121        let ret = {}
122        this.unsubscribeDirection = setInterval(() => {
123          ret.direction = getRandomArbitrary(49, 50)
124          arguments[0].success(ret)
125        }, 100)
126      }
127    },
128    unsubscribeCompass: function () {
129      clearInterval(this.unsubscribeDirection)
130      delete this.unsubscribeDirection
131    }
132  })
133}
134
135function mockProximity() {
136  Object.assign(global.systemplugin.sensor, {
137    subscribeProximity: function () {
138      if(!this.unsubscribeDistance) {
139        let ret = {}
140        this.unsubscribeDistance = setInterval(() => {
141          ret.distance = Math.ceil(Math.random() * 100)
142          arguments[0].success(ret)
143        }, 1000)
144      }
145    },
146    unsubscribeProximity: function () {
147      clearInterval(this.unsubscribeDistance)
148      delete this.unsubscribeDistance
149    }
150  })
151}
152
153function mockLight () {
154  Object.assign(global.systemplugin.sensor, {
155    subscribeLight: function () {
156      if(!this.unsubscribeIntensity) {
157        let ret = {}
158        this.unsubscribeIntensity = setInterval(() => {
159          ret.intensity = getRandomArbitrary(660, 680)
160          arguments[0].success(ret)
161        }, 500)
162      }
163    },
164    unsubscribeLight: function () {
165      clearInterval(this.unsubscribeIntensity)
166      delete this.unsubscribeIntensity
167    },
168  })
169}
170
171function mockStepCounter() {
172  Object.assign(global.systemplugin.sensor, {
173    subscribeStepCounter: function () {
174      if(!this.unsubscribeSteps) {
175        let ret = { steps: 0 }
176        this.unsubscribeSteps = setInterval(() => {
177          ret.steps += 1
178          arguments[0].success(ret)
179        }, 1000)
180      }
181    },
182    unsubscribeStepCounter: function () {
183      clearInterval(this.unsubscribeSteps)
184      delete this.unsubscribeSteps
185    }
186  })
187}
188
189function mockBarometer() {
190  Object.assign(global.systemplugin.sensor, {
191    subscribeBarometer: function () {
192      if(!this.unsubscribePressure) {
193        let ret = {}
194        this.unsubscribePressure = setInterval(() => {
195          ret.pressure = getRandomArbitrary(1110, 1111)
196          arguments[0].success(ret)
197        }, 500)
198      }
199    },
200    unsubscribeBarometer: function () {
201      clearInterval(this.unsubscribePressure)
202      delete this.unsubscribePressure
203    }
204  })
205}
206
207function mockHeartRate() {
208  Object.assign(global.systemplugin.sensor, {
209    subscribeHeartRate: function () {
210      if(!this.unsubscribeRate) {
211        let ret = {}
212        this.unsubscribeRate = setInterval(() => {
213          ret.heartRate = Math.ceil(Math.random() * 30)
214          arguments[0].success(ret)
215        }, 500)
216      }
217    },
218    unsubscribeHeartRate: function () {
219      clearInterval(this.unsubscribeRate)
220      delete this.unsubscribeRate
221    },
222  })
223}
224
225function mockOnBodyState () {
226  Object.assign(global.systemplugin.sensor, {
227    subscribeOnBodyState: function () {
228      if(!this.unsubscribeBodyState) {
229        let ret = {}
230        this.unsubscribeBodyState = setInterval(() => {
231          ret.value = Math.ceil(Math.random() * 20)
232          arguments[0].success(ret)
233        }, 500)
234      }
235    },
236    unsubscribeOnBodyState: function () {
237      clearInterval(this.unsubscribeBodyState)
238      delete this.unsubscribeBodyState
239    }
240  })
241}
242
243function mockGeolocation () {
244  const data = {
245    latitude: '121.61934',
246    longitude: '31.257907',
247    accuracy: '15',
248    time: '160332896544'
249  }
250  global.systemplugin.geolocation = {
251    getLocation: function () {
252      arguments[0].success(data)
253      isComplete(arguments[0].complete)
254    },
255    getLocationType: function () {
256      let args = {types: ['gps', 'network']}
257      arguments[0].success(args)
258      isComplete(arguments[0].complete)
259    },
260    getSupportedCoordTypes() {
261      return ["wgs84"]
262    },
263    subscribe: function () {
264      if(!this.unsubscribeLocation) {
265        this.unsubscribeLocation = setInterval(() => {
266          data.latitude = getRandomArbitrary(121, 122)
267          data.longitude = getRandomArbitrary(31, 32)
268          data.accuracy = getRandomArbitrary(14, 18)
269          arguments[0].success(data)
270        }, 1000)
271      }
272    },
273    unsubscribe: function () {
274      clearInterval(this.unsubscribeLocation)
275      delete this.unsubscribeLocation
276    }
277  }
278}
279
280function mockNetwork () {
281  const data = {
282    metered: true,
283    type: "5g"
284  }
285  global.systemplugin.network = {
286    getType: function () {
287      arguments[0].success(data)
288      arguments[0].complete()
289    },
290    subscribe: function () {
291      if(!this.unsubscribeNetwork) {
292        this.unsubscribeNetwork = setInterval(() => {
293          arguments[0].success(data)
294        }, 3000)
295      }
296    },
297    unsubscribe: function () {
298      clearInterval(this.unsubscribeNetwork)
299      delete this.unsubscribeNetwork
300    }
301  }
302}
303
304function mockBrightness () {
305  Object.assign(global.systemplugin.brightness, {
306    getValue: function () {
307      arguments[0].success(this.argsV)
308      isComplete(arguments[0].complete)
309    },
310    setValue: function () {
311      if(arguments[0].value) {
312        this.argsV.value = arguments[0].value
313        arguments[0].success("brightness setValue successfully")
314        isComplete(arguments[0].complete)
315      }
316    },
317    getMode: function () {
318      arguments[0].success(this.argsM)
319      isComplete(arguments[0].complete)
320    },
321    setMode: function () {
322      this.argsM.mode = arguments[0].mode
323      arguments[0].success("brightness setMode successfully")
324      isComplete(arguments[0].complete)
325    },
326    setKeepScreenOn: function () {
327      arguments[0].success("brightness setKeepScreenOn successfully")
328      isComplete(arguments[0].complete)
329    }
330  })
331}
332
333function mockVolume () {
334  Object.assign(global.systemplugin.volume, {
335    getMediaValue: function () {
336      arguments[0].success(this.args)
337      isComplete(arguments[0].complete)
338    },
339    setMediaValue: function () {
340      if(arguments[0].value) {
341        this.args.value = arguments[0].value
342        arguments[0].success("set volume successfully")
343        isComplete(arguments[0].complete)
344      }
345    }
346  })
347}
348
349function mockBattery () {
350  global.systemplugin.battery = {
351    getStatus: function () {
352      arguments[0].success.call(this, { level: 1, charging: false} )
353      isComplete(arguments[0].complete)
354    }
355  }
356}
357
358function mockSystemPackage () {
359  global.systemplugin.package = {
360    hasInstalled: function () {
361      arguments[0].success(true)
362      isComplete(arguments[0].complete)
363    }
364  }
365}
366
367function mockRequest () {
368  const data = {
369    code: "[pc Preview]: no internet",
370    data: "[pc Preview]: no internet",
371    headers: "[pc Preview]: no internet",
372    token: "[pc Preview]: no internet",
373    uri: "[pc Preview]: no internet",
374  }
375  global.systemplugin.request = {
376    upload: function () {
377      arguments[0].success(data)
378      isComplete(arguments[0].complete)
379    },
380    download: function () {
381      arguments[0].success(data)
382      isComplete(arguments[0].complete)
383    },
384    onDownloadComplete: function () {
385      arguments[0].success(data)
386      isComplete(arguments[0].complete)
387    }
388  }
389}
390
391function mockFetch () {
392  global.sendGroupMessage = global.group.sendGroupMessage;
393  let GroupMessenger = {
394    create: function () {
395      let messenger = {};
396      messenger.send = function (groupName, functionName, ...args) {
397        return new Promise(function (resolve, reject) {
398          let params = messenger.prepareArgs(...args);
399          sendGroupMessage(function (result) {
400            resolve(messenger.parseJsonResult(result));
401          }, function (error) {
402            reject(messenger.parseJsonResult(error));
403          }, groupName, functionName, ...params);
404        })
405      };
406      messenger.parseJsonResult = function (data) {
407        if (data && data.constructor == String) {
408          try {
409            data = JSON.parse(data);
410          } catch (jsonParseErr) {
411            console.warn("parse result exception: " + JSON.stringify(jsonParseErr));
412          }
413        }
414        return data;
415      };
416      messenger.prepareArgs = function (...args) {
417        let result = [...args];
418        for (let i = 0; i < result.length; i++) {
419          if (typeof result[i] === 'function') {
420            result[i] = messenger.packageCallback(result[i]);
421          }
422        }
423        return result;
424      };
425      messenger.packageCallback = function (func) {
426        return function (data) {
427          data = messenger.parseJsonResult(data);
428          if (!Array.isArray(data)) {
429            func(data);
430          } else {
431            func(...data);
432          }
433        };
434      };
435      return messenger;
436    }
437  };
438
439  let CommonCallback = {
440    commonCallback: function commonCallback(callback, flag, data, code) {
441      if (typeof callback === 'function') {
442        switch (flag) {
443          case 'success':
444            callback(data);
445            break;
446          case 'fail':
447            callback(data, code);
448            break;
449          case 'cancel':
450            callback(data);
451            break;
452          case 'complete':
453            callback();
454            break;
455          default:
456            break;
457        }
458      } else {
459        console.warn('callback.' + flag + ' is not function or not present');
460      }
461    }
462  };
463  global.commonCallback = CommonCallback.commonCallback;
464  let CommonCallbackEx = {
465    commonCallbackEx: function commonCallbackEx(callback, result, pluginError) {
466      if ((callback === undefined) || ((callback.success === undefined) && (callback.fail === undefined) && (callback.complete === undefined))) {
467        return CommonCallbackEx.promiseMethod(result, pluginError);
468      } else {
469        return CommonCallbackEx.callbackMethod(callback, result, pluginError);
470      }
471    },
472    promiseMethod: function promiseMethod(result, pluginError) {
473      if (pluginError != undefined) {
474        throw pluginError;
475      }
476      return result;
477    },
478    callbackMethod: function callbackMethod(callback, result, pluginError) {
479      if (pluginError != undefined) {
480        commonCallback(callback.fail, 'fail', pluginError.data, pluginError.code);
481        commonCallback(callback.complete, 'complete');
482        throw pluginError;
483      }
484      commonCallback(callback.success, 'success', result.data);
485      commonCallback(callback.complete, 'complete');
486      return result;
487    },
488    catching: function catching(promise, param) {
489      return promise.then(ret => commonCallbackEx(param, ret))
490        .catch(err => commonCallbackEx(param, null, err));
491    }
492  };
493  global.commonCallbackEx = CommonCallbackEx.commonCallbackEx;
494  global.systemplugin.catching = CommonCallbackEx.catching;
495
496  let FetchObject = {
497    getFetch: function () {
498      let fetch = {}
499      fetch.messenger = GroupMessenger.create();
500      fetch.fetch = async function (param) {
501        return await CommonCallbackEx.catching(this.messenger.send("groupName", "fetch", param), param);
502      }
503      return fetch
504    }
505  }
506
507  global.systemplugin.fetch = FetchObject.getFetch();
508}
509
510function mockStorage () {
511  global.systemplugin.storage = {
512    get: function () {
513      arguments[0].success("[pc Preview]: no system")
514      isComplete(arguments[0].complete)
515    },
516    set: function () {
517      arguments[0].success("[pc Preview]: no system")
518      isComplete(arguments[0].complete)
519    },
520    clear: function () {
521      arguments[0].success("[pc Preview]: no system")
522      isComplete(arguments[0].complete)
523    },
524    delete: function () {
525      arguments[0].success("[pc Preview]: no system")
526      isComplete(arguments[0].complete)
527    }
528  }
529}
530
531function mockFile () {
532  global.systemplugin.file = {
533    move: function () {
534      arguments[0].success(arguments[0].dstUri)
535      isComplete(arguments[0].complete)
536    },
537    copy: function () {
538      arguments[0].success(arguments[0].dstUri)
539      isComplete(arguments[0].complete)
540    },
541    list: function () {
542      const data = {
543        fileList: [{
544          uri:'[pc Preview]: no file',
545          lastModifiedTime:"[pc Preview]: no file",
546          length:"[pc Preview]: no file",
547          type: 'file'}]
548      }
549      arguments[0].success(data)
550      isComplete(arguments[0].complete)
551    },
552    get: function () {
553      const data = {
554        uri:'[pc Preview]: no file',
555        lastModifiedTime:"[pc Preview]: no file",
556        length:"[pc Preview]: no file",
557        type: 'file',
558        subFiles: ["[pc Preview]: no file", "[pc Preview]: no file"]
559      }
560      arguments[0].success(data)
561      isComplete(arguments[0].complete)
562    },
563    delete: function () {
564      arguments[0].success()
565      isComplete(arguments[0].complete)
566    },
567    writeText: function () {
568      arguments[0].success()
569      isComplete(arguments[0].complete)
570    },
571    writeArrayBuffer: function () {
572      arguments[0].success()
573      isComplete(arguments[0].complete)
574    },
575    readText: function () {
576      const data = {text: "[pc Preview]: success default"}
577      arguments[0].success(data)
578      isComplete(arguments[0].complete)
579    },
580    readArrayBuffer: function () {
581      const data = {buffer: ["[pc Preview]: default", "[pc Preview]: default", "[pc Preview]: default"]}
582      arguments[0].success(data)
583      isComplete(arguments[0].complete)
584    },
585    access: function () {
586      arguments[0].success()
587      isComplete(arguments[0].complete)
588    },
589    mkdir: function () {
590      arguments[0].success()
591      isComplete(arguments[0].complete)
592    },
593    rmdir: function () {
594      arguments[0].success()
595      isComplete(arguments[0].complete)
596    }
597  }
598}
599
600function isComplete() {
601  if(arguments[0] === undefined) {
602    return
603  }
604  arguments[0].call(this)
605}
606
607function getRandomArbitrary(min, max) {
608  return Math.random().toFixed(6) * (max - min) + min;
609}
610