@molejs/mole-jssdk/es/devicePermission.js

mole app jssdk

function dingTalkPolyfill () {
  return {
    openNewPage: function openNewPage(_ref) {
      var url = _ref.url;

      window.dd.biz.util.openLink({
        url: url });
    },

    get version() {
      return window.dd.version;
    }
  };
}

var ua = window.navigator.userAgent;

function dynamicLoadJs(url, callback) {
  var head = document.getElementsByTagName('head')[0];
  var script = document.createElement('script');
  script.type = 'text/javascript';
  script.src = url;
  if (typeof callback == 'function') {
    script.onload = script.onreadystatechange = function () {
      if (!this.readyState || this.readyState === "loaded" || this.readyState === "complete") {
        callback();
        script.onload = script.onreadystatechange = null;
      }
    };
  }
  head.appendChild(script);
}

var platform = {
  get iPhoneX() {
    return (/iphone/gi.test(ua) && screen.height == 812 && screen.width == 375
    );
  },

  get iPhoneXR() {
    return (/iphone/gi.test(window.navigator.userAgent) && window.devicePixelRatio && window.devicePixelRatio === 2 && window.screen.width === 414 && window.screen.height === 896
    );
  },

  get iPhoneXSMax() {
    return (/iphone/gi.test(window.navigator.userAgent) && window.devicePixelRatio && window.devicePixelRatio === 3 && window.screen.width === 414 && window.screen.height === 896
    );
  },

  get os() {
    if (ua.match(/(Android);?[\s\/]+([\d.]+)?/)) {
      return 'android';
    }    var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
    var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
    var iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/);
    if (ipad || iphone || ipod) return 'ios';
    return '';
  },

  get container() {
    if (ua.toLowerCase().match(/upaasapp/i)) return 'italent';
    if (ua.toLowerCase().match(/tita/i)) return 'tita';
    if (ua.match(/DingTalk/i)) return 'dingTalk';
    if (ua.match(/MicroMessenger/i)) return 'wechart';
    if (ua.match(/wxwork/i)) return 'wxwork';
    return 'browser';
  },

  get OS() {
    if (ua.match(/(Android);?[\s\/]+([\d.]+)?/)) {
      return 'android';
    }    var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
    var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
    var iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/);
    if (ipad || iphone || ipod) return 'ios';
    return '';
  },

  get ShellName() {
    if (ua.toLowerCase().match(/upaasapp/i)) return 'italent';
    if (ua.toLowerCase().match(/tita/i)) return 'tita';
    if (ua.match(/DingTalk/i)) return 'dingTalk';
    if (ua.match(/MicroMessenger/i)) return 'wechart';
    if (ua.match(/wxwork/i)) return 'wxwork';
    return 'browser';
  },
  get web() {
    if (/mobile|android|iphone|ipad|phone/i.test(ua) && !platform.bsAppAndroid && !platform.bsAppIOS) {
      return true;
    }
    return false;
  },

  get ios() {
    return platform.os === 'ios';
  },

  get android() {
    return platform.os === 'android';
  },

  get weixin() {
    return !!ua.match(/MicroMessenger/i);
  },

  get weixinWork() {
    return !!ua.match(/wxwork/i);
  },

  get bsAppIOS() {
    return !!ua.toLowerCase().match(/beisen/i) && platform.ios && platform.apiCloud;
  },

  get beisenApp() {
    return platform.bsAppIOS || platform.bsAppAndroid;
  },

  get bsAppAndroid() {
    return !!ua.toLowerCase().match(/beisen/i) && platform.android;
  },
  get apiCloud() {
    return !!ua.toLowerCase().match(/apicloud/i);
  },

  get titaApp() {
    return !!ua.toLowerCase().match(/tita/i);
  },

  get titav2App() {
    return !!ua.match(/Titav2/i);
  },
  get upaasApp() {
    return !!ua.toLowerCase().match(/upaasapp/i);
  },

  get dingTalk() {
    return !!ua.match(/DingTalk/i);
  },
  get bayer() {
    return !!ua.match(/Bayer/i);
  },
  get iTalentIOS() {
    return platform.ios && platform.apiCloud && platform.upaasApp;
  },
  get iTalentAndroid() {
    return platform.android && platform.upaasApp;
  },

  get iTalentWeb() {
    return false;
  },
  get api() {
    return platform.bsAppIOS ? window.api || window.top.api || {} : window.BSJSBridge;
  },
  waitApi: function waitApi() {
    var t = void 0;
    return new Promise(function (reslove, reject) {
      if (!!ua.match(/DingTalk/i)) {
        return dynamicLoadJs('//g.alicdn.com/dingding/dingtalk-jsapi/2.3.0/dingtalk.open.js', function () {
          window.api = dingTalkPolyfill(window.dd);
          return reslove({});
        });
      }

      if (platform.bsAppAndroid) {
        if (window.BSJSBridge || window.parent.BSJSBridge) {
          return reslove({
            api: window.BSJSBridge || window.parent.BSJSBridge
          });
        }

        t = setInterval(function () {
          if (window.BSJSBridge || window.parent.BSJSBridge) {
            clearInterval(t);
            return reslove({
              api: window.BSJSBridge || window.parent.BSJSBridge
            });
          }
        }, 16);
      } else if (platform.bsAppIOS) {
        if (window.api || window.parent.api) {
          return reslove({
            api: window.api || window.parent.api
          });
        }

        t = setInterval(function () {
          if (window.api || window.parent.api) {
            clearInterval(t);
            return reslove({
              api: window.api || window.parent.api
            });
          }
        }, 16);
      } else {
        return reslove({});
      }
    });
  },
  waitApiV2: function waitApiV2() {
    var t = void 0;
    return new Promise(function (reslove, reject) {
      if (platform.dingTalk) {
        return dynamicLoadJs('//g.alicdn.com/dingding/dingtalk-jsapi/2.3.0/dingtalk.open.js', function () {
          window.api = dingTalkPolyfill(window.dd);
          return reslove({});
        });
      }
      if (platform.bsAppAndroid) {
        if (window.bsapi || window.parent.bsapi) {
          return reslove({
            api: window.bsapi || window.parent.bsapi
          });
        }

        t = setInterval(function () {
          if (window.bsapi || window.parent.bsapi) {
            clearInterval(t);
            return reslove({
              api: window.bsapi || window.parent.bsapi
            });
          }
        }, 16);
      } else if (platform.bsAppIOS) {
        if (window.api || window.parent.api) {
          return reslove({
            api: window.api || window.parent.api
          });
        }

        t = setInterval(function () {
          if (window.api || window.parent.api) {
            clearInterval(t);
            return reslove({
              api: window.api || window.parent.api
            });
          }
        }, 16);
      }
    });
  },
  select: function select() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var mobile = params.mobile,
        androidApp = params.androidApp,
        iosApp = params.iosApp,
        beisenApp = params.beisenApp,
        weixin = params.weixin,
        weixinWork = params.weixinWork,
        dingTalk = params.dingTalk;


    var cb = void 0;
    if (platform.bsAppIOS && iosApp) {
      cb = iosApp;
    } else if (platform.bsAppAndroid && androidApp) {
      cb = androidApp;
    } else if (platform.dingTalk && dingTalk) {
      cb = dingTalk;
    } else if (platform.weixin && weixin) {
      cb = weixin;
    } else if (platform.weixinWork && weixinWork) {
      cb = weixinWork;
    } else {
      cb = mobile;
    }

    if (platform.beisenApp && beisenApp) {
      cb = beisenApp;
    }

    if (typeof cb === 'function') {
      return cb();
    }
  }
};

