API Function

下载apk方法

函数封装

class nativeAPI {
    /**
    * 本地下载api封装
    * @param {*} parameter
    * parameter: {   // 下载地址(http/https)开头
    *     url：文件下载地址，网络连接
    *     fileName：保存本地的文件夹名称（下载后保存到该文件夹内）
    *     appName：文件名称（下载的文件名称）
    * }
    * @param {*} callback （文件下载的进度条进度）（下载成功后返回的对象）
    */
    downLoadApi(parameter, callback) {
        // 创建下载接口
        const dtask = plus.downloader.createDownload(
            // 下载地址
            parameter.url,
            // 本地文件地址（安卓手机路径）
            {
                filename: `file://storage/emulated/0/${parameter.fileName}/${parameter.appName}`,
            },
            function (r, status) {
                if (status == 200) {
                    // 下载成功
                } else {
                    //status为200表示下载成功
                    // 则表示下载失败
                    console.log("下载失败", r);
                    plus.downloader.clear(); //清除下载任务
                }
            }
        );

        // 保存上一次的进度条进度变化的值
        let copyProgress = "";

        // 监听下载进度(每次下载进度变化便会执行一次该回调)
        dtask.addEventListener("statechanged", (task) => {
            // 如果监听对象不存在,则直接退出
            if (!dtask) return;

            /**
             * task.state: 状态:1,2,3,4
             * 1. 表示开始下载
             * 2. 链接到服务器
             * 3. 下载中 (监听进度进度)
             * 4. 下载完成
             */
            switch (task.state) {
                case 3:
                    // 计算下载进度比列
                    const progress = Math.floor(
                        (task.downloadedSize / task.totalSize) * 100
                    );
                    /**
                     * 起因：一样的进度值会多次执行
                     * 解决方法：保留上一次的进度值和目前进度值进行对比，如果相同，表示重复执行立即退出，否则为最新进度，对比参数同步更新
                     */
                    if (copyProgress == progress) return;
                    copyProgress = progress;
                    // 如果进度值为100者退出执行 让其进度下一个判断
                    if (progress == 100) return;
                    callback && callback({ progress, path: "下载中，下载后可获取文件路径" });
                    break;

                case 4:
                    // 状态码为4表示当前下载完成，恢复对比参数
                    copyProgress = "";
                    // 执行完回调函数 (progress: 为进度条进度 )(path为下载后的文件路径)
                    callback && callback({ progress: 100, path: task.filename });
                    break;
            }
        });

        // 开始下载
        dtask.start();
    }

    /**
     * 查找文件是否存在
     * @param {*} callback 
     * callback: {   // 下载地址(http/https)开头
     *     path：文件下载地址，网络连接
     *     success:()=>{}    查询成功后调取的回调函数
     *     fail:()=>{}       查询失败后调取的回调函数
     * }
     */
    lookupFile(callback) {
        plus.io.getFileInfo({
            // 查询的文件路径
            filePath: callback.path,
            // 查询成功
            success: (res) => {
                callback && callback.success && callback.success({ status: 200, size: Number(res.size) / 1024 });
            },
            // 查询失败
            fail: (r) => {
                callback && callback.fail && callback.fail({ status: 201, msg: "文件不存在", ...r });
            },
        });
    }

    /**
     * 调起手机app安装
     * @param {*} path 安装的app路径
     */
    installApp(path) {
        // plus.runtime.openFile(`file://storage/emulated/0/${path}`);
        plus.runtime.openFile(path);
    }

     /**
     * 权限申请
     * @param {*} callback 回调函数（在存储条件允许的情况下执行该函数）
     */
    PermissionApplication(callback) {
        plus.android.requestPermissions(['android.permission.WRITE_EXTERNAL_STORAGE'], function (e) {
            if (e.deniedAlways.length > 0) { //权限被永久拒绝
                // 弹出提示框解释为何需要读写手机储存权限，引导用户打开设置页面开启
                uni.showModal({
                    title: '存储权限',
                    content: '您拒绝了存储权限，请前往设置-应用开启存储权限。',
                    success: function (res) {
                        if (res.confirm) {
                            // console.log('用户点击确定');
                        } else if (res.cancel) {
                            // console.log('用户点击取消');
                        }
                    }
                });
            }

            if (e.deniedPresent.length > 0) { //权限被临时拒绝
                // 弹出提示框解释为何需要读写手机储存权限，可再次调用plus.android.requestPermissions申请权限
                plus.android.requestPermissions(['android.permission.WRITE_EXTERNAL_STORAGE'])
            }

            if (e.granted.length > 0) { //权限被允许
                //调用依赖获取读写手机储存权限的代码
                callback && callback();
            }
        });
    }
}

