uni-app在安卓设备上获取 (WIFI 【和】以太网) ip 和 MAC

 示例标题：题主以下用于 Android 版本 7.1.2

一、获取（ WIFI 【和】 以太网 ） IP

<template>
	<view class="UserQuerise">

	</view>
</template>

<script>
	export default {

		data() {
			return {
				wifiIp: '', // (WIFI)--IP
				ethernetIp: '', // (以太网)--IP
			}
		},
		onload() {
			// Ip地址 （WIFI和 以太网）
			this.getDeviceIpAddresses()
		},
		methods: {
			// 获取设备Ip地址  （WIFI 和 以太网）
			getDeviceIpAddresses() {
				if (typeof plus === 'undefined' || plus.os.name !== 'Android') {
					console.log('非安卓环境，无法获取IP');
					return;
				}

				try {
					// 导入安卓原生类
					const Context = plus.android.importClass('android.content.Context');
					const ConnectivityManager = plus.android.importClass('android.net.ConnectivityManager');
					const WifiManager = plus.android.importClass('android.net.wifi.WifiManager');
					const NetworkInterface = plus.android.importClass('java.net.NetworkInterface');
					const InetAddress = plus.android.importClass('java.net.InetAddress');

					// 获取系统服务
					const mainActivity = plus.android.runtimeMainActivity();
					const connectivityManager = mainActivity.getSystemService(Context.CONNECTIVITY_SERVICE);

					// 1. WiFi IP获取逻辑
					const wifiManager = mainActivity.getSystemService(Context.WIFI_SERVICE);
					const wifiInfo = plus.android.invoke(wifiManager, "getConnectionInfo");
					if (wifiInfo) {
						const wifiIpInt = plus.android.invoke(wifiInfo, "getIpAddress");
						if (wifiIpInt !== 0) {
							this.wifiIp = this.intToIp(wifiIpInt);
						}
					} else {
						console.log('未获取到WiFi连接信息');
					}

					// 2. 有线（以太网）IP获取逻辑（适配Android 7.1.2）
					try {
						// 获取所有网络接口
						const interfaces = NetworkInterface.getNetworkInterfaces();

						// 使用plus.android.invoke调用Java方法
						while (plus.android.invoke(interfaces, "hasMoreElements")) {
							const intf = plus.android.invoke(interfaces, "nextElement");
							// 跳过回环接口
							if (plus.android.invoke(intf, "isLoopback")) continue;
							const interfaceName = plus.android.invoke(intf, "getName");
							// console.log("检查接口:", interfaceName);
							if (interfaceName.startsWith("eth") || interfaceName.startsWith("usb")) {
								const addresses = plus.android.invoke(intf, "getInetAddresses");
								while (plus.android.invoke(addresses, "hasMoreElements")) {
									const addr = plus.android.invoke(addresses, "nextElement");
									if (!plus.android.invoke(addr, "isLoopbackAddress")) {
										const hostAddress = plus.android.invoke(addr, "getHostAddress");
										if (hostAddress.indexOf(':') === -1) {
											this.ethernetIp = hostAddress;
											// console.log("找到以太网IP:", this.ethernetIp);
											break;
										}
									}
								}
							}
						}
					} catch (e) {
						console.error("获取网络接口时出错:", e);
					}

					console.log('WiFi IP:', this.wifiIp);
					console.log('有线（以太网）IP:', this.ethernetIp);
				} catch (e) {
					console.error('获取IP失败:', e);
				}
			},
			//辅助方法 ： 将整数Ip转换为字符串
			intToIp(ipInt) {
				return (
					(ipInt & 0xFF) +
					'.' +
					((ipInt >> 8) & 0xFF) +
					'.' +
					((ipInt >> 16) & 0xFF) +
					'.' +
					((ipInt >> 24) & 0xFF)
				);
			},
		}
	}
</script>

<style>

</style>

二、获取（ WIFI 【和】 以太网 ） MAC

<template>
	<view class="UserQuerise">

	</view>
</template>

