Android Wifi IP 设置

最新推荐文章于 2024-06-29 13:37:05 发布
最新推荐文章于 2024-06-29 13:37:05 发布
阅读量1w 收藏 12
点赞数
文章标签： android string exception null object dialog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AresCJ/article/details/7981370
版权 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.IntentFilter;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager.Channel;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.ListView;
import android.widget.Toast;

public class WifiActivity extends Activity implements OnClickListener{
	protected static final String TAG = "WifiActivity";
	
	public final static String KEY_WIFI_PRIORITY = "wifi_priority";
	public final static String KEY_WIFI_STATIC_IP = "wifi_static_ip";
	
	WifiP2pManager mManager;
	Channel mChannel;
	BroadcastReceiver mReceiver;
	IntentFilter mIntentFilter;
	private WifiManager mWifiManager;
	private List<ScanResult> mListResult;
	private WifiAdapter mWifiAdapter;
	private ListView mList;
	
	/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
    	super.onCreate(savedInstanceState);
        setContentView(R.layout.wifi_list);
        ImageButton btn = (ImageButton)findViewById(R.id.back);
        btn.setOnClickListener(this);
        mList = (ListView)findViewById(R.id.list_view);
        mReceiver = new WifiReceiver(new WifiScanListener() {
			
			@Override
			public void suppStateChange() {
				
			}
			
			@Override
			public void stateChange() {
				
			}
			
			@Override
			public void endScan() {
				endScanWifi(mWifiManager.getScanResults());				
			}
		});
        
        mIntentFilter = new IntentFilter();
        
        mIntentFilter.addAction("android.net.wifi.WIFI_STATE_CHANGED");
        mIntentFilter.addAction("android.net.wifi.SCAN_RESULTS");
        mIntentFilter.addAction("android.net.wifi.supplicant.STATE_CHANGE");
        
        mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);        
        mWifiManager.setWifiEnabled(true);
        mWifiAdapter = new WifiAdapter(this, null);
        mList.setAdapter(mWifiAdapter);
        
    }
    