function promiseToCallback(prom, callback) {
  return prom.then(function (arg) {
    callback && callback(null, arg);
    return arg;
  }).catch(function (err) {
    callback && callback(err);
    return Promise.reject(err);
  });
}

function getApi() {
  return new Promise(function (resolve, reject) {
    if (platform.ios) {
      var BSApi = window.api.require('BSApi');
      resolve(BSApi);
    } else {
      resolve(window.bsapi);
    }
  });
}

var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();

var get = function get(object, property, receiver) {
  if (object === null) object = Function.prototype;
  var desc = Object.getOwnPropertyDescriptor(object, property);

  if (desc === undefined) {
    var parent = Object.getPrototypeOf(object);

    if (parent === null) {
      return undefined;
    } else {
      return get(parent, property, receiver);
    }
  } else if ("value" in desc) {
    return desc.value;
  } else {
    var getter = desc.get;

    if (getter === undefined) {
      return undefined;
    }

    return getter.call(receiver);
  }
};

var inherits = function (subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};

var possibleConstructorReturn = function (self, call) {
  if (!self) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return call && (typeof call === "object" || typeof call === "function") ? call : self;
};

var MoleError = function (_Error) {
  inherits(MoleError, _Error);

  function MoleError(msg) {
    classCallCheck(this, MoleError);
    return possibleConstructorReturn(this, (MoleError.__proto__ || Object.getPrototypeOf(MoleError)).call(this, msg));
  }

  createClass(MoleError, [{
    key: "toString",
    value: function toString() {
      return "[MoleError] " + get(MoleError.prototype.__proto__ || Object.getPrototypeOf(MoleError.prototype), "toString", this).call(this);
    }
  }]);
  return MoleError;
}(Error);

