精华内容
下载资源
问答
  • 安卓9.0设置WIFI静态IP地址
    千次阅读 热门讨论
    2020-06-16 14:09:26

    简单的一个函数实现对wifi设置静态或动态IP地址。

    一、需要的权限

    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
    <uses-permission android:name="android.permission.OVERRIDE_WIFI_CONFIG"
        tools:ignore="ProtectedPermissions" />

    可以删除该WiFi 和修改。

    二、清单文件需要将shareduserid设置成system。

    android:sharedUserId="android.uid.system"

    三、具体函数,函数执行条件是wifi开关打开,并且要设置的wifi已经连接成功。

        // 定义几种加密方式,一种是WEP,一种是WPA,还有没有密码的情况
        public enum WifiCipherType {
            WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
        }
    
        /**
         * @param context   use Application context is better
         * @param ipAddress ip address: like 192.168.1.168
         * @param mode      : STATIC or DHCP, set static or dhcp ip mode
         * @param netmask   ip mask, like 255.255.255.0
         * @param gateway   gateway, like 192.168.1.1
         * @param dns1      dns 1
         * @param dns2      dns 2, if mode=static, then can use "" or null
         * @param ssid current has connected wifi ssid
         * @param pwd current has connected wifi pwd
         * @param wifiCipherType current has connected wifi capabilities
         *                  eg. dhcp mode: setWifiStaticIP(ApplicationContext, "DHCP", "", "", "", "", "", "test", "123456", WifiCipherType.WIFICIPHER_WPA);
         *                  static mode: setWifiStaticIP(ApplicationContext, "STATIC",
         *                  "192.168.1.168", "255.255.255.0",
         *                  "192.168.1.1", "114.114.114.114", "8.8.8.8", "test", "123456", WifiCipherType.WIFICIPHER_WPA);
         *                  for android 9.0
         */
        public static boolean setWifiStaticIP(Context context, String mode, String ipAddress, String netmask,
                                            String gateway, String dns1, String dns2,
                                              String ssid, String pwd, WifiCipherType wifiCipherType) {
            if (context == null || (!"STATIC".equals(mode) && !"DHCP".equals(mode))
                || TextUtils.isEmpty(ssid) || wifiCipherType == null
                    || TextUtils.isEmpty(wifiCipherType.name())) {
                Log.d(TAG, " setWifiStaticIP failed, param incorrect context=" + context + ", mode=" + mode);
                return false;
            }
    
            try {
                WifiManager wifiManager = ((WifiManager) context.getSystemService(Context.WIFI_SERVICE));
                if ("DHCP".equals(mode)) {
                    IpConfiguration dhcpConfiguration = new IpConfiguration(IpConfiguration.IpAssignment.DHCP,
                            IpConfiguration.ProxySettings.NONE, null, null);
                    dhcpConfiguration.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
                    WifiConfiguration wifiConfiguration = createWifiConfig(ssid, pwd, wifiCipherType, dhcpConfiguration);
                    // current assignment is DHCP OR STATIC
                    String assignMent = wifiConfiguration.getIpConfiguration().ipAssignment.name();
                    Log.d(TAG, " setWifiStaticIP assignMent=" + assignMent + ", mode=" + mode);
                    wifiManager.setWifiApConfiguration(wifiConfiguration);
                    // update network
                    wifiManager.updateNetwork(wifiConfiguration);
                    // reconnect
                    int netId = wifiManager.addNetwork(wifiConfiguration);
                    wifiManager.disableNetwork(netId);
                    wifiManager.enableNetwork(netId, true);
                    Log.i(TAG, " setWifiStaticIP dhcp set success");
                    return true;
                }
                // set static ip address
                IpConfiguration ipConfiguration = getStaticIpConfiguration(ipAddress, netmask, gateway, dns1, dns2);
                if (ipConfiguration != null) {
                    WifiConfiguration wifiConfiguration = createWifiConfig(ssid, pwd, wifiCipherType, ipConfiguration);
                    wifiManager.setWifiApConfiguration(wifiConfiguration);
                    // update network
                    wifiManager.updateNetwork(wifiConfiguration);
                    // reconnect
                    int netId = wifiManager.addNetwork(wifiConfiguration);
                    wifiManager.disableNetwork(netId);
                    wifiManager.enableNetwork(netId, true);
                    Log.i(TAG, "setWifiStaticIP set static ip success");
                    return true;
                } else {
                    Log.w(TAG, "setWifiStaticIP set static ip failed");
                    return false;
                }
            } catch (Exception e) {
                Log.e(TAG, "setWifiStaticIP e=" + e.getMessage());
            }
            return false;
        }
    
        private static IpConfiguration getStaticIpConfiguration(String ipAddress, String netmask, String gateway, String dns1, String dns2) {
            try {
                StaticIpConfiguration staticIpConfiguration = new StaticIpConfiguration();
                int prefixLength = maskStr2InetMask(netmask);
                InetAddress inetAddr = null;
                InetAddress gatewayAddr = getIPv4Address(gateway);
                InetAddress dnsAddr = getIPv4Address(dns1);
    
                if (TextUtils.isEmpty(ipAddress)) {
                    inetAddr = getLocalIPAddress();
                } else {
                    String[] ipStr = ipAddress.split("\\.");
                    byte[] ipBuf = new byte[4];
                    for (int i = 0; i < 4; i++) {
                        ipBuf[i] = (byte) (Integer.parseInt(ipStr[i]) & 0xff);
                    }
                    try {
                        inetAddr = InetAddress.getByAddress(ipBuf);
                        Log.d(TAG, "getStaticIpConfiguration  address correct inetAddr=" + inetAddr);
                    } catch (UnknownHostException e) {
                        e.printStackTrace();
                    }
                }
    
                if (inetAddr == null || inetAddr.getAddress().toString().isEmpty()
                        || prefixLength == 0 || gatewayAddr.toString().isEmpty()
                        || dnsAddr == null || dnsAddr.toString().isEmpty()) {
                    Log.d(TAG, " getStaticIpConfiguration  address incorrect inetAddr=" + inetAddr);
                    return null;
                }
    
                Class<?> linkAddressClass = null;
                linkAddressClass = Class.forName("android.net.LinkAddress");
                Class[] cl = new Class[]{InetAddress.class, int.class};
                Constructor cons = null;
                try {
                    cons = linkAddressClass.getConstructor(cl);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
                Object[] x = {inetAddr, prefixLength};
                try {
                    staticIpConfiguration.ipAddress = (LinkAddress) cons.newInstance(x);
                    Log.d(TAG, " getStaticIpConfiguration staticIpConfiguration.ipAddress=" + staticIpConfiguration.ipAddress);
                } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
                    e.printStackTrace();
                }
    
                staticIpConfiguration.gateway = gatewayAddr;
                staticIpConfiguration.dnsServers.add(dnsAddr);
                if (!dns2.isEmpty())
                    staticIpConfiguration.dnsServers.add(getIPv4Address(dns2));
    
                Log.d(TAG, " getStaticIpConfiguration staticIpConfiguration  ====" + staticIpConfiguration
                        + ", inetAddr=" + inetAddr);
    
                IpConfiguration ipConfiguration = new IpConfiguration(IpConfiguration.IpAssignment.STATIC,
                        IpConfiguration.ProxySettings.NONE, staticIpConfiguration, null);
                ipConfiguration.setIpAssignment(IpConfiguration.IpAssignment.STATIC);
                ipConfiguration.setStaticIpConfiguration(staticIpConfiguration);
                return ipConfiguration;
            } catch (Exception e) {
                Log.e(TAG, "getStaticIpConfiguration ERROR=" + e.getMessage());
            }
            return null;
        }

    ------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    2020/07/22补充上述中缺失的函数。 

        /*
         * convert subMask string to prefix length
         */
        public static int maskStr2InetMask(String maskStr) {
            StringBuffer sb;
            String str;
            int inetmask = 0;
            int count = 0;
            /*
             * check the subMask format
             */
            Pattern pattern = Pattern.compile("(^((\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])$)|^(\\d|[1-2]\\d|3[0-2])$");
            if (pattern.matcher(maskStr).matches() == false) {
                Log.e(TAG, "subMask is error");
                return 0;
            }
    
            String[] ipSegment = maskStr.split("\\.");
            for (int n = 0; n < ipSegment.length; n++) {
                sb = new StringBuffer(Integer.toBinaryString(Integer.parseInt(ipSegment[n])));
                str = sb.reverse().toString();
                count = 0;
                for (int i = 0; i < str.length(); i++) {
                    i = str.indexOf("1", i);
                    if (i == -1)
                        break;
                    count++;
                }
                inetmask += count;
            }
            return inetmask;
        }
    public static InetAddress getIPv4Address(String text) {
            try {
                return NetworkUtils.numericToInetAddress(text);
            } catch (IllegalArgumentException | ClassCastException e) {
                return null;
            }
        }
        /**
         * Get local Ip address.
         */
        public static InetAddress getLocalIPAddress() {
            Enumeration<NetworkInterface> enumeration = null;
            try {
                enumeration = NetworkInterface.getNetworkInterfaces();
            } catch (SocketException e) {
                e.printStackTrace();
            }
            if (enumeration != null) {
                while (enumeration.hasMoreElements()) {
                    NetworkInterface nif = enumeration.nextElement();
                    Enumeration<InetAddress> inetAddresses = nif.getInetAddresses();
                    if (inetAddresses != null) {
                        while (inetAddresses.hasMoreElements()) {
                            InetAddress inetAddress = inetAddresses.nextElement();
                            if (!inetAddress.isLoopbackAddress() && isIPv4Address(inetAddress.getHostAddress())) {
                                return inetAddress;
                            }
                        }
                    }
                }
            }
            return null;
        }
    public static WifiConfiguration createWifiConfig(String SSID, String password,
                                                         WifiCipherType type,
                                                         IpConfiguration ipConfiguration) {
            WifiConfiguration config = new WifiConfiguration();
            config.allowedAuthAlgorithms.clear();
            config.allowedGroupCiphers.clear();
            config.allowedKeyManagement.clear();
            config.allowedPairwiseCiphers.clear();
            config.allowedProtocols.clear();
            config.SSID = "\"" + SSID + "\"";
            config.setIpConfiguration(ipConfiguration);
            if (type == WifiCipherType.WIFICIPHER_NOPASS) {
    //            config.wepKeys[0] = "";  //注意这里
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
    //            config.wepTxKeyIndex = 0;
            }
    
            if (type == WifiCipherType.WIFICIPHER_WEP) {
                config.preSharedKey = "\"" + password + "\"";
                config.hiddenSSID = true;
                config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                config.wepTxKeyIndex = 0;
            }
    
            if (type == WifiCipherType.WIFICIPHER_WPA) {
                config.preSharedKey = "\"" + password + "\"";
                config.hiddenSSID = true;
                config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
                config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
                config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
                config.status = WifiConfiguration.Status.ENABLED;
            }
            return config;
        }
        
        /**
         * Ipv4 address check.
         */
        private static final Pattern IPV4_PATTERN = Pattern.compile(
                "^(" + "([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}" +
                        "([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$");
        /**
         * Check if valid IPV4 address.
         *
         * @param input the address string to check for validity.
         * @return True if the input parameter is a valid IPv4 address.
         */
        public static boolean isIPv4Address(String input) {
            return IPV4_PATTERN.matcher(input).matches();
        }

    -------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    2021/1/7补充,设置当前连接的wifi为静态IP或自动获取IP ,在安卓5.1.1测试通过,这样就不需要传入SSID,密码和加密方式了。

        /**
         * @param context   use Application context is better
         * @param ipAddress ip address: like 192.168.1.168
         * @param mode      : STATIC or DHCP, set static or dhcp ip mode
         * @param netmask   ip mask, like 255.255.255.0
         * @param gateway   gateway, like 192.168.1.1
         * @param dns1      dns 1
         * @param dns2      dns 2, if mode=static, then can use "" or null
         *                  eg. dhcp mode: setWifiStaticIP(ApplicationContext, "DHCP", "", "", "", "", "");
         *                  static mode: setWifiStaticIP(ApplicationContext, "STATIC",
         *                  "192.168.1.168", "255.255.255.0",
         *                  "192.168.1.1", "114.114.114.114", "8.8.8.8");
         *                  for android 9.0 or 5.1
         */
        public boolean setWifiStaticIP(Context context, String mode, String ipAddress, String netmask,
                                              String gateway, String dns1, String dns2) {
            if (context == null || (!"STATIC".equals(mode) && !"DHCP".equals(mode))) {
                Log.d(TAG, " setWifiStaticIP failed, param incorrect context=" + context + ", mode=" + mode);
                return false;
            }
            try {
                WifiManager wifiManager = ((WifiManager) context.getSystemService(Context.WIFI_SERVICE));
                if ("DHCP".equals(mode)) {
                    IpConfiguration dhcpConfiguration = new IpConfiguration(IpConfiguration.IpAssignment.DHCP,
                            IpConfiguration.ProxySettings.NONE, null, null);
                    dhcpConfiguration.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
                    WifiConfiguration wifiConfiguration = getCurrentConfig();
                    if (wifiConfiguration != null) {
                        wifiConfiguration.setIpConfiguration(dhcpConfiguration);
                        // current assignment is DHCP OR STATIC
                        String assignMent = wifiConfiguration.getIpConfiguration().ipAssignment.name();
                        Log.d(TAG, " setWifiStaticIP assignMent=" + assignMent + ", mode=" + mode);
                        wifiManager.setWifiApConfiguration(wifiConfiguration);
                        // update network
                        wifiManager.updateNetwork(wifiConfiguration);
                        // reconnect
                        int netId = wifiManager.addNetwork(wifiConfiguration);
                        wifiManager.disableNetwork(netId);
                        wifiManager.enableNetwork(netId, true);
                        Log.i(TAG, " setWifiStaticIP dhcp set success");
                        return true;
                    } else {
                        return false;
                    }
                }
                // set static ip address
                IpConfiguration ipConfiguration = getStaticIpConfiguration(ipAddress, netmask, gateway, dns1, dns2);
                if (ipConfiguration != null) {
                    WifiConfiguration wifiConfiguration = getCurrentConfig();
                    if (wifiConfiguration != null) {
                        wifiConfiguration.setIpConfiguration(ipConfiguration);
                        wifiManager.setWifiApConfiguration(wifiConfiguration);
                        // update network
                        wifiManager.updateNetwork(wifiConfiguration);
                        // reconnect
                        int netId = wifiManager.addNetwork(wifiConfiguration);
                        wifiManager.disableNetwork(netId);
                        wifiManager.enableNetwork(netId, true);
                        Log.i(TAG, "setWifiStaticIP set static ip success");
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    Log.w(TAG, "setWifiStaticIP set static ip failed");
                    return false;
                }
            } catch (Exception e) {
                Log.e(TAG, "setWifiStaticIP e=" + e.getMessage());
            }
            return false;
        }
        
       /**
         * 获取当前网络配置信息
         */
        public WifiConfiguration getCurrentConfig()
        {
            WifiManager mWifiManager = ((WifiManager) context.getSystemService(Context.WIFI_SERVICE));
            WifiInfo connectionInfo = mWifiManager.getConnectionInfo();  //得到连接的wifi网络
            WifiConfiguration wifiConfig = null;
            List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
            for (WifiConfiguration conf : configuredNetworks) {
                if (conf.networkId == connectionInfo.getNetworkId()) {
                    wifiConfig = conf;
                    break;
                }
            }
            return wifiConfig;
        }

    因为部分api在framework.jar中才有,所以需要导入framework.jar作为依赖,另外测试时app用了platform签名。

    framework.jar可以在https://github.com/zzhceo/EthernetStaticIp获取。

    在模块的build.gradle中加入依赖framework.jar方式如下:

    dependencies {
        //... ...
        // framework.jar placed in app/libs directory
        compileOnly files('libs/framework.jar')
    }

    部分参考:https://blog.csdn.net/ink_s/article/details/78720544

    以太网静态、动态IP设置可参考我的另一篇文章:https://blog.csdn.net/zzhceo/article/details/99596435

    更多相关内容
  • 目录ubuntu 设置静态IP地址最简单的方法 ubuntu 设置静态IP地址最简单的方法 右键点击右上角的WiFi标志,如下 点击第一个,如下 Interface是目前网口,点击右边的框 —>默认的eth0是有线的,wlan0是无线的 点击...
  • 树莓派WiFi设置固定IP地址

    千次阅读 2021-04-26 15:50:10
    陈拓 2021/04/25-2021/04/25 树莓派开启WiFi 见《电脑连接树莓派3B+》 ... ... 通过WiFi登录树莓派,查看网络接口 wlan0在192.168.3网段...设置树莓派设置固定IP地址192.168.3.8 sudo nano /etc/network/interfac.

    陈拓 2021/04/25-2021/04/25

     

    • 树莓派开启WiFi

    见《电脑连接树莓派3B+》

    https://zhuanlan.zhihu.com/p/40500429

    https://blog.csdn.net/chentuo2000/article/details/103332186

    • 通过WiFi登录树莓派,查看网络接口

    wlan0在192.168.3网段上。

    • 设置树莓派设置固定IP地址192.168.3.8

    sudo nano /etc/network/interfaces

    auto lo
    iface lo inet loopback
    
    iface eth0 inet dhcp
    
    allow-hotplug wlan0
    iface wlan0 inet manual
    wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
    iface default inet static
    address 192.168.3.8
    netmask 255.255.255.0
    gateway 192.168.3.1
    dns-nameservers 192.168.3.1
    • 重新启动系统

    sudo reboot

    • 查看IP地址

     

     

    展开全文
  • 我最近在学习有关tcp通信的相关内容,发现在客户端连接服务端时(linux ubuntu16.04),需要先确定服务端的IP地址,由于电脑连接时默认动态分配IP地址,不同时间连接同一wifiIP地址可能不同,所以需要设置静态IP。...

            我最近在学习有关tcp通信的相关内容,发现在客户端连接服务端时(linux ubuntu16.04),需要先确定服务端的IP地址,由于电脑连接时默认动态分配IP地址,不同时间连接同一wifi的IP地址可能不同,所以需要设置静态IP。

            开始我参照网上的一些博客,通过修改/etc/network/interfaces和/etc/resolv.conf中的相关内容,包括IP地址、网关、掩码、DNS等实现静态IP的设置,但是我在设置完后重启电脑后发现电脑不能连接网络,百度了好久也没解决。

            然后我发现可以直接点击wifi连接图标进行设置。
            点击wifi连接图标,然后点击最下面的编辑连接:

                                                         

           选择需要编辑的wifi名称,然后点击编辑,选择IPv4设置,方法选为手动,在地址一栏中点击增加,分别双击设置地址、子网掩码和网关,然后点击保存即可。

                                                        

    展开全文
  • 1. 打开网络和Internet配置。点击电脑图标,鼠标右键,出现这个标志 2. 点击更改适配器选项。 3. 点击以太网 4.... 6. 然后在这里你就能自由配置你的路由信息啦,注意IP地址不能跟别人的冲突了! ...

    1. 打开网络和Internet配置。点击电脑图标,鼠标右键,出现这个标志

     

     

     

    2. 点击更改适配器选项。

     

     

    3. 点击以太网

     

    4.点击属性

     

     

    5.用鼠标双击Internet协议版本(TCP/Ipv4),一定要双击!

     

     

    6. 然后在这里你就能自由配置你的路由信息啦,注意IP地址不能跟别人的冲突了!

     

    展开全文
  • WifiManager类提供了对设备Wifi功能的管理,包括Wifi开关的打开和关闭,IP地址获取等等,早期的Android版本甚至支持对于IP的设置。在这里仅介绍其简单的一个小应用——获取IP地址。 首先先添加Uses-Permission:...
  • android实现wifi静态IP设置

    热门讨论 2013-08-04 19:08:32
    实现wifi静态IP设置,4.2以下版本都可使用,封装好,方便使用
  • 如何设置安卓手机WIFI的静态IP地址哈哈
  • Android设置WIFI静态IP

    千次阅读 热门讨论 2020-12-29 16:25:27
    想要在代码中实现设置WIFI静态IP需要有系统权限,要在manifest文件添加android:sharedUserId=“android.uid.system”,还要有系统签名。 设置WIFI静态IP和之前以太网的类似,都是要构造StaticIpConfiguration对象,...
  • 在公司、家里连接WIFI热点时移动设备多了,经常会出现无法连接的现象。出现这种现象的原因有很多,其中一种就是“IP冲突”。今天脚本之家小编就给大家演示一下,在手机上如何设置“静态IP”...如何设置手机IP地址 ...
  • 无线网络如何设置静态ip地址

    千次阅读 2021-08-07 03:17:57
    在我们手机中会发现DHCP服务器来获得动态IP地址了,但有时dhcp获取的IP上不了网这时就需要固定IP地址了,那么如何设置静态IP地址呢?下面是学习啦小编给大家整理的一些有关无线网络设置静态ip地址的方法,希望对大家...
  • 为无线网设置固定IP地址

    千次阅读 2021-02-18 13:49:50
    (1)一个人只要自己不放弃自己,整个世界也不会放弃你. (2)天生我才必有大用 (3)不能忍受学习之苦就一定要忍受生活之苦...(1)自己的计算机是通过连接WIFI热点上网,由于软件开发需要,不希望IP地址变来变去的,.
  • 网上有些设置wifi的资料,WEP加密方式存在一些bug,进行了修复;上传一个完整的测试wep加密,静态分配ip的例子;
  • Linux设置固定IP连接wifi

    千次阅读 2019-12-16 11:24:58
    设置固定IP ... 例如想要设置网络的信息如下 ...IP地址:10.10.10.155 子网掩码:255.255.255.0 网关:10.10.10.2 广播地址:10.10.10.255 DNS:10.10.10.2,114.114.114.114 我们需要编辑2个文件 /etc/netwo...
  • 本文主要介绍了笔记本电脑中,把无线网络连接中的IP地址,配置为自动获取IP地址设置方法。由于在XP、Win7、Win8系统中,设置方法有所不同;所以,下面本文将分别介绍XP、Win7、Win8笔记本中,把无线网络连接中的IP...
  • 360安全路由器IP地址怎么设置?我们在正确安装360安全路由器和将电脑的IP地址设置为自动获取后,就可以进行360安全路由器IP设置,下面小编就为大家带来360安全路由器IP设置方法。360安全路由器IP设置方法:1、打开...
  • 电脑怎么设置无线网络ip地址

    千次阅读 2021-07-05 08:35:07
    有时候我们的电脑连接无线网络不能上网时,可能是因为ip地址获取不到的问题,这个时候可以自己设置无线网络ip地址。下面是学习啦小编整理的电脑设置无线网络ip地址的方法,供您参考。电脑设置无线网络ip地址的方法...
  • 现在博主在上大三,正在学习一些计算机网络的一些概念,知道了局域网ip和网关ip不同的概念,当时还纳了闷了2的32...手机在连入局域网的WiFi的时候,会自动获取IP地址信息到本机,然后可以通过“设置→系统→关于手机→
  • 树莓派开机自动连接WiFi 及树莓派设置固定IP地址 自动驾驶小车系列第二步 内有树莓派连不上WiFi的奇怪bug及解决方案 树莓派开机自动连接WiFi 第一步我们已经通过有线ip ssh连接到树莓派了,开启VNC Viewer, 现在设置...
  • 怎么设置电脑的固定IP地址

    万次阅读 多人点赞 2019-05-20 15:37:06
    我们电脑的IP地址一般来说都是动态的,那么,我们如何通过手动设置电脑的固定IP地址呢?下面我们就以Windows7旗舰版系统为例一起来了解! 一、在屏幕的左下方,单击开始按钮,并选择右侧的控制面板选项,如下图所...
  • android Wifi 设置静态ip地址的方法

    千次阅读 2014-03-14 16:59:01
    调用setIpWithTfiStaticIp()即可为连接好的wifi配置 静态Ip。支持Android4.0以上及以下的版本。... * 设置静态ip地址的方法  */  private boolean setIpWithTfiStaticIp() {  WifiManager wi
  • 怎么设置局域网计算机的IP地址

    千次阅读 2021-07-25 02:19:52
    怎么设置局域网计算机的IP地址生活中,我们已经离不开wifi了,但是我们很少人知道怎么设置局域网计算机的IP地址。那么怎么设置局域网计算机的'IP地址呢?下面就让jy135小编来告诉大家吧,欢迎阅读。1、首先,通过开始...
  • 对芯燁产品下的xp-N160I产品配置WiFi 无线打印。里面有相关的配置程序,打印机驱动以及详细配置说明文档。
  • 情况,wifi已经输入密码正确,但是中间出现灰色的wifi图标,还有一个叹号,说是没有IP地址 解决方法: 1 试过重启 2 试过删掉该网络再重新输入密码 3 试过删掉WiFi一栏 来自百度: 最佳答案: 1、首先打开偏好设置,...
  • 树莓派4B 设置WIFI固定IP+设置网口固定IP 1、修改配置文件 目录:/etc/dhcpcd.conf sudo vim /etc/dhcpcd.conf 2、编辑配置文件 在文件末尾添加 #家里的配置参数,路由器和网关地址不同 SSID WiFi-Name1 ...
  • Mac pro 连上wifi 5G提示无ip地址

    千次阅读 2020-12-17 20:50:25
    Mac pro 连上wifi 5G提示无ip地址问题解决 现象 某品牌双频路由器,2.4G的网能连接上,5G的wifi连接上提示无ip地址。DHCP都是自动分配的,却上不了网。 解决 进入路由器管理后台,将5Gwifi的信道设置成161 ...
  • 设置每台计算机的固定IP方法:1、进入路由器登录界面。...3、首先,我们必须检查现有IP和相应的MAC地址列。单击左侧的“ DHCP服务器”,选择...5、在右侧输入正确的相应MAC和IP地址,然后将“状态”选择为“启用...
  • 无线密码 addresses: [192.168.1.101/24] gateway4: 192.168.1.255 nameservers: addresses: [8.8.8.8,114.114.114.114] 检查语法 sudo netplan generate 使配置生效 sudo netplan apply 查看ip地址 ifconfig 此时就...
  • * 设置WiFi静态ip等配置 * * @param context * @param ip * @param gateWay * @param dns1 * @param dns2 */ public boolean changeWifiConfiguration(Context context,String ssid, String ip, String ...
  • Mac 连接WIFI设置不同IP

    千次阅读 2019-05-13 10:12:04
    场景: 公司用固定IP上网,而家里上网需要自动获取。如何设置? 点击左下角“+”号,添加一个“家WIFI”,点击上面的位置,添加一个位置为“家”。默认都是自动获取IP。...”家WiFi“连接自动获取ip。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,255
精华内容 16,502
关键字:

怎么设置wifiip地址

友情链接: USB系统研究.rar