Skip to content

H
Hello UTS

DCloud / Hello UTS

通知 1598
Star 27
Fork 9
H
Hello UTS
提交 bccd6706 编写于 作者: 杜庆泉's avatar 杜庆泉
浏览文件
操作

移除uni-wifi 转移至 uni-api

上级 9c6360b0
隐藏空白更改
内联 并排
Showing with 2 addition and 828 deletion
pages.json
浏览文件 @ bccd6706
......@@ -123,15 +123,6 @@
"enablePullDownRefresh": false
}
},
{
"path" : "pages/SystemAPI/android/wifi",
"style" :
{
"navigationBarTitleText": "",
"enablePullDownRefresh": false
}
},
{
......
pages/SystemAPI/SystemAPI.vue
浏览文件 @ bccd6706
......@@ -5,7 +5,6 @@
<uni-collapse-item title="设备相关" :border="false">
<uni-list>
<uni-list-item @tap="testGetBatteryCapacity" title="获取电池电量" class="itemButton" :clickable="true"/>
<uni-list-item @tap="testGotoWifi" title="wifi功能示例" class="itemButton" :clickable="true" link/>
</uni-list>
</uni-collapse-item>
</uni-collapse>
......@@ -86,12 +85,8 @@
title:'需要在自定义基座中运行'
})
}
},
testGotoWifi() {
uni.navigateTo({
url:'/pages/SystemAPI/android/wifi'
})
},
}
}
}
</script>
......
pages/SystemAPI/android/wifi.vue 已删除 100644 → 0
浏览文件 @ 9c6360b0
<template>
<view class="content">
<button @tap="testStartWifi" style="width:100%">初始化wifi模块</button>
<button @tap="testGetWifiList" style="width:100%">获取当前wifi列表</button>
<button @tap="testGetConnnectWifi" style="width:100%">获取当前连接的wifi</button>
<button @tap="testStopWifi" style="width:100%">关闭wifi模块</button>
</view>
</template>
<script>
export default {
data() {
return {
}
},
onLoad() {
},
methods: {
testConnnectWifi(){
uni.connectWifi({
maunal:false,
SSID:"Xiaomi_20D0",
password:"BBBB",
complete:(res)=>{
console.log(res);
}
});
},
testGetConnnectWifi(){
uni.getConnectedWifi({
partialInfo:false,
complete:(res)=>{
console.log(res);
uni.showToast({
icon:'none',
title:res.wifi.SSID
})
}
});
},
testStartWifi(){
uni.startWifi({
success:(res)=> {
console.log("success: " + JSON.stringify(res));
// wifi 开启成功后，注册wifi链接状态监听和wifi列表获取监听
uni.onGetWifiList(function(res){
console.log("onGetWifiList");
console.log(res);
});
uni.onWifiConnected(function(res){
console.log("onWifiConnected");
console.log(res);
});
},fail:(res)=>{
console.log("fail: " + JSON.stringify(res));
},complete:(res)=>{
console.log("complete: " + JSON.stringify(res));
}
})
},
testStopWifi() {
uni.stopWifi({
success:(res)=> {
console.log("success: " + JSON.stringify(res));
},fail:(res)=>{
console.log("fail: " + JSON.stringify(res));
},complete:(res)=>{
console.log("complete: " + JSON.stringify(res));
}
})
},
testGetWifiList() {
uni.getWifiList({
success:(res)=> {
console.log("success: " + JSON.stringify(res));
},fail:(res)=>{
console.log("fail: " + JSON.stringify(res));
},complete:(res)=>{
console.log("complete: " + JSON.stringify(res));
}
})
},
}
}
</script>
<style>
.content {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
}
</style>
uni_modules/uni-wifi/package.json 已删除 100644 → 0
浏览文件 @ 9c6360b0
{
"id": "uni-wifi",
"displayName": "uni-wifi",
"version": "1.0.0",
"description": "wifi管理",
"keywords": [
"wifi"
],
"repository": "",
"engines": {
"HBuilderX": "^3.6.8"
},
"dcloudext": {
"type": "uts",
"sale": {
"regular": {
"price": "0.00"
},
"sourcecode": {
"price": "0.00"
}
},
"contact": {
"qq": ""
},
"declaration": {
"ads": "",
"data": "",
"permissions": ""
},
"npmurl": ""
},
"uni_modules": {
"uni-ext-api":{
"uni": {
"getConnectedWifi": "getConnectedWifi",
"startWifi": "startWifi",
"stopWifi": "stopWifi",
"getWifiList":"getWifiList",
"onGetWifiList":"onGetWifiList",
"onWifiConnected":"onWifiConnected",
"connectWifi":"connectWifi"
}
},
"dependencies": [],
"encrypt": [],
"platforms": {
"cloud": {
"tcb": "u",
"aliyun": "u"
},
"client": {
"Vue": {
"vue2": "u",
"vue3": "u"
},
"App": {
"app-android": "u",
"app-ios": "u"
},
"H5-mobile": {
"Safari": "u",
"Android Browser": "u",
"微信浏览器(Android)": "u",
"QQ浏览器(Android)": "u"
},
"H5-pc": {
"Chrome": "u",
"IE": "u",
"Edge": "u",
"Firefox": "u",
"Safari": "u"
},
"小程序": {
"微信": "u",
"阿里": "u",
"百度": "u",
"字节跳动": "u",
"QQ": "u",
"钉钉": "u",
"快手": "u",
"飞书": "u",
"京东": "u"
},
"快应用": {
"华为": "u",
"联盟": "u"
}
}
}
}
}
\ No newline at end of file
uni_modules/uni-wifi/readme.md 已删除 100644 → 0
浏览文件 @ 9c6360b0
# wa-wifi
### 开发文档
[UTS 语法](https://uniapp.dcloud.net.cn/tutorial/syntax-uts.html)
[UTS 原生插件](https://uniapp.dcloud.net.cn/plugin/uts-plugin.html)
[Hello UTS](https://gitcode.net/dcloud/hello-uts/-/tree/dev)
\ No newline at end of file
uni_modules/uni-wifi/utssdk/app-android/config.json 已删除 100644 → 0
浏览文件 @ 9c6360b0
{
"abis": [
"arm64-v8a"
],
"dependencies": [
"com.google.code.gson:gson:2.8.9"
],
"minSdkVersion": 21
}
uni_modules/uni-wifi/utssdk/app-android/index.uts 已删除 100644 → 0
浏览文件 @ 9c6360b0
import Context from "android.content.Context";
import {UTSAndroid } from "io.dcloud.uts";
import WifiManager from "android.net.wifi.WifiManager";
import WifiInfo from "android.net.wifi.WifiInfo";
import Manifest from "android.Manifest";
import PackageManager from "android.content.pm.PackageManager";
import ScanResult from "android.net.wifi.ScanResult";
import BroadcastReceiver from "android.content.BroadcastReceiver";
import ActivityCompat from "androidx.core.app.ActivityCompat";
import IntentFilter from "android.content.IntentFilter";
import Gson from "com.google.gson.Gson";
import JSONObject from "com.alibaba.fastjson.JSONObject";
import Intent from "android.content.Intent";
import Thread from "java.lang.Thread";
import WifiConfiguration from 'android.net.wifi.WifiConfiguration';
import AuthAlgorithm from 'android.net.wifi.WifiConfiguration.AuthAlgorithm';
import KeyMgmt from 'android.net.wifi.WifiConfiguration.KeyMgmt';
import TextUtils from 'android.text.TextUtils';
/**
* Wifi 函数通用入参封装
*/
type WifiOption = {
success?: (res: object) => void;
fail?: (res: object) => void;
complete?: (res: object) => void;
};
/**
* Wifi 链接参数封装
*/
type WifiConnectOption = {
SSID:string;
BSSID:string;
password:string;
maunal:boolean;
partialInfo:boolean;
success?: (res: object) => void;
fail?: (res: object) => void;
complete?: (res: object) => void;
}
function isHex(key:string):boolean {
for (var i = key.length - 1; i >= 0; i--) {
let c = key.charAt(i);
if (!(c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a'
&& c <= 'f')) {
return false;
}
}
return true;
}
/**
* 判断是否是wep格式的key
*/
function isHexWepKey(wepKey:string):boolean {
let len = wepKey.length;
// WEP-40, WEP-104, and some vendors using 256-bit WEP (WEP-232?)
if (len != 10 && len != 26 && len != 58) {
return false;
}
return isHex(wepKey);
}
function wrapWifiConfiguration(SSID:string ,password:string,passwordType:string):WifiConfiguration {
let config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID = "\"" + SSID + "\"";
// nopass
if ("NONE".equals(passwordType)) {
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
}
// // wep
if ("WEP".equals(passwordType)) {
if (!TextUtils.isEmpty(password)) {
if (isHexWepKey(password)) {
config.wepKeys[0] = password;
} else {
config.wepKeys[0] = "\"" + password + "\"";
}
}
config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
config.allowedKeyManagement.set(KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
// wpa
if ("WPA".equals(passwordType)) {
config.preSharedKey = "\"" + password + "\"";
config.hiddenSSID = true;
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.OPEN);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.TKIP);
// 此处需要修改否则不能自动重联
config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
}
return config;
}
/**
* Wifi信息统一数据结构
*/
class UniWifiInfo {
SSID: String = "";
BSSID: String = "";
secure: boolean = false;
signalStrength: Number = 0;
frequency: Number = 0;
/*下面的字段属于扩展字段*/
securityType:string = ""
constructor(scanResult?: ScanResult) {
if (scanResult != null) {
// 如果是通过扫描列表得到的数据，进行封装
this.BSSID = scanResult.BSSID;
this.SSID = scanResult.SSID;
this.signalStrength = scanResult.level;
this.frequency = scanResult.frequency;
// 是否安全，微信的标准是是否需要密码。 来源:https://developers.weixin.qq.com/community/develop/doc/00064cf1790458db19cddf9925ac00?highLine=WifiInfo
this.secure = false;
let capabilities = scanResult.capabilities.trim();
if ((capabilities.equals(Global.WIFI_AUTH_OPEN) || capabilities.equals(Global.WIFI_AUTH_ROAM))) {
this.secure = false;
} else {
this.secure = true;
}
/*扩展字段*/
this.securityType = getSecurityType(scanResult);
}
}
/**
* 根据connectInfo 链接信息对wifi数据结构进行初始化
*/
wrapConnectInfo(connectInfo: WifiInfo): void {
console.log(connectInfo.getSSID());
console.log(connectInfo.getBSSID());
if (connectInfo.getBSSID() == null) {
return
}
if (connectInfo.getSSID() != null) {
let s = connectInfo.getSSID();
// 微信不带，这里需要去掉引号
if (s.length > 2 && s.charAt(0) == '"' && s.charAt(s.length - 1) == '"') {
s = s.substring(1, s.length - 1);
}
this.SSID = s;
}
this.BSSID = connectInfo.getBSSID();
//Android返回的值是-100~0，而微信API规范是0~100，值越大信号越好，需要+100拉齐
this.signalStrength = connectInfo.getRssi() + 100;
this.frequency = connectInfo.getFrequency();
}
}
/**
* 获取当前链接的wifi信息
*/
type GetConnectedWifiOptions = {
partialInfo?: boolean
success?: (res: UTSJSONObject) => void
fail?: (res: UTSJSONObject) => void
complete?: (res: UTSJSONObject) => void
}
/**
* 全局数据储存
*/
class Global {
static mReceiver?: CustomBroadcastReceiver = null;
static scanList: UniWifiInfo[] = []
static WIFI_AUTH_OPEN: String = "";
static WIFI_AUTH_ROAM: String = "[ESS]";
static getWifiListCallbackList: UTSCallback[] = []
static onWifiConnectCallbackList: UTSCallback[] = []
}
function getSecurityType(result:ScanResult):string {
if (result.capabilities.contains("WEP")) {
return "WEP";
} else if (result.capabilities.contains("PSK")) {
return "WPA";
} else if (result.capabilities.contains("EAP")) {
return "EAP";
}
return "NONE";
}
/**
* 自定义wifi变化广播监听器
*/
class CustomBroadcastReceiver extends BroadcastReceiver {
mWifiManager?: WifiManager = null;
constructor(wifiManager: WifiManager) {
super();
this.mWifiManager = wifiManager;
}
override onReceive(_context: Context, intent: Intent): void {
if (intent.action == WifiManager.WIFI_STATE_CHANGED_ACTION) {
let state =
intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_UNKNOWN)
if (state == WifiManager.WIFI_STATE_ENABLED) {
// 获取当前的connectInfo 并且进行数据封装
let uniWifiInfo = new UniWifiInfo(null)
//做一些异步操作
setTimeout(function() {
// BroadcastReceiver 中不能执行耗时任务，需要使用setTimeout
console.log(Thread.currentThread().getName())
// @ts-ignore
let winfo = this.mWifiManager!.getConnectionInfo();
while (winfo.bssid == null) {
Thread.sleep(1000)
winfo = this.mWifiManager!.getConnectionInfo();
}
// 封装成数据对象
uniWifiInfo.wrapConnectInfo(winfo)
let res = {
errMsg: 'onWifiConnected:ok',
errCode: 0,
wifi: uniWifiInfo
}
// wifi状态可用了，分发当前的链接状态给已注册的监听集合
for (let perCallback in Global.onWifiConnectCallbackList) {
perCallback(res);
}
}, 100);
}
}
if (intent.action == WifiManager.SCAN_RESULTS_AVAILABLE_ACTION) {
// wifi 扫描结果回调
let results = this.mWifiManager!.scanResults;
if (results != null) {
Global.scanList = []
for (let scanResult in results) {
if (scanResult.SSID == null) {
continue;
}
Global.scanList.push(new UniWifiInfo(scanResult));
}
// 挨个通知，所有的监听器
for (let perCallback in Global.getWifiListCallbackList) {
const data = new JSONObject();
let mainJsonStr = Gson().toJson(Global.scanList);
data["wifiList"] = mainJsonStr
perCallback(data);
}
}
}
}
}
/************************* 下面是对外提供的函数 *************************/
/**
* 获取wifi列表
*/
export function getWifiList(option: WifiOption) {
if (Global.mReceiver == null) {
// 还没调用startWifi 提示报错
var result = {
errCode: 12000,
errMsg: "getWifiList:fail:not invoke startWifi",
errSubject:"uni-getWifiList"
}
option.fail?.(result)
option.complete?.(result)
return
}
let wifiManager: WifiManager =
UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
wifiManager.startScan()
let ret = {
errCode: 0,
errMsg: "getWifiList:ok"
}
option.success?.(ret)
option.complete?.(ret)
}
/**
* wifi 链接成功的回调注册
*/
export function onWifiConnected(callback: UTSCallback) {
Global.onWifiConnectCallbackList.push(callback)
}
/**
* wifi 链接成功的回调取消注册
*/
export function offWifiConnected(callback: UTSCallback) {
let callbackIndex = Global.onWifiConnectCallbackList.indexOf(callback)
if (callbackIndex > 0) {
Global.onWifiConnectCallbackList.splice(callbackIndex, 1);
}
}
/**
* 注册Wifi列表的监听事件
*/
export function onGetWifiList(callback: UTSCallback) {
Global.getWifiListCallbackList.push(callback)
}
/**
* 取消注册Wifi列表的监听事件
*/
export function offGetWifiList(callback: UTSCallback) {
let callbackIndex = Global.getWifiListCallbackList.indexOf(callback)
if (callbackIndex > 0) {
Global.getWifiListCallbackList.splice(callbackIndex, 1);
}
}
/**
* 链接指定wifi
*/
export function connectWifi(option: WifiConnectOption) {
var result = {
errCode: 12000,
errMsg: "connectWifi:fail:not invoke startWifi",
errSubject:"uni-connectWifi"
}
if (Global.mReceiver == null || Global.scanList.length < 1) {
// 还没调用startWifi 提示报错
option.fail?.(result)
option.complete?.(result)
return
}
if(option.maunal == true){
// 指定了手动模式
let manunalIntent = new Intent(android.provider.Settings.ACTION_WIFI_SETTINGS);
UTSAndroid.getUniActivity()!!.startActivity(manunalIntent);
result.errCode = 0
result.errMsg = "connectWifi:ok"
option.success?.(result)
option.complete?.(result)
return
}
// 执行后续的逻辑
let scanWifiInfo:UniWifiInfo|null = null
for (let scanResult in Global.scanList) {
if (scanResult.SSID.equals(option.SSID)) {
scanWifiInfo = scanResult
}
}
if(scanWifiInfo == null){
// 不在扫描列表中返回错误
option.fail?.(result)
option.complete?.(result)
return
}
console.log(JSON.stringify(scanWifiInfo.securityType));
let wifiConfigration = wrapWifiConfiguration(option.SSID,option.password,scanWifiInfo.securityType);
let wifiManager: WifiManager =
UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
// 如果已经存在了指定wifi 配置，移除之
let targetExistConfig:WifiConfiguration|null = null
let existingConfigs = wifiManager.getConfiguredNetworks();
for (let existingConfig in existingConfigs) {
if (existingConfig.SSID.equals("\"" + option.SSID + "\"")) {
targetExistConfig = existingConfig
}
}
if (targetExistConfig != null) {
wifiManager.removeNetwork(targetExistConfig.networkId);
}
try {
let netID = wifiManager.addNetwork(wifiConfigration);
let enabled = wifiManager.enableNetwork(netID, true);
let connected = wifiManager.reconnect();
console.log(connected);
} catch (e) {
// TODO: handle exception
console.log(e);
// e.printStackTrace();
}
result.errCode = 0
result.errMsg = "connectWifi:ok"
option.success?.(result)
option.complete?.(result)
}
/**
* 开启wifi
*/
export function startWifi(option: WifiOption) {
// 需要先开启wifi,才能使用后续的功能
let requestCode = 1001;
let permissionWifi = arrayOf("android.permission.ACCESS_FINE_LOCATION");
var result = {
errCode: 12001,
errMsg: "startWifi:premission loss",
errSubject:"uni-startWifi",
}
// 检查权限
if (ActivityCompat.checkSelfPermission(UTSAndroid.getUniActivity()!, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(UTSAndroid.getUniActivity()!, permissionWifi, requestCode)
// 尚不具备权限，返回错误
option.fail?.(result)
option.complete?.(result)
return;
}
// 具备了权限，继续前进
let wifiManager: WifiManager =
UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
if (Global.mReceiver == null) {
Global.mReceiver = new CustomBroadcastReceiver(wifiManager)
}
let filter = new IntentFilter()
filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)
// @ts-ignore
filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION)
// @ts-ignore
filter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
UTSAndroid.getUniActivity()!.registerReceiver(Global.mReceiver, filter)
wifiManager.startScan()
result.errCode = 0
result.errMsg = "startWifi:ok"
option.success?.(result)
option.complete?.(result)
}
/**
* 关闭wifi
*/
export function stopWifi(option: WifiOption) {
// 需要先开启wifi,才能使用后续的功能
if (Global.mReceiver == null) {
var result = {
errNo: 12000,
errCode: 12000,
errSubject:"uni-stopWifi",
errMsg: "stopWifi:not init"
}
option.fail?.(result)
option.complete?.(result)
return
}
try{
UTSAndroid.getUniActivity()!.unregisterReceiver(Global.mReceiver)
}catch(e){
// 可能存在重复
//console.log(e);
}
var result = {
errNo: 0,
errCode: 0,
errMsg: "stopWifi:ok"
}
option.success?.(result)
option.complete?.(result)
}
/**
* 获取当前连接中的wifi信息
*/
export function getConnectedWifi(option: GetConnectedWifiOptions) {
let wifiInfo = new UniWifiInfo(null)
var res = {
errCode: 12000,
errMsg: "getConnectedWifi:fail:not invoke startWifi",
errSubject:"uni-getConnectedWifi",
wifi:wifiInfo
}
if (Global.mReceiver == null) {
// 还没调用startWifi 提示报错
option.fail?.(res)
option.complete?.(res)
return
}
if (ActivityCompat.checkSelfPermission(UTSAndroid.getUniActivity()!, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
// 尚不具备权限，返回错误
res.errCode = 12001
res.errMsg = "getConnectedWifi:permission loss"
option.fail?.(res)
option.complete?.(res)
return;
}
// TODO 应该try catch一下，把系统的错误码给返回来，然后和微信的错误码拉齐
// 需要先校验权限，没有位置权限无法获取wifi
const context = UTSAndroid.getAppContext();
if (context != null) {
const wm = context.getSystemService(
Context.WIFI_SERVICE
) as WifiManager;
// 测试android 12上可以使用
//@ts-ignore
const winfo = wm.getConnectionInfo();
// 封装成数据对象
wifiInfo.wrapConnectInfo(winfo);
res.errCode = 0
res.errMsg = "getConnectedWifi:ok"
res.wifi = wifiInfo;
option.success?.(res)
option.complete?.(res)
return
}
option.fail?.(res)
option.complete?.(res)
}
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或