var DevicePermissions = {
  Camera: 'camera',
  Album: 'album',
  Contacts: 'contacts',
  Microphone: 'microphone',
  Location: 'location',
  Calendar: 'calendar',
  Phone: 'phone',
  Sms: 'sms',
  Storage: 'storage' };

function filterArray(src, shouldInclude) {
  var excluded = [];
  var excludedIndexes = [];
  var result = src.reduce(function (acc, cur, idx, src2) {
    if (shouldInclude(cur)) {
      acc.push(cur);
    } else {
      excluded.push(cur);
      excludedIndexes.push(idx);
    }
    return acc;
  }, []);
  return {
    result: result,
    excluded: excluded,
    excludedIndexes: excludedIndexes
  };
}

function restoreFilteredArray(src, excluded, excludedIndexes) {
  var cp = src.concat();
  excludedIndexes.forEach(function (idx, i) {
    cp.splice(idx, 0, excluded[i]);
  });
  return cp;
}

function filterNoNeedRequestPermissions(perms) {
  var isIOS = platform.ios;
  var r = filterArray(perms, function (p) {
    return isIOS || !isIOS && p !== DevicePermissions.Album;
  });
  return r;
}

function restoreNoNeedRequestPermissions(ret, nnrFiltered, neverField) {
  var noNeedReqFill = nnrFiltered.excluded.map(function (p) {
    var obj = {
      name: p,
      granted: true
    };
    if (neverField) {
      obj.never = false;
    }
    return obj;
  });
  var retRestored = restoreFilteredArray(ret, noNeedReqFill, nnrFiltered.excludedIndexes);
  return retRestored;
}

function hasPermission(permissions, callback) {
  var orgIsArray = Array.isArray(permissions);
  var nnrFiltered = filterNoNeedRequestPermissions(orgIsArray ? permissions : [permissions]);
  var prom = getApi().then(function (api) {
    return new Promise(function (resolve, reject) {
      if (nnrFiltered.result.length === 0) {
        resolve([]);
        return;
      }
      var ret = api.hasPermission({ list: nnrFiltered.result });
      resolve(ret);
    });
  }).then(function (ret) {
    return restoreNoNeedRequestPermissions(ret, nnrFiltered, false);
  }).then(function (retRestored) {
    if (orgIsArray) {
      return retRestored;
    } else {
      return retRestored[0];
    }
  }).catch(function (ex) {
    return Promise.reject(new MoleError(ex));
  });
  return promiseToCallback(prom, callback);
}

function requestPermission(permissions, callback) {
  var orgIsArray = Array.isArray(permissions);
  var nnrFiltered = filterNoNeedRequestPermissions(orgIsArray ? permissions : [permissions]);
  var prom = getApi().then(function (api) {
    return new Promise(function (resolve, reject) {
      if (nnrFiltered.result.length === 0) {
        resolve([]);
        return;
      }
      api.requestPermission({ list: nnrFiltered.result }, function (ret, err) {
        if (ret) {
          resolve(ret);
        } else {
          reject(err);
        }
      });
    });
  }).then(function (ret) {
    return restoreNoNeedRequestPermissions(ret, nnrFiltered, true);
  }).then(function (retRestored) {
    if (orgIsArray) {
      return retRestored;
    } else {
      return retRestored[0];
    }
  }).catch(function (ex) {
    return Promise.reject(new MoleError(ex));
  });
  return promiseToCallback(prom, callback);
}

export { DevicePermissions, hasPermission, requestPermission };