<script>
	export default {

		data() {
			return {
				wifiMac: '', // (WIFI)--MAC
				ethernetMac: '' // (以太网)--MAC
			}
		},
		onload() {
			// MAC地址 （WIFI和 以太网）
			this.getDeviceMacAddresses()
		},
		methods: {
			// 获取设备MAC地址  （WIFI 和 以太网）
			getDeviceMacAddresses() {
				if (typeof plus === 'undefined' || plus.os.name !== 'Android') {
					console.log('非安卓环境，无法获取MAC地址');
					return;
				}

				try {
					// 重置结果
					this.wifiMac = '';
					this.ethernetMac = '';

					// 导入必要的Android类
					const NetworkInterface = plus.android.importClass('java.net.NetworkInterface');
					const File = plus.android.importClass('java.io.File');
					const FileReader = plus.android.importClass('java.io.FileReader');
					const BufferedReader = plus.android.importClass('java.io.BufferedReader');

					// --------------------------
					// 方法1：通过NetworkInterface遍历所有接口（优先使用）
					// --------------------------
					// console.log('尝试通过NetworkInterface获取MAC地址...');
					try {
						const interfaces = plus.android.invoke(NetworkInterface, "getNetworkInterfaces");
						while (interfaces && plus.android.invoke(interfaces, "hasMoreElements")) {
							const intf = plus.android.invoke(interfaces, "nextElement");
							const interfaceName = plus.android.invoke(intf, "getName");
							const isUp = plus.android.invoke(intf, "isUp");
							const isLoopback = plus.android.invoke(intf, "isLoopback");

							console.log(`检查接口: ${interfaceName}, isUp=${isUp}, isLoopback=${isLoopback}`);

							// 跳过回环接口和未激活的接口
							if (isLoopback || !isUp) continue;

							// 尝试获取MAC字节
							const macBytes = plus.android.invoke(intf, "getHardwareAddress");

							// 检查MAC是否有效（非空且长度为6字节）
							if (macBytes && macBytes.length === 6) {
								const macAddress = this.bytesToMac(macBytes);
								console.log(`接口${interfaceName}的MAC: ${macAddress}`);

								// 区分WiFi和以太网接口
								if (interfaceName.startsWith("wlan")) {
									this.wifiMac = macAddress;
									console.log('找到WiFi MAC:', this.wifiMac);
								} else if (interfaceName.startsWith("eth") || interfaceName.startsWith("usb")) {
									this.ethernetMac = macAddress;
									console.log('找到以太网MAC:', this.ethernetMac);
								}
							}
						}
					} catch (e) {
						console.error('通过NetworkInterface获取MAC失败:', e);
					}

					// --------------------------
					// 方法2：通过系统文件获取MAC（备用方案）
					// --------------------------
					if (!this.wifiMac || !this.ethernetMac) {
						// console.log('尝试通过系统文件获取MAC地址...');
						try {
							const netDir = new File("/sys/class/net/");
							const interfaces = netDir.list();

							if (interfaces) {
								for (let i = 0; i < interfaces.length; i++) {
									const interfaceName = interfaces[i];
									const addressFile = new File(netDir, `${interfaceName}/address`);

									if (addressFile.exists()) {
										try {
											const reader = new BufferedReader(new FileReader(addressFile));
											const macAddress = reader.readLine().trim();
											reader.close();

											// 验证MAC格式（正则表达式）
											if (/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/.test(macAddress)) {
												// console.log(`系统文件中找到${interfaceName}的MAC: ${macAddress}`);

												if (interfaceName.startsWith("wlan")) {
													this.wifiMac = macAddress;
												} else if (interfaceName.startsWith("eth") || interfaceName.startsWith(
														"usb")) {
													this.ethernetMac = macAddress;
												}
											}
										} catch (e) {
											console.error(`读取${interfaceName}的MAC文件失败:`, e);
										}
									}
								}
							}
						} catch (e) {
							console.error('通过系统文件获取MAC失败:', e);
						}
					}

					// --------------------------
					// 输出最终结果
					// --------------------------
					console.log('WiFi MAC:', this.wifiMac || '未获取到');
					console.log('以太网MAC:', this.ethernetMac || '未获取到');

					// 如果仍未获取到，尝试使用备用接口名称
					if (!this.ethernetMac) {
						console.log('尝试备用接口名称...');
						// 这里可以添加针对特定设备的接口名称匹配逻辑
					}

				} catch (e) {
					console.error('获取MAC地址失败:', e);
				}
			},
			// 辅助方法：将字节数组转换为MAC地址格式
			bytesToMac(bytes) {
				try {
					// 确保是有效的字节数组
					if (!bytes || bytes.length !== 6) return null;

					// 转换为十六进制字符串
					const hex = [];
					for (let i = 0; i < bytes.length; i++) {
						// 处理Java字节的有符号问题
						const byte = bytes[i] & 0xff;
						hex.push(byte.toString(16).padStart(2, '0').toUpperCase());
					}
					return hex.join(':');
				} catch (e) {
					console.error('字节转MAC失败:', e);
					return null;
				}
			},

		}
	}
</script>

<style>

</style>