使用方法

  // 查看当前app是否存在
  nativeAPI.lookupFile({
    // 文件路径
    path: `file://storage/emulated/0/${'LUKES后台管理/LUKES后台管理.apk'}`,
    success(res) {
      // 查询到文件返回文件信息
      // console.log(res, "文件查找成功");
    },
    fail(r) {
      // 没有该文件
      // console.log(res, "文件不存在");
    }
  });


   // 安装app方法
   nativeAPI.installApp(`file://storage/emulated/0/${'LUKES后台管理/LUKES后台管理.apk'}`);

   // 下载app方法
   nativeAPI.downLoadApi(
       {
       // 下载app地址 （下载地址(http/https)开头）（网络连接）
         url: "https://vip.123pan.cn/1818386522/%E6%B········",
       // 创建本地文件并保存到（fileName属性值）文件夹中  （自定义文件夹，并把下载好的文件放到当前文件夹中）
         fileName: "LUKES后台管理",
       // 文件名称
         appName: "LUKES后台管理.apk",
       },
       (res) => {
           // res ==> res.progress (进度条进度)
           // res ==> res.path (当前文件地址)

           // 进度条为100时，表示下载成功
         if (res.progress == 100) {
           // 调起手机安装程序  安装app
           nativeAPI.installApp(res.path);
         }
       }
   );

设置剪切板内容

/**
 * 复制文本内容
 * @param {*} text 复制的文本
 * @param {*} [callback] 复制完成后的回调函数 => { return text } 返回复制的文本内容
 */
setCopy(text, callback) {
    uni.setClipboardData({
        data: text,
        showToast: false,
        success() { callback && callback(text) }
    });
}

获取剪切板内容

/**
 * 保存文件到本地
 * @param {*} path 文件链接 
 */
addFile(path) {
    uni.saveFile({
        tempFilePath: path,
        success(res) {
            console.log(res);
        }
    });
}

保存文件到本地

/**
 * 保存文件到本地
 * @param {*} path 文件链接 
 */
addFile(path) {
    uni.saveFile({
        tempFilePath: path,
        success(res) {
            console.log(res);
        }
    });
}

保存图片到相册

/**
 * 保存图片到相册
 * @param {*} url 需要保存的图片地址
 * @param {*} [callback] 保存成功后的回调函数
 */
savePick(url, callback) {
    uni.saveImageToPhotosAlbum({
        filePath: url,
        success: (res) => {
            callback && callback(res);
            this.msgInfo("保存成功，请到相册中查看");
        }
    });
}

预览图片

/**
 * 预览图片
 * @param {*} imgsArr 预览图片的数组 （图片集合）
 * @param {*} [itemList] 长安图片的菜单栏 例如：['发送给朋友', '保存图片', '收藏']
 * @param {*} [callback] 点击某一个菜单栏的回调函数 （返回点击的按钮以及图片索引）
 * @param {*} [rej] 返回错误信息
 */
pickyl(current, imgsArr, itemList = ["暂无功能"], callback, rej) {
    let _this = this;
    uni.previewImage({
        // 当前图片索引
        current,
        // 图片集合
        urls: imgsArr,
        indicator: "number",
        longPressActions: {
            itemList: ['保存图片'],
            // itemList: itemList,
            success: (data) => {
                // 用户点击的当前图片
                const downImg = imgsArr[data.index];
                _this.downLoad(downImg, () => { }, { img: true });
                // callback && callback({
                //     // '选中了第' + (data.tapIndex + 1) + '个按钮
                //     btnIndex: data.tapIndex + 1,
                //     // 第' + (data.index + 1) + '张图片'
                //     imgIndex: data.index + 1,
                // })
                // console.log('选中了第' + (data.tapIndex + 1) + '个按钮,第' + (data.index + 1) + '张图片');
            },
            fail(err) { rej && rej(err) }
        }
    });
}

选择图片

/**
 * 选择图片 
 * @param {*} num 选择的张数
 * @param {*} optionType 从哪里选择 （1.表示从相册选图 2.相机拍照 3.两者都有）
 * @param {*} [oss] 是否转换为oss格式 （Boolean）
 * @param {*} [callback] 图片选取后的回调函数
 */