//    void showLog(String msg) {
//		new AlertDialog.Builder(this).setTitle(R.string.alert_dialog_prompt).setMessage(msg).show();
//	}

	void promptMessage(String msg) {
		Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
	}
    
    public void showEditWifi(final ScanResult sr){
    	LayoutInflater factory = LayoutInflater.from(this);
		final View textEntryView = factory.inflate(R.layout.dialog_wifi_setting, null);
		new AlertDialog.Builder(this).setIconAttribute(android.R.attr.dialogIcon).setTitle(sr.SSID).setView(textEntryView).setCancelable(false)
				.setPositiveButton(R.string.alert_dialog_ok, new DialogInterface.OnClickListener() {
					public void onClick(DialogInterface dialog, int whichButton) {
						try {
							EditText edtWifiPwd = (EditText) textEntryView.findViewById(R.id.edt_wifi_pwd);
							EditText edtStaticIp = (EditText) textEntryView.findViewById(R.id.edt_static_ip);
							EditText edtStaticGateway = (EditText) textEntryView.findViewById(R.id.edt_static_gateway);
							EditText edtStaticNetmask = (EditText) textEntryView.findViewById(R.id.edt_static_netmask);
							EditText edtStaticDns = (EditText) textEntryView.findViewById(R.id.edt_static_dns);
							
							String wifiPwd = edtWifiPwd.getText().toString().trim();
							String ip = edtStaticIp.getText().toString().trim();
							String gateway = edtStaticGateway.getText().toString().trim();
							String prefixLength = edtStaticNetmask.getText().toString().trim();
							String dns = edtStaticDns.getText().toString().trim();
							
							saveStaticWifiConfig(sr,wifiPwd,ip,Integer.parseInt(prefixLength));
						}catch (IllegalArgumentException e) {
							promptMessage(getString(R.string.system_wifi_ip_error));
						} catch (Exception e) {
							e.printStackTrace();
							promptMessage(getString(R.string.system_wifi_setting_error));
						}
					}
				}).setNegativeButton(R.string.alert_dialog_cancel, new DialogInterface.OnClickListener() {
					public void onClick(DialogInterface dialog, int whichButton) {
						dialog.cancel();
					}
				}).create().show();
		
		try {
			WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);
			EditText edtWifiPwd = (EditText) textEntryView.findViewById(R.id.edt_wifi_pwd);
			EditText edtStaticIp = (EditText) textEntryView.findViewById(R.id.edt_static_ip);
			EditText edtStaticGateway = (EditText) textEntryView.findViewById(R.id.edt_static_gateway);
			EditText edtStaticNetmask = (EditText) textEntryView.findViewById(R.id.edt_static_netmask);
			EditText edtStaticDns = (EditText) textEntryView.findViewById(R.id.edt_static_dns);
			
	    	if(historyWifiConfig != null){    		
	    		InetAddress address = getIpAddress(historyWifiConfig);
	    		if(address != null){
	    			edtStaticIp.setText(address.getHostAddress());
	    			address = null;
	    		}
	    		address = getGateway(historyWifiConfig);
	    		if(address != null){
	    			edtStaticGateway.setText(address.getHostAddress());
	    			address = null;
	    		}
	    		address = getDNS(historyWifiConfig);
	    		if(address != null){
	    			edtStaticDns.setText(address.getHostAddress());
	    			address = null;
	    		}
	    		edtStaticNetmask.setText(getNetworkPrefixLength(historyWifiConfig));			
				
	    	}
	    	
	    	if(TextUtils.isEmpty(edtStaticIp.getText().toString().trim())){
	    		String ipString = SmartHomePreference.getStringProperty(KEY_WIFI_STATIC_IP);
	    		int intIp = inetAddressToInt(InetAddress.getByName(ipString)); 
	    		String dns = (intIp & 0xFF ) + "." + ((intIp >> 8 ) & 0xFF) + "." + ((intIp >> 16 ) & 0xFF) + ".1";
	    		
	    		edtStaticIp.setText(ipString);
	    		edtStaticNetmask.setText("24");
	    		edtStaticGateway.setText(dns);
	    		edtStaticDns.setText(dns);	    		
	    	}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
    }
    
    /**
     * 设置wifi,编辑静态IP
     * @param sr
     * @param pwd
     * @param ip
     * @throws Exception
     */
    public void saveStaticWifiConfig(final ScanResult sr,String pwd, String ip,int networkPrefixLength) throws Exception{  
    	InetAddress intetAddress  = InetAddress.getByName(ip);
    	int intIp = inetAddressToInt(intetAddress);    	
    	WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);        	
    	if(historyWifiConfig == null){
    		historyWifiConfig = createComWifiConfig(sr.SSID,pwd);    		
    	}else{
    		if(!TextUtils.isEmpty(pwd)){
    			historyWifiConfig.preSharedKey = "\""+ pwd + "\"";  
    		}
    	}
    	
    	String dns = (intIp & 0xFF ) + "." + ((intIp >> 8 ) & 0xFF) + "." + ((intIp >> 16 ) & 0xFF) + ".1";
    	setIpAssignment("STATIC", historyWifiConfig); //"STATIC" or "DHCP" for dynamic setting
        setIpAddress(intetAddress, networkPrefixLength, historyWifiConfig);
        setGateway(InetAddress.getByName(dns), historyWifiConfig);
        setDNS(InetAddress.getByName(dns), historyWifiConfig);          
        
        mWifiManager.removeNetwork(historyWifiConfig.networkId);
        int netId = mWifiManager.addNetwork(historyWifiConfig);
		mWifiManager.enableNetwork(netId, true);
        mWifiManager.updateNetwork(historyWifiConfig); //apply the setting
        SmartHomePreference.setProperty(WifiActivity.KEY_WIFI_PRIORITY, sr.SSID);
        
        mWifiManager.startScan();
	}
    
    
    /***
     * Convert a IPv4 address from an InetAddress to an integer
     * @param inetAddr is an InetAddress corresponding to the IPv4 address
     * @return the IP address as an integer in network byte order
     */
    public static int inetAddressToInt(InetAddress inetAddr)
            throws IllegalArgumentException {
        byte [] addr = inetAddr.getAddress();
        if (addr.length != 4) {
            throw new IllegalArgumentException("Not an IPv4 address");
        }
        return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) |
                ((addr[1] & 0xff) << 8) | (addr[0] & 0xff);
    }
    
    public void editStaticWifiConfig(final ScanResult sr,String pwd, String ip, String gateway,int prefixLength,String dns) throws Exception{        
    	WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);
    	
    	if(historyWifiConfig == null){
    		historyWifiConfig = createComWifiConfig(sr.SSID,pwd);
    		int netId = mWifiManager.addNetwork(historyWifiConfig);
    		mWifiManager.enableNetwork(netId, true);
    	}
    	
        setIpAssignment("STATIC", historyWifiConfig); //"STATIC" or "DHCP" for dynamic setting
        setIpAddress(InetAddress.getByName(ip), prefixLength, historyWifiConfig);
        setGateway(InetAddress.getByName(gateway), historyWifiConfig);
        setDNS(InetAddress.getByName(dns), historyWifiConfig);
        
        mWifiManager.updateNetwork(historyWifiConfig); //apply the setting
	}
    
    public void editDhcpWifiConfig(final ScanResult sr,String pwd) throws Exception{        
    	WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);
    	
    	if(historyWifiConfig == null){
    		historyWifiConfig = createComWifiConfig(sr.SSID,pwd);
    		int netId = mWifiManager.addNetwork(historyWifiConfig);
    		mWifiManager.enableNetwork(netId, true);
    	}
    	
        setIpAssignment("DHCP", historyWifiConfig); //"STATIC" or "DHCP" for dynamic setting
        
        mWifiManager.updateNetwork(historyWifiConfig); //apply the setting
	}

    /**
     *  新建wifi配置项
     * @param ssid
     * @param pwd
     * @return
     */
    public WifiConfiguration createComWifiConfig(String ssid,String pwd){
    	WifiConfiguration wc = new WifiConfiguration();
        wc.SSID = "\"" + ssid + "\"";      				//配置wifi的SSID，即该热点的名称，如：TP-link_xxx
        wc.preSharedKey = "\""+ pwd + "\"";            //该热点的密码
        wc.hiddenSSID = true;
        wc.status = WifiConfiguration.Status.ENABLED;
        wc.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
        wc.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
        wc.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
        wc.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
        wc.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
        wc.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
        return wc;
    }
    
    /**
     * 查找已经设置好的Wifi
     * @param ssid
     * @return
     */
    public WifiConfiguration getHistoryWifiConfig(String ssid){
    	List<WifiConfiguration> localList = mWifiManager.getConfiguredNetworks();
        for(WifiConfiguration wc : localList){
        	if(("\"" + ssid + "\"").equals(wc.SSID)){
        		return wc;
        	}
        	mWifiManager.disableNetwork(wc.networkId);
        }
        return null;
    }
  
	public static void setIpAssignment(String assign, WifiConfiguration wifiConf)throws SecurityException, IllegalArgumentException,NoSuchFieldException, IllegalAccessException {
		setEnumField(wifiConf, assign, "ipAssignment");
	}

	public static void setIpAddress(InetAddress addr, int prefixLength,WifiConfiguration wifiConf) throws SecurityException,IllegalArgumentException,
	NoSuchFieldException,IllegalAccessException, NoSuchMethodException,ClassNotFoundException, InstantiationException,InvocationTargetException {
		Object linkProperties = getField(wifiConf, "linkProperties");
		if (linkProperties == null)
			return;
		Class laClass = Class.forName("android.net.LinkAddress");
		Constructor laConstructor = laClass.getConstructor(new Class[] {InetAddress.class, int.class });
		Object linkAddress = laConstructor.newInstance(addr, prefixLength);
		ArrayList mLinkAddresses = (ArrayList) getDeclaredField(linkProperties,"mLinkAddresses");
		mLinkAddresses.clear();
		mLinkAddresses.add(linkAddress);
	}

	public static void setGateway(InetAddress gateway,WifiConfiguration wifiConf) throws SecurityException,IllegalArgumentException,
	NoSuchFieldException,IllegalAccessException, ClassNotFoundException,NoSuchMethodException, InstantiationException,InvocationTargetException {
		Object linkProperties = getField(wifiConf, "linkProperties");
		if (linkProperties == null)
			return;
		Class routeInfoClass = Class.forName("android.net.RouteInfo");
		Constructor routeInfoConstructor = routeInfoClass.getConstructor(new Class[] { InetAddress.class });
		Object routeInfo = routeInfoConstructor.newInstance(gateway);
		ArrayList mRoutes = (ArrayList) getDeclaredField(linkProperties,"mRoutes");
		mRoutes.clear();
		mRoutes.add(routeInfo);
	}

	public static void setDNS(InetAddress dns, WifiConfiguration wifiConf) throws SecurityException, IllegalArgumentException,NoSuchFieldException, IllegalAccessException {
		Object linkProperties = getField(wifiConf, "linkProperties");
		if (linkProperties == null)
			return;
		ArrayList<InetAddress> mDnses = (ArrayList<InetAddress>) getDeclaredField(linkProperties, "mDnses");
		mDnses.clear(); // or add a new dns address , here I just want to replace DNS1
		mDnses.add(dns);
	}
	
	public static String getNetworkPrefixLength(WifiConfiguration wifiConf) {
		String address = "";
		try {
			Object linkProperties = getField(wifiConf, "linkProperties");
			if (linkProperties == null)
				return null;
			
			if (linkProperties != null){
				ArrayList mLinkAddresses = (ArrayList) getDeclaredField(linkProperties,"mLinkAddresses");
				if(mLinkAddresses != null && mLinkAddresses.size() > 0){
					Object linkAddressObj = mLinkAddresses.get(0);
					address = linkAddressObj.getClass().getMethod("getNetworkPrefixLength",  new Class[]{}).invoke(linkAddressObj,null) + "";
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		return address;
	}
	
	public static InetAddress getIpAddress(WifiConfiguration wifiConf) {
		InetAddress address = null;
		try {
			Object linkProperties = getField(wifiConf, "linkProperties");
			if (linkProperties == null)
				return null;
			
			if (linkProperties != null){
				ArrayList mLinkAddresses = (ArrayList) getDeclaredField(linkProperties,"mLinkAddresses");
				if(mLinkAddresses != null && mLinkAddresses.size() > 0){
					Object linkAddressObj = mLinkAddresses.get(0);
					address = (InetAddress)linkAddressObj.getClass().getMethod("getAddress",  new Class[]{}).invoke(linkAddressObj,null);
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		return address;
	}

	public static InetAddress getGateway(WifiConfiguration wifiConf)  {
		InetAddress address = null;
		try {
			Object linkProperties = getField(wifiConf, "linkProperties");
			
			if (linkProperties != null){
				ArrayList mRoutes = (ArrayList) getDeclaredField(linkProperties,"mRoutes");
				if(mRoutes != null && mRoutes.size() > 0){
					Object linkAddressObj = mRoutes.get(0);
					address = (InetAddress)linkAddressObj.getClass().getMethod("getGateway",  new Class[]{}).invoke(linkAddressObj,null);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return address;
	}

	public static InetAddress getDNS(WifiConfiguration wifiConf) {
		InetAddress address = null;
		try {
			Object linkProperties = getField(wifiConf, "linkProperties");
			
			if (linkProperties != null){
				ArrayList<InetAddress> mDnses = (ArrayList<InetAddress>) getDeclaredField(linkProperties, "mDnses");
				if(mDnses != null && mDnses.size() > 0){
					address = (InetAddress)mDnses.get(0);				
				}
			}		
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return address;
	}

	public static Object getField(Object obj, String name) throws SecurityException, NoSuchFieldException,IllegalArgumentException, IllegalAccessException {
		Field f = obj.getClass().getField(name);
		Object out = f.get(obj);
		return out;
	}

	public static Object getDeclaredField(Object obj, String name) throws SecurityException, NoSuchFieldException,IllegalArgumentException, IllegalAccessException {
		Field f = obj.getClass().getDeclaredField(name);
		f.setAccessible(true);
		Object out = f.get(obj);
		return out;
	}

	public static void setEnumField(Object obj, String value, String name) throws SecurityException, NoSuchFieldException,
			IllegalArgumentException, IllegalAccessException {
		Field f = obj.getClass().getField(name);
		f.set(obj, Enum.valueOf((Class<Enum>) f.getType(), value));
	}


    @Override
    protected void onResume() {
        super.onResume();
        registerReceiver(mReceiver, mIntentFilter);
        if(mWifiManager != null) mWifiManager.startScan();
    }
    
    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(mReceiver);        
    }

	@Override
	public void onClick(View v) {
		switch (v.getId()) {
		case R.id.back:
//			if(mWifiManager != null) mWifiManager.startScan();
			finish();
			break;

		default:
			break;
		}
	}
	
	public void endScanWifi(final List<ScanResult> list){
		runOnUiThread(new Runnable() {			
			@Override
			public void run() {
				if(mWifiAdapter != null){
					mWifiAdapter.setList(list);
					mWifiAdapter.notifyDataSetChanged();
				}	
			}
		});
			
	}
}

AresCJ
关注
Android 10.0 wifi设置静态ip功能实现
安卓兼职framework和app工程师的博客
05-30 697
在10.0的系统rom定制化开发中，在某些功能开发中，在wifi模块中，有产品需要要求设置wifi静态ip功能，而系统中wifi连接 后ip是动态的，每次开机后连接wifi的ip就是不固定的，所以产品需要采用固定ip，就需要实现静态ip功能
Android 11.0 wifi设置静态ip功能实现
最新发布
安卓兼职framework和app工程师的博客
07-23 443
在11.0的系统rom定制化开发中，在某些功能开发中，在wifi模块中，有产品需要要求设置wifi静态ip功能，而系统中wifi连接 后ip是动态的，每次开机后连接wifi的ip就是不固定的，所以产品需要采用固定ip，就需要实现静态ip功能
android实现wifi静态IP设置
08-04
实现wifi静态IP设置，4.2以下版本都可使用，封装好，方便使用
Android 获取wifi的IP地址
only
03-29 4517
wifimanage=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);//获取WifiManager //检查wifi是否开启 if(!wifimanage.isWifiEnabled()) { wifimanage.setWifiEnabled(true); } WifiInfo? wif
Android Wi-Fi 网络选择
华南烹鱼宴
06-29 1106
例如，如果某个网络在连续五次连接失败时被停用 5 分钟，则第六次连接失败时将被停用 10 分钟，第七次连接失败时将被停用 20 分钟，依此类推，直至达到 18 小时的上限。即使这类网络的性能低于公共网络，用户也可能更倾向于连接到这类网络，因为这类网络可以提供额外的服务，例如能够控制家用设备。已保存网络与推荐网络之间的比较，以及按流量计费的网络与不按流量计费的网络之间的比较，这两项是网络评估的主要类别。这意味着，相对于已保存的按流量计费（付费）的网络，系统始终会优先选择已保存的不按流量计费（免费）的网络。
Android获取wifi的IP地址
LikeSidehu的专栏
07-13 1705
public static String getWifiIp() { WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); if(!wifiManager.isWifiEnabled()) { return null; } WifiIn...
Android获取wifi的ip地址
热门推荐
技匠而已
02-07 1万+
博客来源： 突发奇想获取IP的地址进行搞事，然后记录一下获取设备的ip地址，话不多说，硬核开整
wifimanager类可否可以设置android的IP地址
liu_jun_y的专栏
06-26 2521
需要permission: 更改代码为: android.provider.Settings.System.putString(getContentResolver(), android.provider.Settings.System.WIFI_USE_STATIC_IP, "0"); android.provider.Settings.System.putString(get
android wifi静态ip设置
04-02
在Android设备上，静态IP设置通常涉及修改网络接口的配置文件，但作为应用程序开发者，我们可以利用Android提供的API来完成这个任务，无需root权限。 Android的静态IP设置主要通过`ConnectivityManager`和`Network...
安卓wifi蓝牙相关-androidwifi静态IP设置.rar
07-29
本资料“安卓wifi蓝牙相关-androidwifi静态IP设置.rar”似乎包含了一些关于如何在Android设备上配置WiFi静态IP地址的信息，这对于网络管理和多设备通信尤其有用。下面将详细介绍相关知识点。 首先，让我们关注WiFi...
android如何得到wifi的ip地址,如何从android中的代码知道路由器的IP地址？
weixin_35410816的博客
05-26 291
嘿,这可能对你有帮助：DHCPInfofinal WifiManager manager = (WifiManager) super.getSystemService(WIFI_SERVICE);final DhcpInfo dhcp = manager.getDhcpInfo();final String address = Formatter.formatIpAddress(dhcp.gate...
android wifi热点的ip地址,在Android中，如何获得wifi热点的IP？_java_开发99编程知识库...
weixin_30697437的博客
05-26 1327
在WiFi时没有被设置为热点，它有一个name android-xx7632x324x32423个人热点处于打开状态时，其名称都不见了。 此外，该ip地址的列表。所以如果你能很好的在WiFi config启用热点，首先可以使用之前， intf.getName()若要获取对它的引用。其次，wifi的ip更改，如果你知道哪个接口处于 CONNECTED模式下，可以使用该信息来标识在后来开启后的热点。下...
android获取有线、wifi、3G(4G)的IP
记录工作日常
01-08 980
//获取ip地址 public static String getLocalIPAddress(Context context) { NetworkInfo info = ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo(); if...
android设置wifiip地址,android Wifi 设置静态ip地址的方法
weixin_36162883的博客
05-26 1336
调用setIpWithTfiStaticIp()即可为连接好的wifi配置静态Ip。支持Android4.0以上及以下的版本。(PS：以下的函数使用条件是：wifi是连接好的)测试成功的/** * 设置静态ip地址的方法*/private boolean setIpWithTfiStaticIp() {WifiManager wifiManager = (WifiManager) Fa...
Android11 Wifi连接流程之IP地址分配
一个Android菜鸟的博客
09-10 3262
在Android11 wifi连接流程中我们代码跟踪到了supplicant中开始associate，关联成功以后就是四次握手然后连接成功。连接成功以后还需要分配IP地址，才可以通信，这一节我们看一下IP地址的获取流程。 一、在ClientModeImpl中有一个函数startIpClient。这个函数会在俩个地方被调用，一个是连接的时候ConnectModeState，一个是连接成功以后进入ObtainingIpState。这俩个地方的区别就是isFilsConnection的不同，连接过程中isFils
[MT8766][Android12] 修改WIFI热点默认名称、密码、IP地址以及默认开启热点
小小码农
10-12 1480
最近做了一款没有屏幕显示的智能盒子，要想操控这款设备就只能通过adb投屏，如果默认不允许有线连接，那么要怎么实现adb投屏呢？安卓是支持WIFI adb连接投屏的，只要盒子启动热点，然后用手机或者其他有屏幕的设备连接盒子的热点，这样就可以通过IP地址在有屏幕的设备操纵智能盒子。设备默认开启热点，固定热点的名称、密码以及IP地址，然后手机或者电脑，连接设备的热点，这样电脑跟设备就处于同一个局域网内，通过固定IP就能连接、操作设备。
Android10 系统应用wifi连接和静态ip代理设置
wenzhi的博客
03-23 5420
Android10 系统应用wifi连接和静态ip代理设置 如果是Android10或者更新的Android版本wifi开发，本文对你或许有一定的帮助。 文章目录Android10 系统应用wifi连接和静态ip代理设置Android wifi连接和静态ip代理设置 主要针对系统应用wifi连接的主要代码：WifiConfiguration对象构建其他共勉：努力学习自己应该掌握的知识。 Android wifi连接和静态ip代理设置 主要针对系统应用 wifi连接的主要代码： Android 9 以及之前的
Android设置WIFI静态IP
lebulangzhen的博客
12-29 3082
想要在代码中实现设置WIFI静态IP需要有系统权限，要在manifest文件添加android:sharedUserId=“android.uid.system”，还要有系统签名。 设置WIFI静态IP和之前以太网的类似，都是要构造StaticIpConfiguration对象，以及IpConfiguration.IpAssignment.STATIC就代表设置为静态IP，也可以设置DHCP（自动获取），不过WifiConfiguration可以直接通过WifiManager获取到，比设置以太网的要简单一些
Android WIFI模块测试详解
7. **设置静态IP**：Android系统在IP设置上的输入限制存在缺陷，可能导致非标准IP输入。 深入探讨WIFI模块的运行流程，文档提到了初始化过程，包括在SystemServer启动时生成ConnectivityService实例，然后创建...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值