正在查看： i.BarIS v2024.401.30.180 应用的 WifiWizard2.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
i.BarIS v2024.401.30.180 - WifiWizard2.java 源代码
package wifiwizard2;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.wifi.ScanResult;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.os.Build;
import android.util.Log;
import java.net.HttpURLConnection;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.Iterator;
import java.util.List;
import org.apache.cordova.CallbackContext;
import org.apache.cordova.CordovaInterface;
import org.apache.cordova.CordovaPlugin;
import org.apache.cordova.CordovaWebView;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
public class WifiWizard2 extends CordovaPlugin {
private static final String ACCESS_FINE_LOCATION = "android.permission.ACCESS_FINE_LOCATION";
private static final String ADD_NETWORK = "add";
private static final String CAN_CONNECT_TO_INTERNET = "canConnectToInternet";
private static final String CAN_CONNECT_TO_ROUTER = "canConnectToRouter";
private static final String CAN_PING_WIFI_ROUTER = "canPingWifiRouter";
private static final String CONNECT_NETWORK = "connect";
private static final String DISABLE_NETWORK = "disable";
private static final String DISCONNECT = "disconnect";
private static final String DISCONNECT_NETWORK = "disconnectNetwork";
private static final String ENABLE_NETWORK = "enable";
private static final String GET_CONNECTED_BSSID = "getConnectedBSSID";
private static final String GET_CONNECTED_NETWORKID = "getConnectedNetworkID";
private static final String GET_CONNECTED_SSID = "getConnectedSSID";
private static final String GET_SCAN_RESULTS = "getScanResults";
private static final String GET_SSID_NET_ID = "getSSIDNetworkID";
private static final String GET_WIFI_IP_ADDRESS = "getWifiIP";
private static final String GET_WIFI_IP_INFO = "getWifiIPInfo";
private static final String GET_WIFI_ROUTER_IP_ADDRESS = "getWifiRouterIP";
private static final String IS_CONNECTED_TO_INTERNET = "isConnectedToInternet";
private static final String IS_WIFI_ENABLED = "isWifiEnabled";
private static final String LIST_NETWORKS = "listNetworks";
private static final int LOCATION_REQUEST_CODE = 2;
private static final IntentFilter NETWORK_STATE_CHANGED_FILTER;
private static final String REASSOCIATE = "reassociate";
private static final String RECONNECT = "reconnect";
private static final String REMOVE_NETWORK = "remove";
private static final String REQUEST_FINE_LOCATION = "requestFineLocation";
private static final String SCAN = "scan";
private static final int SCAN_CODE = 1;
private static final int SCAN_RESULTS_CODE = 0;
private static final String SET_WIFI_ENABLED = "setWifiEnabled";
private static final String START_SCAN = "startScan";
private static final String TAG = "WifiWizard2";
private static final int WIFI_SERVICE_INFO_CODE = 3;
private CallbackContext callbackContext;
private ConnectivityManager connectivityManager;
private AP desired;
private ConnectivityManager.NetworkCallback networkCallback;
private final BroadcastReceiver networkChangedReceiver = new NetworkChangedReceiver();
private JSONArray passedData;
private AP previous;
private WifiManager wifiManager;
private static final int API_VERSION = Build.VERSION.SDK_INT;
private static int LAST_NET_ID = -1;
private static boolean bssidRequested = false;
static {
IntentFilter intentFilter = new IntentFilter();
NETWORK_STATE_CHANGED_FILTER = intentFilter;
intentFilter.addAction("android.net.wifi.STATE_CHANGE");
}
private static boolean getHexKey(String str) {
if (str == null) {
return false;
}
int length = str.length();
if (length != 10 && length != 26 && length != 58) {
return false;
}
for (int i = 0; i < length; i++) {
char charAt = str.charAt(i);
if ((charAt < '0' || charAt > '9') && ((charAt < 'a' || charAt > 'f') && (charAt < 'A' || charAt > 'F'))) {
return false;
}
}
return true;
}
@Override
public void initialize(CordovaInterface cordovaInterface, CordovaWebView cordovaWebView) {
super.initialize(cordovaInterface, cordovaWebView);
this.wifiManager = (WifiManager) cordovaInterface.getActivity().getApplicationContext().getSystemService("wifi");
this.connectivityManager = (ConnectivityManager) cordovaInterface.getActivity().getApplicationContext().getSystemService("connectivity");
}
@Override
public boolean execute(String str, JSONArray jSONArray, CallbackContext callbackContext) throws JSONException {
this.callbackContext = callbackContext;
this.passedData = jSONArray;
if (str.equals(IS_WIFI_ENABLED)) {
isWifiEnabled(callbackContext);
return true;
}
if (str.equals(SET_WIFI_ENABLED)) {
setWifiEnabled(callbackContext, jSONArray);
return true;
}
if (str.equals(REQUEST_FINE_LOCATION)) {
requestLocationPermission(2);
return true;
}
if (str.equals(GET_WIFI_ROUTER_IP_ADDRESS)) {
String wiFiRouterIP = getWiFiRouterIP();
if (wiFiRouterIP == null || wiFiRouterIP.equals("0.0.0.0")) {
callbackContext.error("NO_VALID_ROUTER_IP_FOUND");
return true;
}
callbackContext.success(wiFiRouterIP);
return true;
}
if (str.equals(GET_WIFI_IP_ADDRESS) || str.equals(GET_WIFI_IP_INFO)) {
String[] wiFiIPAddress = getWiFiIPAddress();
String str2 = wiFiIPAddress[0];
String str3 = wiFiIPAddress[1];
if (str2 == null || str2.equals("0.0.0.0")) {
callbackContext.error("NO_VALID_IP_IDENTIFIED");
return true;
}
if (str.equals(GET_WIFI_IP_ADDRESS)) {
callbackContext.success(str2);
return true;
}
JSONObject jSONObject = new JSONObject();
jSONObject.put("ip", str2);
jSONObject.put("subnet", str3);
callbackContext.success(jSONObject);
return true;
}
if (!verifyWifiEnabled()) {
callbackContext.error("WIFI_NOT_ENABLED");
return true;
}
if (str.equals(ADD_NETWORK)) {
add(callbackContext, jSONArray);
} else if (str.equals(IS_CONNECTED_TO_INTERNET)) {
canConnectToInternet(callbackContext, true);
} else if (str.equals(CAN_CONNECT_TO_INTERNET)) {
canConnectToInternet(callbackContext, false);
} else if (str.equals(CAN_PING_WIFI_ROUTER)) {
canConnectToRouter(callbackContext, true);
} else if (str.equals(CAN_CONNECT_TO_ROUTER)) {
canConnectToRouter(callbackContext, false);
} else if (str.equals(ENABLE_NETWORK)) {
enable(callbackContext, jSONArray);
} else if (str.equals(DISABLE_NETWORK)) {
disable(callbackContext, jSONArray);
} else if (str.equals(GET_SSID_NET_ID)) {
getSSIDNetworkID(callbackContext, jSONArray);
} else if (str.equals(REASSOCIATE)) {
reassociate(callbackContext);
} else if (str.equals(RECONNECT)) {
reconnect(callbackContext);
} else if (str.equals(SCAN)) {
scan(callbackContext, jSONArray);
} else if (str.equals(REMOVE_NETWORK)) {
remove(callbackContext, jSONArray);
} else if (str.equals(CONNECT_NETWORK)) {
connect(callbackContext, jSONArray);
} else if (str.equals(DISCONNECT_NETWORK)) {
disconnectNetwork(callbackContext, jSONArray);
} else if (str.equals(LIST_NETWORKS)) {
listNetworks(callbackContext);
} else if (str.equals(START_SCAN)) {
startScan(callbackContext);
} else if (str.equals(GET_SCAN_RESULTS)) {
getScanResults(callbackContext, jSONArray);
} else if (str.equals(DISCONNECT)) {
disconnect(callbackContext);
} else if (str.equals(GET_CONNECTED_SSID)) {
getConnectedSSID(callbackContext);
} else if (str.equals(GET_CONNECTED_BSSID)) {
getConnectedBSSID(callbackContext);
} else if (str.equals(GET_CONNECTED_NETWORKID)) {
getConnectedNetworkID(callbackContext);
} else {
callbackContext.error("Incorrect action parameter: " + str);
return false;
}
return true;
}
private boolean scan(final CallbackContext callbackContext, final JSONArray jSONArray) {
Log.v(TAG, "Entering startScan");
final ScanSyncContext scanSyncContext = new ScanSyncContext();
final BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Log.v(WifiWizard2.TAG, "Entering onReceive");
synchronized (scanSyncContext) {
if (scanSyncContext.finished) {
Log.v(WifiWizard2.TAG, "In onReceive, already finished");
return;
}
scanSyncContext.finished = true;
context.unregisterReceiver(this);
Log.v(WifiWizard2.TAG, "In onReceive, success");
WifiWizard2.this.getScanResults(callbackContext, jSONArray);
}
}
};
final Context applicationContext = this.cordova.getActivity().getApplicationContext();
Log.v(TAG, "Submitting timeout to threadpool");
this.cordova.getThreadPool().submit(new Runnable() {
@Override
public void run() {
Log.v(WifiWizard2.TAG, "Entering timeout");
try {
Thread.sleep(10000L);
} catch (InterruptedException e) {
Log.e(WifiWizard2.TAG, "Received InterruptedException e, " + e);
}
Log.v(WifiWizard2.TAG, "Thread sleep done");
synchronized (scanSyncContext) {
if (scanSyncContext.finished) {
Log.v(WifiWizard2.TAG, "In timeout, already finished");
return;
}
scanSyncContext.finished = true;
applicationContext.unregisterReceiver(broadcastReceiver);
Log.v(WifiWizard2.TAG, "In timeout, error");
callbackContext.error("TIMEOUT_WAITING_FOR_SCAN");
}
}
});
Log.v(TAG, "Registering broadcastReceiver");
applicationContext.registerReceiver(broadcastReceiver, new IntentFilter("android.net.wifi.SCAN_RESULTS"));
if (!this.wifiManager.startScan()) {
Log.v(TAG, "Scan failed");
callbackContext.error("SCAN_FAILED");
return false;
}
Log.v(TAG, "Starting wifi scan");
return true;
}
private boolean add(org.apache.cordova.CallbackContext r11, org.json.JSONArray r12) {
throw new UnsupportedOperationException("Method not decompiled: wifiwizard2.WifiWizard2.add(org.apache.cordova.CallbackContext, org.json.JSONArray):boolean");
}
private void enable(CallbackContext callbackContext, JSONArray jSONArray) {
Log.d(TAG, "WifiWizard2: enable entered.");
if (!validateData(jSONArray)) {
callbackContext.error("ENABLE_INVALID_DATA");
Log.d(TAG, "WifiWizard2: enable invalid data.");
return;
}
try {
String string = jSONArray.getString(0);
String string2 = jSONArray.getString(1);
String string3 = jSONArray.getString(2);
int ssidToNetworkId = ssidToNetworkId(string);
try {
if (ssidToNetworkId > -1) {
Log.d(TAG, "Valid networkIdToEnable: attempting connection");
if (string2.equals("true")) {
registerBindALL(ssidToNetworkId);
}
if (this.wifiManager.enableNetwork(ssidToNetworkId, true)) {
if (string3.equals("true")) {
callbackContext.success("NETWORK_ENABLED");
return;
} else {
new ConnectAsync().execute(callbackContext, Integer.valueOf(ssidToNetworkId));
return;
}
}
callbackContext.error("ERROR_ENABLING_NETWORK");
return;
}
callbackContext.error("UNABLE_TO_ENABLE");
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
}
} catch (Exception e2) {
callbackContext.error(e2.getMessage());
Log.d(TAG, e2.getMessage());
}
}
private boolean disable(CallbackContext callbackContext, JSONArray jSONArray) {
Log.d(TAG, "WifiWizard2: disable entered.");
if (!validateData(jSONArray)) {
callbackContext.error("DISABLE_INVALID_DATA");
Log.d(TAG, "WifiWizard2: disable invalid data");
return false;
}
try {
String string = jSONArray.getString(0);
int ssidToNetworkId = ssidToNetworkId(string);
try {
if (ssidToNetworkId > 0) {
if (this.wifiManager.disableNetwork(ssidToNetworkId)) {
maybeResetBindALL();
callbackContext.success("Network " + string + " disabled!");
return true;
}
callbackContext.error("UNABLE_TO_DISABLE");
return true;
}
callbackContext.error("DISABLE_NETWORK_NOT_FOUND");
Log.d(TAG, "WifiWizard2: Network not found to disable.");
return false;
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
return false;
}
} catch (Exception e2) {
callbackContext.error(e2.getMessage());
Log.d(TAG, e2.getMessage());
return false;
}
}
private boolean remove(CallbackContext callbackContext, JSONArray jSONArray) {
Log.d(TAG, "WifiWizard2: remove entered.");
if (!validateData(jSONArray)) {
callbackContext.error("REMOVE_INVALID_DATA");
Log.d(TAG, "WifiWizard2: remove data invalid");
return false;
}
try {
int ssidToNetworkId = ssidToNetworkId(jSONArray.getString(0));
if (ssidToNetworkId > -1) {
if (this.wifiManager.removeNetwork(ssidToNetworkId)) {
if (API_VERSION < 26) {
this.wifiManager.saveConfiguration();
}
callbackContext.success("NETWORK_REMOVED");
return true;
}
callbackContext.error("UNABLE_TO_REMOVE");
return true;
}
callbackContext.error("REMOVE_NETWORK_NOT_FOUND");
Log.d(TAG, "WifiWizard2: Network not found, can't remove.");
return false;
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
return false;
}
}
private void connect(CallbackContext callbackContext, JSONArray jSONArray) {
Log.d(TAG, "WifiWizard2: connect entered.");
if (!validateData(jSONArray)) {
callbackContext.error("CONNECT_INVALID_DATA");
Log.d(TAG, "WifiWizard2: connect invalid data.");
return;
}
try {
String string = jSONArray.getString(0);
String string2 = jSONArray.getString(1);
int ssidToNetworkId = ssidToNetworkId(string);
if (ssidToNetworkId > -1) {
Log.d(TAG, "Valid networkIdToConnect: attempting connection");
if (string2.equals("true")) {
registerBindALL(ssidToNetworkId);
}
if (API_VERSION < 26) {
this.wifiManager.disableNetwork(ssidToNetworkId);
}
this.wifiManager.enableNetwork(ssidToNetworkId, true);
new ConnectAsync().execute(callbackContext, Integer.valueOf(ssidToNetworkId));
return;
}
callbackContext.error("INVALID_NETWORK_ID_TO_CONNECT");
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
}
}
private class ConnectAsync extends AsyncTask<Object, Void, String[]> {
CallbackContext callbackContext;
private ConnectAsync() {
}
@Override
public void onPostExecute(String[] strArr) {
String str = strArr[0];
String str2 = strArr[1];
if (str != null) {
this.callbackContext.error(str);
} else {
this.callbackContext.success(str2);
}
}
@Override
public String[] doInBackground(Object... objArr) {
this.callbackContext = (CallbackContext) objArr[0];
int intValue = ((Integer) objArr[1]).intValue();
int i = 0;
while (i < 15) {
WifiInfo connectionInfo = WifiWizard2.this.wifiManager.getConnectionInfo();
NetworkInfo.DetailedState detailedStateOf = WifiInfo.getDetailedStateOf(connectionInfo.getSupplicantState());
if (connectionInfo.getNetworkId() == intValue && (detailedStateOf == NetworkInfo.DetailedState.CONNECTED || (detailedStateOf == NetworkInfo.DetailedState.OBTAINING_IPADDR && connectionInfo.getIpAddress() != 0))) {
return new String[]{null, "NETWORK_CONNECTION_COMPLETED"};
}
StringBuilder sb = new StringBuilder();
sb.append("WifiWizard: Got ");
sb.append(detailedStateOf.name());
sb.append(" on ");
i++;
sb.append(i);
sb.append(" out of ");
sb.append(15);
Log.d(WifiWizard2.TAG, sb.toString());
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
Log.e(WifiWizard2.TAG, e.getMessage());
return new String[]{"INTERRUPT_EXCEPT_WHILE_CONNECTING", null};
}
}
Log.d(WifiWizard2.TAG, "WifiWizard: Network failed to finish connecting within the timeout");
return new String[]{"CONNECT_FAILED_TIMEOUT", null};
}
}
private boolean disconnectNetwork(CallbackContext callbackContext, JSONArray jSONArray) {
Log.d(TAG, "WifiWizard2: disconnectNetwork entered.");
if (!validateData(jSONArray)) {
callbackContext.error("DISCONNECT_NET_INVALID_DATA");
Log.d(TAG, "WifiWizard2: disconnectNetwork invalid data");
return false;
}
try {
String string = jSONArray.getString(0);
int ssidToNetworkId = ssidToNetworkId(string);
if (ssidToNetworkId > 0) {
if (this.wifiManager.disableNetwork(ssidToNetworkId)) {
maybeResetBindALL();
if (this.wifiManager.removeNetwork(ssidToNetworkId)) {
callbackContext.success("Network " + string + " disconnected and removed!");
return true;
}
callbackContext.error("DISCONNECT_NET_REMOVE_ERROR");
Log.d(TAG, "WifiWizard2: Unable to remove network!");
return false;
}
callbackContext.error("DISCONNECT_NET_DISABLE_ERROR");
Log.d(TAG, "WifiWizard2: Unable to disable network!");
return false;
}
callbackContext.error("DISCONNECT_NET_ID_NOT_FOUND");
Log.d(TAG, "WifiWizard2: Network not found to disconnect.");
return false;
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
return false;
}
}
private boolean disconnect(CallbackContext callbackContext) {
Log.d(TAG, "WifiWizard2: disconnect entered.");
if (this.wifiManager.disconnect()) {
maybeResetBindALL();
callbackContext.success("Disconnected from current network");
return true;
}
callbackContext.error("ERROR_DISCONNECT");
return false;
}
private boolean reconnect(CallbackContext callbackContext) {
Log.d(TAG, "WifiWizard2: reconnect entered.");
if (this.wifiManager.reconnect()) {
callbackContext.success("Reconnected network");
return true;
}
callbackContext.error("ERROR_RECONNECT");
return false;
}
private boolean reassociate(CallbackContext callbackContext) {
Log.d(TAG, "WifiWizard2: reassociate entered.");
if (this.wifiManager.reassociate()) {
callbackContext.success("Reassociated network");
return true;
}
callbackContext.error("ERROR_REASSOCIATE");
return false;
}
private boolean listNetworks(CallbackContext callbackContext) {
Log.d(TAG, "WifiWizard2: listNetworks entered.");
List<WifiConfiguration> configuredNetworks = this.wifiManager.getConfiguredNetworks();
JSONArray jSONArray = new JSONArray();
Iterator<WifiConfiguration> it = configuredNetworks.iterator();
while (it.hasNext()) {
jSONArray.put(it.next().SSID);
}
callbackContext.success(jSONArray);
return true;
}
public boolean getScanResults(CallbackContext callbackContext, JSONArray jSONArray) {
int calculateSignalLevel;
if (this.cordova.hasPermission(ACCESS_FINE_LOCATION)) {
List<ScanResult> scanResults = this.wifiManager.getScanResults();
JSONArray jSONArray2 = new JSONArray();
Integer num = null;
if (!validateData(jSONArray)) {
callbackContext.error("GET_SCAN_RESULTS_INVALID_DATA");
Log.d(TAG, "WifiWizard2: getScanResults invalid data");
return false;
}
if (!jSONArray.isNull(0)) {
try {
JSONObject jSONObject = jSONArray.getJSONObject(0);
if (jSONObject.has("numLevels")) {
Integer valueOf = Integer.valueOf(jSONObject.optInt("numLevels"));
if (valueOf.intValue() > 0) {
num = valueOf;
} else if (jSONObject.optBoolean("numLevels", false)) {
num = 5;
}
}
} catch (JSONException e) {
e.printStackTrace();
callbackContext.error(e.toString());
return false;
}
}
for (ScanResult scanResult : scanResults) {
if (num == null) {
calculateSignalLevel = scanResult.level;
} else {
calculateSignalLevel = WifiManager.calculateSignalLevel(scanResult.level, num.intValue());
}
JSONObject jSONObject2 = new JSONObject();
try {
jSONObject2.put("level", calculateSignalLevel);
jSONObject2.put("SSID", scanResult.SSID);
jSONObject2.put("BSSID", scanResult.BSSID);
jSONObject2.put("frequency", scanResult.frequency);
jSONObject2.put("capabilities", scanResult.capabilities);
jSONObject2.put("timestamp", scanResult.timestamp);
if (API_VERSION >= 23) {
jSONObject2.put("channelWidth", scanResult.channelWidth);
jSONObject2.put("centerFreq0", scanResult.centerFreq0);
jSONObject2.put("centerFreq1", scanResult.centerFreq1);
} else {
jSONObject2.put("channelWidth", JSONObject.NULL);
jSONObject2.put("centerFreq0", JSONObject.NULL);
jSONObject2.put("centerFreq1", JSONObject.NULL);
}
jSONArray2.put(jSONObject2);
} catch (JSONException e2) {
e2.printStackTrace();
callbackContext.error(e2.toString());
return false;
}
}
callbackContext.success(jSONArray2);
return true;
}
requestLocationPermission(0);
return true;
}
private boolean startScan(CallbackContext callbackContext) {
if (this.wifiManager.startScan()) {
callbackContext.success();
return true;
}
callbackContext.error("STARTSCAN_FAILED");
return false;
}
private int getConnectedNetId() {
WifiInfo connectionInfo = this.wifiManager.getConnectionInfo();
if (connectionInfo == null) {
Log.d(TAG, "Unable to read wifi info");
return -1;
}
int networkId = connectionInfo.getNetworkId();
if (networkId == -1) {
Log.d(TAG, "NO_CURRENT_NETWORK_FOUND");
}
return networkId;
}
private boolean getSSIDNetworkID(CallbackContext callbackContext, JSONArray jSONArray) {
Log.d(TAG, "WifiWizard2: getSSIDNetworkID entered.");
if (!validateData(jSONArray)) {
callbackContext.error("GET_SSID_INVALID_DATA");
Log.d(TAG, "WifiWizard2: getSSIDNetworkID invalid data.");
return false;
}
try {
callbackContext.success(ssidToNetworkId(jSONArray.getString(0)));
return true;
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
return false;
}
}
private boolean getConnectedNetworkID(CallbackContext callbackContext) {
int connectedNetId = getConnectedNetId();
if (connectedNetId == -1) {
callbackContext.error("GET_CONNECTED_NET_ID_ERROR");
return false;
}
callbackContext.success(connectedNetId);
return true;
}
private boolean getConnectedSSID(CallbackContext callbackContext) {
return getWifiServiceInfo(callbackContext, false);
}
private boolean getConnectedBSSID(CallbackContext callbackContext) {
return getWifiServiceInfo(callbackContext, true);
}
private boolean getWifiServiceInfo(CallbackContext callbackContext, boolean z) {
String ssid;
if (API_VERSION >= 23 && !this.cordova.hasPermission(ACCESS_FINE_LOCATION)) {
requestLocationPermission(3);
bssidRequested = z;
return true;
}
WifiInfo connectionInfo = this.wifiManager.getConnectionInfo();
if (connectionInfo == null) {
callbackContext.error("UNABLE_TO_READ_WIFI_INFO");
return false;
}
if (!connectionInfo.getSupplicantState().equals(SupplicantState.COMPLETED)) {
callbackContext.error("CONNECTION_NOT_COMPLETED");
return false;
}
if (z) {
ssid = connectionInfo.getBSSID();
} else {
ssid = connectionInfo.getSSID();
}
if (ssid == null || ssid.isEmpty() || ssid == "0x") {
callbackContext.error("WIFI_INFORMATION_EMPTY");
return false;
}
if (ssid.startsWith("\"") && ssid.endsWith("\"")) {
ssid = ssid.substring(1, ssid.length() - 1);
}
callbackContext.success(ssid);
return true;
}
private boolean isWifiEnabled(CallbackContext callbackContext) {
boolean isWifiEnabled = this.wifiManager.isWifiEnabled();
callbackContext.success(isWifiEnabled ? "1" : "0");
return isWifiEnabled;
}
private int ssidToNetworkId(String str) {
try {
int parseInt = Integer.parseInt(str);
Log.d(TAG, "ssidToNetworkId passed SSID is integer, probably a Network ID: " + str);
return parseInt;
} catch (NumberFormatException unused) {
int i = -1;
for (WifiConfiguration wifiConfiguration : this.wifiManager.getConfiguredNetworks()) {
if (wifiConfiguration.SSID != null && wifiConfiguration.SSID.equals(str)) {
i = wifiConfiguration.networkId;
}
}
return i;
}
}
private boolean setWifiEnabled(CallbackContext callbackContext, JSONArray jSONArray) {
if (!validateData(jSONArray)) {
callbackContext.error("SETWIFIENABLED_INVALID_DATA");
Log.d(TAG, "WifiWizard2: setWifiEnabled invalid data");
return false;
}
try {
if (this.wifiManager.setWifiEnabled(jSONArray.getString(0).equals("true"))) {
callbackContext.success();
return true;
}
callbackContext.error("ERROR_SETWIFIENABLED");
return false;
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
return false;
}
}
private boolean verifyWifiEnabled() {
Log.d(TAG, "WifiWizard2: verifyWifiEnabled entered.");
if (this.wifiManager.isWifiEnabled()) {
return true;
}
Log.i(TAG, "Enabling wi-fi...");
if (this.wifiManager.setWifiEnabled(true)) {
Log.i(TAG, "Wi-fi enabled");
int i = 0;
while (!this.wifiManager.isWifiEnabled()) {
if (i >= 10) {
Log.i(TAG, "Took too long to enable wi-fi, quitting");
return false;
}
Log.i(TAG, "Still waiting for wi-fi to enable...");
try {
Thread.sleep(1000L);
} catch (InterruptedException unused) {
}
i++;
}
return true;
}
Log.e(TAG, "VERIFY_ERROR_ENABLE_WIFI");
return false;
}
private String[] getWiFiIPAddress() {
String str;
String formatIP = formatIP(this.wifiManager.getConnectionInfo().getIpAddress());
try {
str = getIPv4Subnet(InetAddress.getByName(formatIP));
} catch (Exception unused) {
str = "";
}
return new String[]{formatIP, str};
}
private String getWiFiRouterIP() {
return formatIP(this.wifiManager.getDhcpInfo().gateway);
}
private String formatIP(int i) {
return String.format("%d.%d.%d.%d", Integer.valueOf(i & 255), Integer.valueOf((i >> 8) & 255), Integer.valueOf((i >> 16) & 255), Integer.valueOf((i >> 24) & 255));
}
public static String getIPv4Subnet(InetAddress inetAddress) {
try {
for (InterfaceAddress interfaceAddress : NetworkInterface.getByInetAddress(inetAddress).getInterfaceAddresses()) {
if (!interfaceAddress.getAddress().isLoopbackAddress() && (interfaceAddress.getAddress() instanceof Inet4Address)) {
return getIPv4SubnetFromNetPrefixLength(interfaceAddress.getNetworkPrefixLength()).getHostAddress().toString();
}
}
return "";
} catch (Exception unused) {
return "";
}
}
public static InetAddress getIPv4SubnetFromNetPrefixLength(int i) {
int i2 = Integer.MIN_VALUE;
for (int i3 = i - 1; i3 > 0; i3--) {
i2 >>= 1;
}
try {
return InetAddress.getByName(Integer.toString((i2 >> 24) & 255) + "." + Integer.toString((i2 >> 16) & 255) + "." + Integer.toString((i2 >> 8) & 255) + "." + Integer.toString(i2 & 255));
} catch (Exception unused) {
return null;
}
}
private boolean validateData(JSONArray jSONArray) {
if (jSONArray != null) {
try {
if (jSONArray.get(0) != null) {
return true;
}
} catch (Exception e) {
this.callbackContext.error(e.getMessage());
return false;
}
}
this.callbackContext.error("DATA_IS_NULL");
return false;
}
protected void requestLocationPermission(int i) {
this.cordova.requestPermission(this, i, ACCESS_FINE_LOCATION);
}
@Override
public void onRequestPermissionResult(int i, String[] strArr, int[] iArr) throws JSONException {
for (int i2 : iArr) {
if (i2 == -1) {
this.callbackContext.error("PERMISSION_DENIED");
return;
}
}
if (i == 0) {
getScanResults(this.callbackContext, this.passedData);
return;
}
if (i == 1) {
scan(this.callbackContext, this.passedData);
} else if (i == 2) {
this.callbackContext.success("PERMISSION_GRANTED");
} else {
if (i != 3) {
return;
}
getWifiServiceInfo(this.callbackContext, bssidRequested);
}
}
private static int getMaxWifiPriority(WifiManager wifiManager) {
int i = 0;
for (WifiConfiguration wifiConfiguration : wifiManager.getConfiguredNetworks()) {
if (wifiConfiguration.priority > i) {
i = wifiConfiguration.priority;
}
}
Log.d(TAG, "WifiWizard: Found max WiFi priority of " + i);
return i;
}
private boolean canConnectToInternet(CallbackContext callbackContext, boolean z) {
try {
if (hasInternetConnection(z)) {
callbackContext.success("1");
return true;
}
callbackContext.success("0");
return false;
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
return false;
}
}
private boolean canConnectToRouter(CallbackContext callbackContext, boolean z) {
try {
if (hasConnectionToRouter(z)) {
callbackContext.success("1");
return true;
}
callbackContext.success("0");
return false;
} catch (Exception e) {
callbackContext.error(e.getMessage());
Log.d(TAG, e.getMessage());
return false;
}
}
public boolean hasInternetConnection(boolean z) {
NetworkInfo activeNetworkInfo;
ConnectivityManager connectivityManager = this.connectivityManager;
if (connectivityManager == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || !activeNetworkInfo.isConnected()) {
return false;
}
if (z) {
return pingCmd("8.8.8.8");
}
return isHTTPreachable("http://www.google.com/");
}
public boolean hasConnectionToRouter(boolean z) {
ConnectivityManager connectivityManager;
NetworkInfo activeNetworkInfo;
String wiFiRouterIP = getWiFiRouterIP();
if (wiFiRouterIP == null || wiFiRouterIP.equals("0.0.0.0") || (connectivityManager = this.connectivityManager) == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || !activeNetworkInfo.isConnected()) {
return false;
}
if (z) {
return pingCmd(wiFiRouterIP);
}
return isHTTPreachable("http://" + wiFiRouterIP + "/");
}
public static boolean isHTTPreachable(String str) {
try {
((HttpURLConnection) new URL(str).openConnection()).getContent();
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
public boolean pingCmd(String str) {
try {
Process exec = Runtime.getRuntime().exec("ping -c 1 -W 3 " + str);
try {
exec.waitFor();
} catch (InterruptedException e) {
Log.e(TAG, "InterruptedException error.", e);
}
int exitValue = exec.exitValue();
Log.d(TAG, "pingCmd exitValue" + exitValue);
return exitValue == 0;
} catch (UnknownHostException e2) {
Log.d(TAG, "UnknownHostException: " + e2.getMessage());
return false;
} catch (Exception e3) {
Log.d(TAG, e3.getMessage());
return false;
}
}
private class NetworkChangedReceiver extends BroadcastReceiver {
private NetworkChangedReceiver() {
}
@Override
public void onReceive(Context context, Intent intent) {
if ("android.net.wifi.STATE_CHANGE".equals(intent.getAction())) {
Log.d(WifiWizard2.TAG, "NETWORK_STATE_CHANGED_ACTION");
NetworkInfo networkInfo = (NetworkInfo) intent.getParcelableExtra("networkInfo");
WifiInfo connectionInfo = WifiWizard2.this.wifiManager.getConnectionInfo();
if (!networkInfo.isConnected() || connectionInfo.getNetworkId() <= -1) {
return;
}
Log.d(WifiWizard2.TAG, "Connected to '" + connectionInfo.getSSID().replaceAll("\"", "") + "' @ " + connectionInfo.getBSSID());
if (WifiWizard2.this.desired == null || connectionInfo.getNetworkId() != WifiWizard2.this.desired.apId) {
return;
}
WifiWizard2.this.onSuccessfulConnection();
}
}
}
private void registerBindALL(int i) {
if (API_VERSION > 21) {
Log.d(TAG, "registerBindALL: registering net changed receiver");
this.desired = new AP(i, null, null);
this.cordova.getActivity().getApplicationContext().registerReceiver(this.networkChangedReceiver, NETWORK_STATE_CHANGED_FILTER);
return;
}
Log.d(TAG, "registerBindALL: API older than 21, bindall ignored.");
}
private void maybeResetBindALL() {
ConnectivityManager.NetworkCallback networkCallback;
Log.d(TAG, "maybeResetBindALL");
if (this.desired != null) {
if (API_VERSION > 21) {
try {
this.cordova.getActivity().getApplicationContext().unregisterReceiver(this.networkChangedReceiver);
} catch (Exception unused) {
}
}
int i = API_VERSION;
if (i >= 23) {
this.connectivityManager.bindProcessToNetwork(null);
} else if (i >= 21 && i < 23) {
ConnectivityManager.setProcessDefaultNetwork(null);
}
if (API_VERSION > 21 && (networkCallback = this.networkCallback) != null) {
try {
this.connectivityManager.unregisterNetworkCallback(networkCallback);
} catch (Exception unused2) {
}
}
this.networkCallback = null;
this.previous = null;
this.desired = null;
}
}
private void resetBindAll(CallbackContext callbackContext) {
Log.d(TAG, "WifiWizard2: resetBindALL");
try {
maybeResetBindALL();
callbackContext.success("Successfully reset BindALL");
} catch (Exception e) {
Log.e(TAG, "InterruptedException error.", e);
callbackContext.error("ERROR_NO_BIND_ALL");
}
}
private void setBindAll(CallbackContext callbackContext) {
Log.d(TAG, "WifiWizard2: setBindALL");
try {
registerBindALL(getConnectedNetId());
callbackContext.success("Successfully bindAll to network");
} catch (Exception e) {
Log.e(TAG, "InterruptedException error.", e);
callbackContext.error("ERROR_CANT_BIND_ALL");
}
}
public void onSuccessfulConnection() {
int i = API_VERSION;
if (i >= 23) {
Log.d(TAG, "BindALL onSuccessfulConnection API >= 23");
NetworkRequest build = new NetworkRequest.Builder().addTransportType(1).build();
ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
@Override
public void onAvailable(Network network) {
if (WifiWizard2.this.connectivityManager.bindProcessToNetwork(network)) {
Log.d(WifiWizard2.TAG, "bindProcessToNetwork TRUE onSuccessfulConnection");
} else {
Log.d(WifiWizard2.TAG, "bindProcessToNetwork FALSE onSuccessfulConnection");
}
}
};
this.networkCallback = networkCallback;
this.connectivityManager.requestNetwork(build, networkCallback);
return;
}
if (i >= 21 && i < 23) {
Log.d(TAG, "BindALL onSuccessfulConnection API >= 21 && < 23");
NetworkRequest build2 = new NetworkRequest.Builder().addTransportType(1).build();
ConnectivityManager.NetworkCallback networkCallback2 = new ConnectivityManager.NetworkCallback() {
@Override
public void onAvailable(Network network) {
ConnectivityManager unused = WifiWizard2.this.connectivityManager;
ConnectivityManager.setProcessDefaultNetwork(network);
}
};
this.networkCallback = networkCallback2;
this.connectivityManager.requestNetwork(build2, networkCallback2);
return;
}
Log.d(TAG, "BindALL onSuccessfulConnection API older than 21, no need to do any binding");
this.networkCallback = null;
this.previous = null;
this.desired = null;
}
private class ScanSyncContext {
public boolean finished;
private ScanSyncContext() {
this.finished = false;
}
}
private static class AP {
final int apId;
final String bssid;
final String ssid;
AP(int i, String str, String str2) {
this.apId = i;
this.ssid = str;
this.bssid = str2;
}
}
}