optionsImg(num = 9, optionType, callback, oss) {
    let _this = this;
    // 判断需要的类型
    let arr = optionType == 1 ? ["album"] : optionType == 2 ? ["camera"] : ["album", "camera"];
    uni.chooseImage({
        count: num, //默认可以选择9张图片
        sizeType: ["original", "compressed"], //可以指定是原图还是压缩图，默认二者都有
        sourceType: arr, //从相册选择
        success: async (res) => {
            if (oss) {
                let arr = await _this.picKImgs(res.tempFilePaths)
                callback && callback(arr);
                return
            }
            callback && callback(res.tempFilePaths)
        },
    });
}

图片转换为oss

// 图片转换为oss [res为数组，包含多张图片路径]
async picKImgs(res) {
    // 文件名称
    let name = appInst.getStore("info").nickname || "新用户";
    // 转换后的路径
    let newImgs = []
    for (const item of res) {
        let img = await uploadImg({ path: item, name });
        // 判断是否转换成功
        if (img.success) {
            newImgs.push(img.fileID)
            console.log(img.fileID);
        }
        // 判断是否把所有的图片都成功的转为oss
        if (res.length == newImgs.length) {
            return newImgs;
        }
    }
}

查看图片信息

/**
 * 查看图片信息
 * @param {*} url 图片地址
 * @param {*} callback 成功后的回调函数 return（图片信息）
 */
imgInfo(url, callback) {
    uni.getImageInfo({
        src: url,
        success: (res) => callback && callback(res)
    });
}

图片下载

/**
 * 图片下载
 * @param {*} url 文件地址
 * @param {*} callback 下载后的回调函数
 */
downLoad(url, callback, setting) {
    let _this = this;
    uni.downloadFile({
        url,
        success: (res) => {
            callback && callback(res)
            if (setting.img) {
                // 保存到相册中
                _this.savePick(res.tempFilePath);
            }
        },
        fail(err) {
            console.log(err);
        }
    });
}

判断手机号码是否正确

/**
 * 判断手机号码是否正确
 * @param {*} num 手机号码
 * @returns 
 */
isTel(num) {
    let tel = /^(?:(?:\+|00)86)?1(?:(?:3[\d])|(?:4[5-79])|(?:5[0-35-9])|(?:6[5-7])|(?:7[0-8])|(?:8[\d])|(?:9[1589]))\d{8}$/;
    return tel.test(num)
}

截取字符串个数

/**
 * 截取字符串个数
 * @param {*} str 要截取的字符串
 * @param {*} num 要截取字符串的个数
 * @returns 
 */
interceptStr(str, num) {
    return str.length > num ? `${str.slice(0, num)}...` : str;
}

获取用户当前地址

/**
 * 获取用户当前地址
 * @param {*} callback 回调函数 返回结果 
 */
getAddress(callback) {
    uni.getLocation({
        type: "gcj02", //返回可以用于uni.openLocation的经纬度
        geocode: true,
        success: (res) => {
            callback && callback(res.address);
        }
    })
}

获取缓存中的数据

/**
 * 获取缓存中的数据
 * @param {*} name 
 */
getStore(name) {
    return uni.getStorageSync(name);
}

设置本地缓存

/**
 * 设置本地缓存
 * @param {*} name 键名
 * @param {*} val 键值
 */
setStore(name, val) {
    uni.setStorageSync(name, val);
}

指纹识别

/**
 * 指纹识别
 */
checkIsSupportSoterAuthentication() {
    // #ifdef APP-PLUS || MP-WEIXIN
    uni.checkIsSupportSoterAuthentication({
        success(res) {
            console.log(res);
            // 如果当前设备支持生物识别方式，且支持指纹识别方式
            if (res.supportMode && res.supportMode.includes("fingerPrint")) {
                /**
                 * uni.checkIsSoterEnrolledInDevice : 获取设备内是否录入指纹信息
                 *  checkAuthMode: 'fingerPrint', // 检验指纹信息
                 * */
                uni.checkIsSoterEnrolledInDevice({
                    checkAuthMode: "fingerPrint", // 检验指纹信息
                    success(res) {
                        console.log(res.isEnrolled);
                        if (res.isEnrolled == true) {
                            /**
                             * 开始 SOTER 生物认证
                             * 执行成功，进行后续操作
                             * */
                            uni.startSoterAuthentication({
                                requestAuthModes: ["fingerPrint"],
                                challenge: "123456",
                                // authContent: "请用指纹解锁",
                                success(res) {
                                    console.log(res);
                                    uni.showToast({
                                        title: "识别成功",
                                        duration: 5000,
                                        icon: "none",
                                    });
                                    //指纹识别成功后，进行后续工作
                                },
                                fail(err) {
                                    console.log(err, "66666666666666666");
                                },
                                complete(res) {
                                    console.log(res);
                                },
                            });
                            uni.hideLoading();
                        } else {
                            this.result = "此设备未录入指纹，请到设置中开启";
                        }
                    },
                    fail(err) {
                        uni.showModal({
                            title: "温馨提示",
                            content: "此设备未录入指纹，请到设置中开启",
                            showCancel: false,
                            success: function (res) {
                                // 进行后续逻辑
                            },
                        });
                    },
                });
            } else {
                this.result = "此设备不支持指纹识别功能";
            }
        },
        fail(err) {
            uni.showModal({
                title: "温馨提示",
                content: "此设备不支持指纹识别功能",
                showCancel: false,
                success: function (res) {
                    // 进行后续逻辑
                },
            });
        },
    });
    // #endif
    // #ifndef APP-PLUS || MP-WEIXIN
    this.result = "此平台不支持指纹识别";
    // #endif
}

