@extscreen/es-core 1.0.0

package/dist/index.js

@@ -0,0 +1,1999 @@
+import Vue from 'vue';
+import { getEventRedirector as getEventRedirector$1 } from '@/utils';
+
+/**
+ *
+ */
+class ESDevelopModule {
+
+  getDevelop() {
+    return Vue.Native.callNativeWithPromise('AndroidDevelopModule', 'getDevelop');
+  }
+
+  getAppKey() {
+    return Vue.Native.callNativeWithPromise('AndroidDevelopModule', 'getAppKey');
+  }
+
+  getPackageName() {
+    return Vue.Native.callNativeWithPromise('AndroidDevelopModule', 'getPackageName');
+  }
+
+  getVersionName() {
+    return Vue.Native.callNativeWithPromise('AndroidDevelopModule', 'getVersionName');
+  }
+
+  getVersionCode() {
+    return Vue.Native.callNativeWithPromise('AndroidDevelopModule', 'getVersionCode');
+  }
+}
+
+var ESDevelopModule$1 = new ESDevelopModule();
+
+/**
+ * {
+	"versionName": "1.0",
+	"versionCode": 1,
+	"packageName": "tv.huan.spark"
+ }
+ *
+ */
+
+class ESDevelopManager {
+
+  //
+  _appKey = '2V29G3SD';
+  _appSecretKey = '5faa1c397ed64d09a17ab89b6b19d373';
+
+  _develop = null;
+  _versionName = '';
+  _versionCode = -1;
+  _packageName = '';
+  _channel = '';
+
+  init() {
+    return new Promise((resolve, reject) => {
+      ESDevelopModule$1.getDevelop()
+        .then(
+          (result) => {
+            this._develop = result;
+            if (result) {
+              this._versionName = result.versionName;
+              this._versionCode = result.versionCode;
+              this._packageName = result.packageName;
+              this._channel = result.channel;
+            }
+            resolve(result);
+          },
+          //
+          error => {
+            resolve(error);
+          }
+        );
+    });
+  }
+
+  getDevelop() {
+    return this._develop;
+  }
+
+  getAppKey() {
+    return this._appKey;
+  }
+
+  getPackageName() {
+    return this._packageName;
+  }
+
+  getVersionName() {
+    return this._versionName;
+  }
+
+  getVersionCode() {
+    return this._versionCode;
+  }
+
+  getChannel() {
+    return this._channel;
+  }
+
+  getAppKey() {
+    return this._appKey;
+  }
+
+  getAppSecretKey() {
+    return this._appSecretKey;
+  }
+}
+
+var ESDevelopManager$1 = new ESDevelopManager();
+
+/**
+ *
+ */
+class ESDeviceModule {
+
+  getAndroidDevice() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getAndroidDevice');
+  }
+
+  getWifiMac() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getWifiMac');
+  }
+
+  getEthMac() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getEthMac');
+  }
+
+  getUuid() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getUuid');
+  }
+
+  getClientType() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getClientType');
+  }
+
+  getTotalMemory() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getTotalMemory');
+  }
+
+  getAvailableMemory() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getAvailableMemory');
+  }
+
+  getScreenWidth() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getScreenWidth');
+  }
+
+  getScreenHeight() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getScreenHeight');
+  }
+
+  getWindowWidth() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getWindowWidth');
+  }
+
+  getWindowHeight() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getWindowHeight');
+  }
+
+  getResolution() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getResolution');
+  }
+
+  getDensity() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getDensity');
+  }
+
+  getDensityDpi() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getDensityDpi');
+  }
+
+  getScaledDensity() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getScaledDensity');
+  }
+
+  getBuildVersionRelease() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildVersionRelease');
+  }
+
+  getBuildModel() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildModel');
+  }
+
+  getBuildBrand() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildBrand');
+  }
+
+
+  getBuildDevice() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildDevice');
+  }
+
+  getBuildBoard() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildBoard');
+  }
+
+  getBuildProduct() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildProduct');
+  }
+
+  getBuildHardware() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildHardware');
+  }
+
+  getBuildManufacturer() {
+    return Vue.Native.callNativeWithPromise('AndroidDeviceModule', 'getBuildManufacturer');
+  }
+
+}
+
+var ESDeviceModule$1 = new ESDeviceModule();
+
+/**
+ * 设备信息管理
+ *
+ * {
+	"screenWidth": 1920,
+	"clientType": "MiBOX4",
+	"buildBoard": "transformers",
+	"scaledDensity": "1.0",
+	"mac": null,
+	"uuid": null,
+	"buildVersionRelease": "6.0.1",
+	"buildManufacturer": "Xiaomi",
+	"windowWidth": 0,
+	"density": "1.0",
+	"buildDevice": "transformers",
+	"availableMemory": 0,
+	"buildHardware": "amlogic",
+	"screenHeight": 1080,
+	"buildModel": "MiBOX4",
+	"buildBrand": null,
+	"densityDpi": "160.0",
+	"resolution": "1920*1080",
+	"totalMemory": 0,
+	"buildProduct": "transformers"
+}
+
+ */
+
+
+class ESDeviceManager {
+
+  //内存
+  _totalMemory = 0;
+  _availMemory = 0;
+
+  //屏幕宽高
+  _screenWidth = 1920;
+  _screenHeight = 1080;
+
+  _windowWidth = 1920;
+  _windowHeight = 1080;
+
+  _androidAPILevel = 14;
+
+  _buildVersionRelease = '';
+  _buildManufacturer = '';
+  _deviceEthMac = '';
+  _deviceWifiMac = '';
+
+  _deviceId = '';
+  _deviceType = '';
+
+  _resolution = '';
+  _ipAddress = '';
+  _totalStore = '';
+  _freeStore = '';
+  _deviceTotalMemory = '';
+  _buildSerial = '';
+  _blueToothName = '';
+
+  _device = null;
+
+  _density = '';
+  _densityDpi = '';
+  _scaledDensity = '';
+  _buildModel = '';
+  _buildBrand = '';
+  _buildDevice = '';
+  _buildProduct = '';
+  _buildHardware = '';
+  _buildSDKVersion = 1;
+
+  init() {
+    return new Promise((resolve, reject) => {
+      this.initAndroidDevice();
+      ESDeviceModule$1.getAndroidDevice().then(
+        (device) => {
+          this._device = device;
+
+          try {
+            if (device) {
+              this._buildSDKVersion = device.buildSDKVersion;
+
+              this._deviceId = device.deviceId;
+              this._deviceType = device._deviceType;
+
+              this._deviceEthMac = device.ethMac;
+              this._deviceWifiMac = device.wifiMac;
+
+              this._totalMemory = device.totalMemory;
+              this._availMemory = device.availableMemory;
+
+              this._screenWidth = device.screenWidth;
+              this._screenHeight = device.screenHeight;
+              this._windowWidth = device.windowWidth;
+              this._windowHeight = device.windowHeight;
+
+              this._resolution = device.resolution;
+              this._density = device.density;
+              this._densityDpi = device.densityDpi;
+              this._scaledDensity = device.scaledDensity;
+
+              this._buildVersionRelease = device.buildVersionRelease;
+              this._buildModel = device.buildModel;
+              this._buildBrand = device.buildBrand;
+              this._buildDevice = device.buildDevice;
+              this._buildProduct = device.buildProduct;
+              this._buildHardware = device.buildHardware;
+              this._buildManufacturer = device.buildManufacturer;
+              this._buildSerial = device.buildSerial;
+
+              this._ipAddress = device.ipAddress;
+              this._totalStore = device.totalStore;
+              this._freeStore = device.freeStore;
+              this._deviceTotalMemory = device.deviceTotalMemory;
+              this._blueToothName = device.blueToothName;
+
+            }
+          } catch (e) {
+          }
+
+          resolve(device);
+        },
+        //
+        error => {
+          resolve(error);
+        }
+      );
+    })
+  }
+
+  initAndroidDevice() {
+    this._androidAPILevel = Vue.Native.APILevel;
+  }
+
+
+  is720PDevice() {
+    return this._screenWidth === 1280 && this._screenHeight === 720;
+  }
+
+  getAndroidAPILevel() {
+    return this._androidAPILevel;
+  }
+
+  getDeviceTotalMemory() {
+    return this._totalMemory;
+  }
+
+  getDeviceAvailMemory() {
+    return this._availMemory;
+  }
+
+  getDevice() {
+    return this._device;
+  }
+
+
+  getBuildVersionRelease() {
+    return this._buildVersionRelease;
+  }
+
+  getBuildManufacturer() {
+    return this._buildManufacturer;
+  }
+
+  getDeviceEthMac() {
+    return this._deviceEthMac;
+  }
+
+  getDeviceWifiMac() {
+    return this._deviceWifiMac;
+  }
+
+  getDeviceId() {
+    return this._deviceId;
+  }
+
+  getDeviceType() {
+    return this._deviceType;
+  }
+
+  getResolution() {
+    return this._resolution;
+  }
+
+  getIpAddress() {
+    return this._ipAddress;
+  }
+
+  getTotalStore() {
+    return this._totalStore;
+  }
+
+  getFreeStore() {
+    return this._freeStore;
+  }
+
+  getDeviceTotalMemoryNew() {
+    return this._deviceTotalMemory;
+  }
+
+  getBuildSerial() {
+    return this._buildSerial;
+  }
+
+  getBlueToothName() {
+    return this._blueToothName;
+  }
+
+  getBrand() {
+    return this._buildBrand;
+  }
+
+  getModel() {
+    return this._buildModel;
+  }
+
+  getScreenWidth() {
+    return this._screenWidth;
+  }
+
+  getScreenHeight() {
+    return this._screenHeight
+  }
+
+  getBuildSDKVersion() {
+    return this._buildSDKVersion;
+  }
+}
+
+var ESDeviceManager$1 = new ESDeviceManager();
+
+/**
+ *
+ */
+class ESNetworkModule {
+
+  getActiveNetworkInfo() {
+    return Vue.Native.callNativeWithPromise('AndroidNetworkModule',
+      'getActiveNetworkInfo');
+  }
+}
+
+var ESNetworkModule$1 = new ESNetworkModule();
+
+/**
+ *
+ */
+class ESNetworkManager {
+
+  _networkInfo = null;
+
+  init() {
+    return new Promise((resolve, reject) => {
+      ESNetworkModule$1.getActiveNetworkInfo().then(
+        //
+        (result) => {
+          this._networkInfo = result;
+          resolve(this._networkInfo);
+        },
+        //
+        error => {
+          this._networkInfo = null;
+          resolve(this._networkInfo);
+        }
+      );
+    });
+  }
+
+  initNetworkInfo() {
+
+  }
+
+  getActiveNetworkInfo() {
+    return this._networkInfo;
+  }
+
+  isNetworkConnected() {
+    return this._networkInfo && this._networkInfo.isConnected;
+  }
+
+  isNetworkInfoConnected(networkInfo) {
+    return networkInfo && networkInfo.isConnected;
+  }
+
+  onConnectivityChanged(networkInfo) {
+    this._networkInfo = networkInfo;
+  }
+
+  getNetworkType() {
+    return this._networkInfo.type;
+  }
+}
+
+var ESNetworkManager$1 = new ESNetworkManager();
+
+class ESToastModule {
+
+  showToast(message) {
+    Vue.Native.callNative('ToastModule', "showToast", message);
+  }
+
+  showLongToast(message) {
+    Vue.Native.callNative('ToastModule', "showLongToast", message);
+  }
+
+  showShortToast(message) {
+    Vue.Native.callNative('ToastModule', "showShortToast", message);
+  }
+}
+
+var ToastModule = new ESToastModule();
+
+/**
+ *
+ */
+
+class ESToast {
+  showToast(message) {
+    ToastModule.showToast(message);
+  }
+
+  showLongToast(message) {
+    ToastModule.showLongToast(message);
+  }
+
+  showShortToast(message) {
+    ToastModule.showShortToast(message);
+  }
+}
+
+var ESToast$1 = new ESToast();
+
+/**
+ *
+ */
+class ESAppModule {
+
+  isAppInstalled(packageName) {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'isAppInstalled', packageName);
+  }
+
+  isSystemApp(packageName) {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'isAppSystem', packageName);
+  }
+
+  getAppList() {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'getAppList');
+  }
+
+  getAutoStartAppList() {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'getAutoStartAppList');
+  }
+
+}
+
+var ESAppModule$1 = new ESAppModule();
+
+/**
+ *
+ */
+class ESAudioModule {
+  //------------------------通话音量------------------------
+  getStreamVoiceCallMaxVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamVoiceCallMaxVolume');
+  }
+
+  getStreamVoiceCallVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamVoiceCallVolume');
+  }
+
+  //------------------------系统音量------------------------
+  getStreamSystemMaxVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamSystemMaxVolume');
+  }
+
+  getStreamSystemVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamSystemVolume');
+  }
+
+  //------------------------铃声音量------------------------
+  getStreamRingMaxVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamRingMaxVolume');
+  }
+
+  getStreamRingVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamRingVolume');
+  }
+
+  //------------------------音乐音量------------------------
+  getStreamMusicMaxVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamMusicMaxVolume');
+  }
+
+  getStreamMusicVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamMusicVolume');
+  }
+
+  //------------------------提示音音量------------------------
+  getStreamAlarmMaxVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamAlarmMaxVolume');
+  }
+
+  getStreamAlarmVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamAlarmVolume');
+  }
+
+  //------------------------音量------------------------
+  getStreamMaxVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamMaxVolume');
+  }
+
+  getStreamVolume() {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'getStreamMaxVolume');
+  }
+
+  //------------------------调整音量------------------------
+  adjustStreamVolume(streamType, adjust, flags) {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'adjustStreamVolume', [streamType, adjust, flags]);
+  }
+
+  setStreamVolume(streamType, index, flags) {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'setStreamVolume', [streamType, index, flags]);
+  }
+
+  setStreamMute(streamType, state) {
+    return Vue.Native.callNativeWithPromise('AndroidAudioModule',
+      'setStreamMute', [streamType, state]);
+  }
+}
+
+var ESAudioModule$1 = new ESAudioModule();
+
+/**
+ *
+ */
+class ESModule {
+
+  getSupportSchemes() {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'getSupportSchemes',);
+  }
+
+  launchEsPage(params) {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'launchEsPage', {
+        pkg: params.pkg,
+        args: params.args,
+        flags: params.flags,
+        pageTag: params.pageTag,
+        pageLimit: params.pageLimit,
+        backgroundColor: params.backgroundColor,
+      });
+  }
+
+  launchNativeApp(paramsArray) {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'launchNativeApp', paramsArray);
+  }
+
+  launchNativeAppWithPackage(pkg) {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'launchNativeAppWithPackage', pkg);
+  }
+
+  sendBroadcast(paramsArray) {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'sendBroadcast', paramsArray);
+  }
+
+  startService(paramsArray) {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'startService', paramsArray);
+  }
+
+  finish() {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'finish');
+  }
+
+  finishAll() {
+    return Vue.Native.callNativeWithPromise('EsNativeModule',
+      'finishAll');
+  }
+}
+
+var ESModule$1 = new ESModule();
+
+/**
+ *
+ */
+class ESFileModule {
+
+  newFile(pathname) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'newFile', {pathname: pathname}
+    );
+  }
+
+  getName(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getName', {id: fileId}
+    );
+  }
+
+  getParent(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getParent', {id: fileId}
+    );
+  }
+
+  getPath(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getPath', {id: fileId}
+    );
+  }
+
+  isAbsolute(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'isAbsolute', {id: fileId}
+    );
+  }
+
+  getAbsolutePath(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getAbsolutePath', {id: fileId}
+    );
+  }
+
+  getCanonicalPath(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getCanonicalPath', {id: fileId}
+    );
+  }
+
+  canRead(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'canRead', {id: fileId}
+    );
+  }
+
+  canWrite(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'canWrite', {id: fileId}
+    );
+  }
+
+  exists(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'exists', {id: fileId}
+    );
+  }
+
+  isDirectory(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'isDirectory', {id: fileId}
+    );
+  }
+
+  isFile(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'isFile', {id: fileId}
+    );
+  }
+
+  isHidden(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'isHidden', {id: fileId}
+    );
+  }
+
+  lastModified(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'lastModified', {id: fileId}
+    );
+  }
+
+  length(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'length', {id: fileId}
+    );
+  }
+
+  createNewFile(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'createNewFile', {id: fileId}
+    );
+  }
+
+  deleteOnExit(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'deleteOnExit', {id: fileId}
+    );
+  }
+
+  list(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'list', {id: fileId}
+    );
+  }
+
+  mkdir(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'mkdir', {id: fileId}
+    );
+  }
+
+  mkdirs(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'mkdirs', {id: fileId}
+    );
+  }
+
+  setLastModified(fileId, time) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setLastModified', {id: fileId, time: time}
+    );
+  }
+
+  getTotalSpace(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getTotalSpace', {id: fileId}
+    );
+  }
+
+  getFreeSpace(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getFreeSpace', {id: fileId}
+    );
+  }
+
+  getUsableSpace(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'getUsableSpace', {id: fileId}
+    );
+  }
+
+  delete(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'delete', {id: fileId}
+    );
+  }
+
+  setReadOnly(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setReadOnly', {id: fileId}
+    );
+  }
+
+  setWritableOwnerOnly(fileId, writable, ownerOnly) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setReadOnly', {
+        id: fileId,
+        writable: writable,
+        ownerOnly: ownerOnly,
+      }
+    );
+  }
+
+  setWritable(fileId, writable) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setWritable', {
+        id: fileId,
+        writable: writable,
+      }
+    );
+  }
+
+  setReadableOwnerOnly(fileId, readable, ownerOnly) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setReadableOwnerOnly', {
+        id: fileId,
+        readable: readable,
+        ownerOnly: ownerOnly,
+      }
+    );
+  }
+
+
+  setReadable(fileId, readable) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setReadable', {
+        id: fileId,
+        readable: readable,
+      }
+    );
+  }
+
+  setExecutableOwnerOnly(fileId, executable, ownerOnly) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setExecutableOwnerOnly', {
+        id: fileId,
+        executable: executable,
+        ownerOnly: ownerOnly,
+      }
+    );
+  }
+
+  setExecutable(fileId, executable) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'setExecutable', {
+        id: fileId,
+        executable: executable
+      }
+    );
+  }
+
+  canExecute(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'canExecute', {id: fileId}
+    );
+  }
+
+  renameTo(fileId, renameFileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'canExecute', {id: fileId, renameFileId: renameFileId}
+    );
+  }
+
+  close(fileId) {
+    return Vue.Native.callNativeWithPromise('AndroidFileModule',
+      'close', {id: fileId}
+    );
+  }
+}
+
+var ESFileModule$1 = new ESFileModule();
+
+/**
+ *
+ */
+
+class ESFile {
+
+  _fileId = -1;
+
+  newFile(pathname) {
+    return ESFileModule$1.newFile(pathname)
+      .then((fileId) => {
+        this._fileId = fileId;
+        return Promise.resolve(fileId);
+      });
+  }
+
+  getFileId() {
+    return this._fileId;
+  }
+
+  getName() {
+    return ESFileModule$1.getName(this.getFileId());
+  }
+
+  getParent() {
+    return ESFileModule$1.getParent(this.getFileId());
+  }
+
+  getPath() {
+    return ESFileModule$1.getPath(this.getFileId());
+  }
+
+  isAbsolute() {
+    return ESFileModule$1.isAbsolute(this.getFileId());
+  }
+
+  getAbsolutePath() {
+    return ESFileModule$1.getAbsolutePath(this.getFileId());
+  }
+
+  getCanonicalPath() {
+    return ESFileModule$1.getCanonicalPath(this.getFileId());
+  }
+
+  canRead() {
+    return ESFileModule$1.canRead(this.getFileId());
+  }
+
+  canWrite() {
+    return ESFileModule$1.canWrite(this.getFileId());
+  }
+
+  exists() {
+    return ESFileModule$1.exists(this.getFileId());
+  }
+
+  isDirectory() {
+    return ESFileModule$1.isDirectory(this.getFileId());
+  }
+
+  isFile() {
+    return ESFileModule$1.isFile(this.getFileId());
+  }
+
+  isHidden() {
+    return ESFileModule$1.isHidden(this.getFileId());
+  }
+
+  lastModified() {
+    return ESFileModule$1.lastModified(this.getFileId());
+  }
+
+  length() {
+    return ESFileModule$1.length(this.getFileId());
+  }
+
+  createNewFile() {
+    return ESFileModule$1.createNewFile(this.getFileId());
+  }
+
+  deleteOnExit() {
+    return ESFileModule$1.deleteOnExit(this.getFileId());
+  }
+
+  list() {
+    return ESFileModule$1.list(this.getFileId());
+  }
+
+  mkdir() {
+    return ESFileModule$1.mkdir(this.getFileId());
+  }
+
+  mkdirs() {
+    return ESFileModule$1.mkdirs(this.getFileId());
+  }
+
+  setLastModified(time) {
+    return ESFileModule$1.setLastModified(this.getFileId(), time);
+  }
+
+  getTotalSpace() {
+    return ESFileModule$1.getTotalSpace(this.getFileId());
+  }
+
+  getFreeSpace() {
+    return ESFileModule$1.getFreeSpace(this.getFileId());
+  }
+
+  getUsableSpace() {
+    return ESFileModule$1.getUsableSpace(this.getFileId());
+  }
+
+  delete() {
+    return ESFileModule$1.delete(this.getFileId());
+  }
+
+  setReadOnly() {
+    return ESFileModule$1.setReadOnly(this.getFileId());
+  }
+
+  setWritableOwnerOnly(writable, ownerOnly) {
+    return ESFileModule$1.setWritableOwnerOnly(this.getFileId(), writable, ownerOnly);
+  }
+
+  setWritable(writable) {
+    return ESFileModule$1.setWritable(this.getFileId(), writable);
+  }
+
+  setReadableOwnerOnly(readable, ownerOnly) {
+    return ESFileModule$1.setReadableOwnerOnly(this.getFileId(), readable, ownerOnly);
+  }
+
+  setReadable(readable) {
+    return ESFileModule$1.setReadable(this.getFileId(), readable);
+  }
+
+  setExecutableOwnerOnly(executable, ownerOnly) {
+    return ESFileModule$1.setExecutableOwnerOnly(this.getFileId(), executable, ownerOnly);
+  }
+
+  setExecutable(executable) {
+    return ESFileModule$1.setExecutable(this.getFileId(), executable);
+  }
+
+  canExecute() {
+    return ESFileModule$1.canExecute(this.getFileId());
+  }
+
+  renameTo(renameFileId) {
+    return ESFileModule$1.renameTo(this.getFileId(), renameFileId);
+  }
+
+  close() {
+    return ESFileModule$1.close(this.getFileId());
+  }
+}
+
+/**
+ *
+ */
+
+class ESPermissionModule {
+
+  isPermissionsGranted(permissionList) {
+    return Vue.Native.callNativeWithPromise('AndroidPermissionModule',
+      'isPermissionsGranted', permissionList);
+  }
+
+
+  isPermissionsGrantedReverse(permissionList) {
+    return Vue.Native.callNativeWithPromise('AndroidPermissionModule',
+      'isPermissionsGrantedReverse', permissionList);
+  }
+
+
+  requestPermissions(permissionList) {
+    return Vue.Native.callNativeWithPromise('AndroidPermissionModule',
+      'requestPermissions', permissionList);
+  }
+
+  requestPermissionsReverse(permissionList) {
+    return Vue.Native.callNativeWithPromise('AndroidPermissionModule',
+      'requestPermissionsReverse', permissionList);
+  }
+
+  requestPermissionListPromise(permissionList) {
+    return Vue.Native.callNativeWithPromise('AndroidPermissionModule',
+      'requestPermissionListPromise', permissionList);
+  }
+}
+
+var ESPermissionModule$1 = new ESPermissionModule();
+
+/**
+ *
+ */
+
+class ESPowerModule {
+
+  wakeLockAcquire() {
+    return Vue.Native.callNativeWithPromise('AndroidPowerModule',
+      'wakeLockAcquire',);
+  }
+
+  wakeLockRelease() {
+    return Vue.Native.callNativeWithPromise('AndroidPowerModule',
+      'wakeLockRelease',);
+  }
+}
+
+var ESPowerModule$1 = new ESPowerModule();
+
+/**
+ *
+ */
+
+class ESSharedPreferencesModule {
+
+  initSharedPreferences(name) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'initSharedPreferences', name);
+  }
+
+  //----------------------------------------------------
+  getBoolean(key, defValue) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'getBoolean', key, defValue);
+  }
+
+  putBoolean(key, value) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'putBoolean', key, value);
+  }
+
+  //----------------------------------------------------
+
+  getInt(key, defValue) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'getInt', key, defValue);
+  }
+
+  putInt(key, value) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'putInt', key, value);
+  }
+
+  //----------------------------------------------------
+
+  getLong(key, defValue) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'getLong', key, defValue);
+  }
+
+  putLong(key, value) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'putLong', key, value);
+  }
+
+  //----------------------------------------------------
+  getString(key, defValue) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'getString', key, defValue);
+  }
+
+  putString(key, value) {
+    return Vue.Native.callNativeWithPromise('AndroidSharedPreferencesModule',
+      'putString', key, value);
+  }
+
+  //----------------------------------------------------
+}
+
+var ESSharedPreferencesModule$1 = new ESSharedPreferencesModule();
+
+/**
+ *
+ */
+
+class ESStorageModule {
+
+  getCacheDir() {
+    return Vue.Native.callNativeWithPromise('AndroidStorageModule',
+      'getCacheDir',);
+  }
+
+  getFilesDir() {
+    return Vue.Native.callNativeWithPromise('AndroidStorageModule',
+      'getFilesDir',);
+  }
+
+  getExternalCacheDir() {
+    return Vue.Native.callNativeWithPromise('AndroidStorageModule',
+      'getExternalCacheDir',);
+  }
+
+  getExternalStorageState() {
+    return Vue.Native.callNativeWithPromise('AndroidStorageModule',
+      'getExternalStorageState',);
+  }
+
+  hasExternalStoragePermission() {
+    return Vue.Native.callNativeWithPromise('AndroidStorageModule',
+      'hasExternalStoragePermission',);
+  }
+}
+
+var ESStorageModule$1 = new ESStorageModule();
+
+/**
+ *
+ */
+class ESUsbDeviceModule {
+
+  isUsbDevicePermissionsGranted(vendorId, productId) {
+    return Vue.Native.callNativeWithPromise('AndroidUsbDeviceModule',
+      'isUsbDevicePermissionsGranted', vendorId, productId);
+  }
+
+  requestUsbDevicePermission(permission, vendorId, productId) {
+    return Vue.Native.callNativeWithPromise('AndroidUsbDeviceModule',
+      'requestUsbDevicePermission', permission, vendorId, productId);
+  }
+
+  getUsbDeviceList() {
+    return Vue.Native.callNativeWithPromise('AndroidUsbDeviceModule',
+      'getUsbDeviceList');
+  }
+
+  getUsbDevice(vendorId, productId) {
+    return Vue.Native.callNativeWithPromise('AndroidUsbDeviceModule',
+      'getUsbDevice', [vendorId, productId]);
+  }
+
+  getUsbDeviceListByArray(array) {
+    return Vue.Native.callNativeWithPromise('AndroidUsbDeviceModule',
+      'getUsbDeviceListByArray', array);
+  }
+}
+
+var ESUsbDeviceModule$1 = new ESUsbDeviceModule();
+
+//
+
+const ES_ANIMATION_TYPE_NONE = "none";
+
+const ES_ANIMATION_TYPE_PLAY = "play";
+const ES_ANIMATION_TYPE_PLAY_SEQUENTIALLY = "playSequentially";
+const ES_ANIMATION_TYPE_PLAY_TOGETHER = "playTogether";
+
+const ES_ANIMATION_TYPE_WITH = "with";
+const ES_ANIMATION_TYPE_BEFORE = "before";
+const ES_ANIMATION_TYPE_AFTER = "after";
+const ES_ANIMATION_TYPE_AFTER_DELAY = "afterDelay";
+
+//
+const ES_ANIMATION_VALUE_TYPE_INT = 'ofInt';
+const ES_ANIMATION_VALUE_TYPE_FLOAT = 'ofFloat';
+
+//
+const ES_ANIMATION_PROPERTY_NAME_ALPHA = 'alpha';
+const ES_ANIMATION_PROPERTY_NAME_ROTATION = 'rotation';
+
+const ES_ANIMATION_PROPERTY_NAME_SCALE_X = 'scaleX';
+const ES_ANIMATION_PROPERTY_NAME_SCALE_Y = 'scaleY';
+
+const ES_ANIMATION_PROPERTY_NAME_TRANSLATION_X = 'translationX';
+const ES_ANIMATION_PROPERTY_NAME_TRANSLATION_Y = 'translationY';
+
+/**
+ * Capitalize a word
+ *
+ * @param {string} s The word input
+ * @returns string
+ */
+function capitalize(str) {
+  if (typeof str !== 'string') {
+    return '';
+  }
+  return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
+}
+
+/**
+ * Get binding events redirector
+ *
+ * The function should be calld with `getEventRedirector.call(this, [])`
+ * for binding this.
+ *
+ * @param {string[] | string[][]} events events will be redirect
+ * @returns Object
+ */
+function getEventRedirector(events) {
+  const on = {};
+  events.forEach((event) => {
+    if (Array.isArray(event)) {
+      const [exposedEventName, nativeEventName] = event;
+      if (Object.prototype.hasOwnProperty.call(this.$listeners, exposedEventName)) {
+        on[event] = this[`on${capitalize(nativeEventName)}`];
+      }
+    } else if (Object.prototype.hasOwnProperty.call(this.$listeners, event)) {
+      on[event] = this[`on${capitalize(event)}`];
+    }
+  });
+  return on;
+}
+
+function ESAnimationViewComponent() {
+  Vue.registerElement('AnimationViewComponent', {
+    component: {
+      name: 'AnimationViewComponent',
+      processEventData(event, nativeEventName, nativeEventParams) {
+        switch (nativeEventName) {
+          case 'onAnimationCancel':
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case 'onAnimationEnd':
+            event.animationId = nativeEventParams.animationId;
+            event.isReverse = nativeEventParams.isReverse;
+            break;
+          case 'onAnimationRepeat':
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case 'onAnimationStart':
+            event.animationId = nativeEventParams.animationId;
+            event.isReverse = nativeEventParams.isReverse;
+            break;
+          case 'onAnimationPause':
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case 'onAnimationResume':
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case 'onAnimationUpdate':
+            event.animationId = nativeEventParams.animationId;
+            event.animatedValue = nativeEventParams.animatedValue;
+            break;
+        }
+        return event;
+      },
+    },
+  });
+
+  Vue.component('es-animation-view-component', {
+    methods: {
+      resetAnimators() {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'resetAnimators', [], (res) => {
+          });
+      },
+      animatorSet(animatorId, duration, listenAnimator) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'animatorSet', [animatorId, duration, listenAnimator], (res) => {
+          });
+      },
+      //--------------------------------------------------
+      startAnimator(animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'startAnimator', [animatorId], (res) => {
+          });
+      },
+      startAnimatorDelay(animatorId, delay) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'startAnimatorDelay', [animatorId, delay], (res) => {
+          });
+      },
+      pauseAnimator(animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'pauseAnimator', [animatorId], (res) => {
+          });
+      },
+      resumeAnimator(animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'resumeAnimator', [animatorId], (res) => {
+          });
+      },
+      cancelAnimator(animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'cancelAnimator', [animatorId], (res) => {
+          });
+      },
+      reverseAnimator(animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'reverseAnimator', [animatorId], (res) => {
+          });
+      },
+      //-----------------------------------------------------------------
+      play(animatorSetId, animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'play', [animatorSetId, animatorId], (res) => {
+          });
+      },
+      with(animatorSetId, animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'with', [animatorSetId, animatorId], (res) => {
+          });
+      },
+      before(animatorSetId, animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'before', [animatorSetId, animatorId], (res) => {
+          });
+      },
+      after(animatorSetId, animatorId) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'after', [animatorSetId, animatorId], (res) => {
+          });
+      },
+      //-----------------------------------------------------------------
+      playSequentially1(animatorSetId, animatorId1) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playSequentially1', [animatorSetId, animatorId1], (res) => {
+          });
+      },
+      playSequentially2(animatorSetId, animatorId1, animatorId2) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playSequentially2', [animatorSetId, animatorId1, animatorId2], (res) => {
+          });
+      },
+      playSequentially3(animatorSetId, animatorId1, animatorId2, animatorId3) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playSequentially3', [animatorSetId, animatorId1, animatorId2, animatorId3], (res) => {
+          });
+      },
+      playSequentially4(animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playSequentially4', [animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4], (res) => {
+          });
+      },
+      playSequentially5(animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4, animatorId5) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playSequentially5', [animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4, animatorId5], (res) => {
+          });
+      },
+      //-----------------------------------------------------------------
+
+      //-----------------------------------------------------------------
+      playTogether1(animatorSetId, animatorId1) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playTogether1', [animatorSetId, animatorId1], (res) => {
+          });
+      },
+      playTogether2(animatorSetId, animatorId1, animatorId2) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playTogether2', [animatorSetId, animatorId1, animatorId2], (res) => {
+          });
+      },
+      playTogether3(animatorSetId, animatorId1, animatorId2, animatorId3) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playTogether3', [animatorSetId, animatorId1, animatorId2, animatorId3], (res) => {
+          });
+      },
+      playTogether4(animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playTogether4', [animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4], (res) => {
+          });
+      },
+      playTogether5(animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4, animatorId5) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'playTogether5', [animatorSetId, animatorId1, animatorId2, animatorId3, animatorId4, animatorId5], (res) => {
+          });
+      },
+      //-----------------------------------------------------------------
+      objectAnimator(
+        id,
+        valueType, propertyName,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator', [
+            id,
+            valueType, propertyName,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue],
+          (res) => {
+          });
+      },
+
+      objectAnimator1(id,
+                      valueType, propertyName,
+                      value1,
+                      duration, repeatMode, repeatCount,
+                      listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator1', [
+            id,
+            valueType, propertyName,
+            value1,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator2(
+        id,
+        valueType, propertyName,
+        value1, value2,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator2', [
+            id,
+            valueType, propertyName,
+            value1, value2,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator3(
+        id,
+        valueType, propertyName,
+        value1, value2, value3,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator3', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator4(
+        id,
+        valueType, propertyName,
+        value1, value2, value3, value4,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator4', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3, value4,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator5(
+        id,
+        valueType, propertyName,
+        value1, value2, value3, value4, value5,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator5', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3, value4, value5,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator6(
+        id,
+        valueType, propertyName,
+        value1, value2, value3, value4, value5, value6,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator6', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3, value4, value5, value6,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator7(
+        id,
+        valueType, propertyName,
+        value1, value2, value3, value4, value5, value6, value7,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator7', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3, value4, value5, value6, value7,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator8(
+        id,
+        valueType, propertyName,
+        value1, value2, value3, value4, value5, value6, value7, value8,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator8', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3, value4, value5, value6, value7, value8,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator9(
+        id,
+        valueType, propertyName,
+        value1, value2, value3, value4, value5, value6, value7, value8, value9,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator9', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3, value4, value5, value6, value7, value8, value9,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+      objectAnimator10(
+        id,
+        valueType, propertyName,
+        value1, value2, value3, value4, value5, value6, value7, value8, value9, value10,
+        duration, repeatMode, repeatCount,
+        listenAnimator, listenAnimatorValue) {
+        Vue.Native.callUIFunction(this.$refs.animationView,
+          'objectAnimator10', [
+            id,
+            valueType, propertyName,
+            value1, value2, value3, value4, value5, value6, value7, value8, value9, value10,
+            duration, repeatMode, repeatCount,
+            listenAnimator, listenAnimatorValue], (res) => {
+          });
+      },
+
+
+      //---------------------------------------
+      onAnimationCancel(evt) {
+        let id = evt.animationId;
+        this.$emit('on-animation-cancel', id);
+      },
+      onAnimationEnd(evt) {
+        let id = evt.animationId;
+        let isReverse = evt.isReverse;
+        this.$emit('on-animation-end', id, isReverse);
+      },
+      onAnimationRepeat(evt) {
+        let id = evt.animationId;
+        this.$emit('on-animation-repeat', id);
+      },
+      onAnimationStart(evt) {
+        let id = evt.animationId;
+        let isReverse = evt.isReverse;
+        this.$emit('on-animation-start', id, isReverse);
+      },
+      onAnimationPause(evt) {
+        let id = evt.animationId;
+        this.$emit('on-animation-pause', id);
+      },
+      onAnimationResume(evt) {
+        let id = evt.animationId;
+        this.$emit('on-animation-resume', id);
+      },
+      onAnimationUpdate(evt) {
+        let id = evt.animationId;
+        let value = evt.animatedValue;
+        this.$emit('on-animation-update', id, value);
+      }
+    },
+
+    render(h) {
+      const on = getEventRedirector.call(this, [
+        ['on-animation-end', 'animationEnd'],
+        ['on-animation-cancel', 'animationCancel'],
+        ['on-animation-start', 'animationStart'],
+        ['on-animation-repeat', 'animationRepeat'],
+        ['on-animation-pause', 'aAnimationPause'],
+        ['on-animation-resume', 'animationResume'],
+        ['on-animation-update', 'animationUpdate'],
+      ]);
+      return h('AnimationViewComponent',
+        {
+          on,
+          ref: 'animationView',
+        }, this.$slots.default);
+    },
+  });
+}
+
+function ESSeekBarViewComponent() {
+  Vue.registerElement('TVSeekBarViewComponent', {
+    component: {
+      name: 'TVSeekBarViewComponent',
+      processEventData(event, nativeEventName, nativeEventParams) {
+        switch (nativeEventName) {
+          case 'onFocus':
+            event.isFocused = nativeEventParams.isFocused;
+            break;
+          case 'onSeekBarChange':
+            event.fromUser = nativeEventParams.fromUser;
+            event.progress = nativeEventParams.progress;
+            break;
+        }
+        return event;
+      },
+    },
+  });
+
+  Vue.component('es-seek-bar-view-component', {
+
+    methods: {
+      setMaxProgress(progress) {
+        Vue.Native.callUIFunction(this.$refs.TVSeekBar,
+          'setMaxProgress', [progress], (res) => {
+          });
+      },
+      setProgress(progress) {
+        Vue.Native.callUIFunction(this.$refs.TVSeekBar,
+          'setProgress', [progress], (res) => {
+          });
+      },
+      setSecondProgress(progress) {
+        Vue.Native.callUIFunction(this.$refs.TVSeekBar,
+          'setSecondProgress', [progress], (res) => {
+          });
+      },
+      show(value) {
+        Vue.Native.callUIFunction(this.$refs.TVSeekBar,
+          'show', [value], (res) => {
+          });
+      },
+      onFocusChange(evt) {
+        this.$emit('focus', evt);
+      },
+      onSeekBarChange(evt) {
+        this.$emit('seek-change', evt);
+      },
+
+    },
+
+    render(h) {
+      const on = getEventRedirector$1.call(this, [
+        ['focus', 'focusChange'],
+        ['seek-change', 'seekBarChange'],
+      ]);
+      return h('TVSeekBarViewComponent',
+        {
+          on,
+          ref: 'ESSeekBarView',
+        }, this.$slots.default);
+    },
+  });
+}
+
+function ESProgressBarViewComponent() {
+  Vue.registerElement('TVProgressBarViewComponent', {
+    component: {
+      name: 'TVProgressBarViewComponent',
+    },
+  });
+
+  Vue.component('es-progress-bar-view-component', {
+    methods: {
+      setMaxProgress(progress) {
+        Vue.Native.callUIFunction(this.$refs.TVProgressBar,
+          'setMaxProgress', [progress], (res) => {
+          });
+      },
+      setProgress(progress) {
+        Vue.Native.callUIFunction(this.$refs.TVProgressBar,
+          'setProgress', [progress], (res) => {
+          });
+      },
+      setSecondProgress(progress) {
+        Vue.Native.callUIFunction(this.$refs.TVProgressBar,
+          'setSecondProgress', [progress], (res) => {
+          });
+      },
+      show(value) {
+        Vue.Native.callUIFunction(this.$refs.TVSeekBar,
+          'show', [value], (res) => {
+          });
+      },
+    },
+    render(h) {
+      return h('TVProgressBarViewComponent',
+        {
+          ref: 'ESProgressBarView'
+        }, this.$slots.default
+      );
+    }
+  });
+}
+
+function ESLoadingViewComponent() {
+  Vue.registerElement('LoadingViewComponent', {
+    component: {
+      name: 'LoadingViewComponent'
+    },
+  });
+
+  Vue.component('es-loading-view-component', {
+
+    render(h) {
+      return h('LoadingViewComponent',
+        {
+          ref: 'LoadingView'
+        }, this.$slots.default
+      );
+    }
+  });
+}
+
+function ESTransitionImageViewComponent() {
+  Vue.registerElement('TransitionImageComponent', {
+    component: {
+      name: 'TransitionImageComponent'
+    },
+  });
+
+  Vue.component('es-transition-image-view-component', {
+    methods: {
+      setNextColor(color) {
+        Vue.Native.callUIFunction(this.$refs.transitionImageComponent,
+          'setNextColor', [color], (res) => {
+          });
+      },
+      setNextImage(url) {
+        Vue.Native.callUIFunction(this.$refs.transitionImageComponent,
+          'setNextImage', [url], (res) => {
+          });
+      },
+      setTransitionTime(duration) {
+        Vue.Native.callUIFunction(this.$refs.transitionImageComponent,
+          'setTransitionTime', [duration], (res) => {
+          });
+      },
+    },
+    render(h) {
+      return h('TransitionImageComponent',
+        {
+          ref: 'transitionImageComponent'
+        }, this.$slots.default
+      );
+    }
+  });
+}
+
+function ESQRCodeViewComponent() {
+  Vue.registerElement('QrCodeComponent', {
+    component: {
+      name: 'QrCodeComponent'
+    },
+  });
+
+  Vue.component('es-qr-code-view-component', {
+
+    render(h) {
+      return h('QrCodeComponent',
+        {
+          ref: 'qrCode'
+        }, this.$slots.default
+      );
+    }
+  });
+}
+
+//
+const ES_NETWORK_INFO_STATE_CONNECTING = 0;
+const ES_NETWORK_INFO_STATE_CONNECTED = 1;
+const ES_NETWORK_INFO_STATE_SUSPENDED = 2;
+const ES_NETWORK_INFO_STATE_DISCONNECTING = 3;
+const ES_NETWORK_INFO_STATE_DISCONNECTED = 4;
+const ES_NETWORK_INFO_STATE_UNKNOWN = 5;
+
+//
+const ES_NETWORK_INFO_TYPE_NONE = -1;
+const ES_NETWORK_INFO_TYPE_MOBILE = 0;
+const ES_NETWORK_INFO_TYPE_WIFI = 1;
+const ES_NETWORK_INFO_TYPE_ETHERNET = 9;
+
+let ESApp;
+
+function setESApp(app) {
+  ESApp = app;
+}
+
+function getESApp() {
+  return ESApp;
+}
+
+var ESNetworkMixin = {
+  mounted() {
+    ESApp.$on('onConnectivityChanged', this.onConnectivityChanged);
+  },
+
+  methods: {
+    onConnectivityChanged(networkInfo) {
+      ESNetworkManager$1.onConnectivityChanged(networkInfo);
+      this.onESConnectivityChanged(networkInfo);
+    },
+
+    onESConnectivityChanged(networkInfo) {
+
+    }
+  },
+
+  beforeDestroy() {
+    ESApp.$off('onConnectivityChanged', this.onConnectivityChanged);
+  },
+};
+
+var ESUsbDeviceMixin = {
+  mounted() {
+    ESApp.$on('onUsbDeviceAttached', this.onUsbDeviceAttached);
+    ESApp.$on('onUsbDeviceDetached', this.onUsbDeviceDetached);
+  },
+
+  methods: {
+    onUsbDeviceAttached(usbDevice) {
+      this.onESUsbDeviceAttached(usbDevice);
+    },
+
+    onUsbDeviceDetached(usbDevice) {
+      this.onESUsbDeviceDetached(usbDevice);
+    },
+
+    //--------------------------------------
+    onESUsbDeviceAttached(usbDevice) {
+
+    },
+    onESUsbDeviceDetached(usbDevice) {
+
+    },
+  },
+
+  beforeDestroy() {
+    ESApp.$off('onUsbDeviceAttached', this.onUsbDeviceAttached);
+    ESApp.$off('onUsbDeviceDetached', this.onUsbDeviceDetached);
+  },
+};
+
+export { ESAnimationViewComponent, ESApp, ESAppModule$1 as ESAppModule, ESAudioModule$1 as ESAudioModule, ESDevelopManager$1 as ESDevelopManager, ESDevelopModule$1 as ESDevelopModule, ESDeviceManager$1 as ESDeviceManager, ESDeviceModule$1 as ESDeviceModule, ESFile, ESFileModule$1 as ESFileModule, ESLoadingViewComponent, ESModule$1 as ESModule, ESNetworkManager$1 as ESNetworkManager, ESNetworkMixin, ESNetworkModule$1 as ESNetworkModule, ESPermissionModule$1 as ESPermissionModule, ESPowerModule$1 as ESPowerModule, ESProgressBarViewComponent, ESQRCodeViewComponent, ESSeekBarViewComponent, ESSharedPreferencesModule$1 as ESSharedPreferencesModule, ESStorageModule$1 as ESStorageModule, ESToast$1 as ESToast, ToastModule as ESToastModule, ESTransitionImageViewComponent, ESUsbDeviceMixin, ESUsbDeviceModule$1 as ESUsbDeviceModule, ES_ANIMATION_PROPERTY_NAME_ALPHA, ES_ANIMATION_PROPERTY_NAME_ROTATION, ES_ANIMATION_PROPERTY_NAME_SCALE_X, ES_ANIMATION_PROPERTY_NAME_SCALE_Y, ES_ANIMATION_PROPERTY_NAME_TRANSLATION_X, ES_ANIMATION_PROPERTY_NAME_TRANSLATION_Y, ES_ANIMATION_TYPE_AFTER, ES_ANIMATION_TYPE_AFTER_DELAY, ES_ANIMATION_TYPE_BEFORE, ES_ANIMATION_TYPE_NONE, ES_ANIMATION_TYPE_PLAY, ES_ANIMATION_TYPE_PLAY_SEQUENTIALLY, ES_ANIMATION_TYPE_PLAY_TOGETHER, ES_ANIMATION_TYPE_WITH, ES_ANIMATION_VALUE_TYPE_FLOAT, ES_ANIMATION_VALUE_TYPE_INT, ES_NETWORK_INFO_STATE_CONNECTED, ES_NETWORK_INFO_STATE_CONNECTING, ES_NETWORK_INFO_STATE_DISCONNECTED, ES_NETWORK_INFO_STATE_DISCONNECTING, ES_NETWORK_INFO_STATE_SUSPENDED, ES_NETWORK_INFO_STATE_UNKNOWN, ES_NETWORK_INFO_TYPE_ETHERNET, ES_NETWORK_INFO_TYPE_MOBILE, ES_NETWORK_INFO_TYPE_NONE, ES_NETWORK_INFO_TYPE_WIFI, getESApp, setESApp };