本地静态资源链接 (仅仅浏览器可用)

/**
 * 本地静态资源链接 (仅仅浏览器可用)
 * @param {*} url 本地资源地址
 * @returns 
 */
getPick(url) {
    return new URL(`../static/${url}`,
        import.meta.url).href;
}

跳转首页

/**
 * 跳转首页
 * @param {*} url 页面路径
 * @param {*} [callback] 跳转完成后的回调函数 
 */
tab(url, callback) {
    uni.switchTab({
        url,
        success: () => callback && callback(),
        fail: (err) => {
            console.log(err);
        }
    });
}

没有记录的跳转 (关闭所有页面)

/**
 * 没有记录的跳转 (关闭所有页面) 没有记录
 * @param {*} url 页面路径
 * @param {*} [callback] 跳转完成后的回调函数 
 */
noJL(url, callback) {
    uni.reLaunch({
        url,
        success: () => callback && callback(),
        fail: (err) => {
            console.log(err);
        }
    })
}

没有记录的跳转 (关闭当前页面)

/**
 * 没有记录的跳转 (关闭当前页面) 没有记录
 * @param {*} url 页面路径
 * @param {*} [callback] 跳转完成后的回调函数 
 */
toOne(url, callback) {
    uni.redirectTo({
        url,
        success: () => callback && callback(),
        fail: (err) => {
            console.log(err);
        }
    })
}

跳转到某一个页面 （非tabbar页面）

/**
 * 跳转到某一个页面 （非tabbar页面）
 * @param {*} url 页面路径
 * @param {*} [callback] 跳转完成后的回调函数 
 */
to(url, callback) {
    uni.navigateTo({
        url,
        success: () => callback && callback()
    })
    // this.shock()
}

返回上个页面，后退

/**
 * 返回上个页面，后退
 * @param {*} [num] <string/number> （后退的步数） 
 */
last(num = 1, callback) {
    uni.navigateBack({ delta: num });
    this.delay(() => callback && callback(), 100);
}

提示信息

/**
 * 提示信息
 * @param {*} title 提示的内容
 * @param {*} icon  警示图标
 * @param {*} [callback] 跳转完成后的回调函数 
 */
msgInfo(title, icon = "none", duration = 2500) {
    uni.showToast({
        title,
        icon: "none",
        duration
    });
}

隐藏提示信息

/** 隐藏提示信息 **/
hide() {
    uni.hideToast();
}

手机震动

/**
 * 手机震动
 * @param {*} [callback] 震动完成后的回调函数
 */
shock(callback) {
    uni.vibrateShort({ success: () => callback && callback() });
}

双击事件封装

/**
 * 双击事件封装
 * @param hander 回调函数 {
 * click：单机时执行
 * doubleClick：双击时执行
 * }
 * @param time 执行时间，默认300毫秒后执行
 * @returns null
 */
double(hander: { click: Function, doubleClick: Function}, time = 300) {
  // 清除定时器
  clearTimeout(doubleTapTime);
  // 判断该属性是否存在 ,如果_this.sum不存在，者指定默认值
  let doubleSumTap = uni.getStorageSync("doubleSumTap") as any;
  doubleSumTap = doubleSumTap == "undefined" ? 0 : doubleSumTap;
  // 当前索引增加
  doubleSumTap++;
  // 修改缓存的数据
  uni.setStorageSync("doubleSumTap", doubleSumTap);
  // 判断是否到达预设的时间
  doubleTapTime = setTimeout(() => {
    // 单击
    if(doubleSumTap == 1) hander.click();
    // 双击执行完成
    if (doubleSumTap == 2) hander.doubleClick();
    // 清除缓存
    uni.removeStorageSync("doubleSumTap");
    // 默认值
    doubleSumTap = 0;
  }, time);
}