精华内容
下载资源
问答
  • 我主要目的是让小米手机中的一个应用一直保持wifi连接,具体设置如下: 本人手机型号为小米note,系统为miui开发版: (1)设置->WLAN->高级设置->在休眠状态下保持WLAN网络连接->始终 (2)设置->其他高级...

    我主要目的是让小米手机中的一个应用一直保持wifi连接,具体设置如下:


    本人手机型号为小米note,系统为miui开发版:

    (1)设置->WLAN->高级设置->在休眠状态下保持WLAN网络连接->始终

    (2)设置->其他高级设置->电量与性能->神隐模式->后台功耗控制级别选择关闭   并   应用配置选择目标应用->自定义配置->保持联网

    (3)安全中心->授权管理->ROOT权限管理->添加目标应用

    (4)安全中心->授权管理->自启动管理->添加目标应用

    展开全文
  • Android连接WiFi设置IP为静态IP

    千次阅读 2018-09-03 16:32:36
    设置静态IP需要先忘记WiFi密码再重新连接,会记住是哪个APP连接WiFi public class WifiConnet { private static WifiConnet utils = null; private WifiManager wifiManager; public static int Num = 0; ...

    设置静态IP需要先忘记WiFi密码再重新连接,会记住是哪个APP连接WiFi

    public class WifiConnet {
        private static WifiConnet utils = null;
        private WifiManager wifiManager;
        public static int Num = 0;
        public static String SSID = "";
    
        // 构造函数
        public static synchronized WifiConnet getIntance() {
            if (utils == null){
                utils = new WifiConnector();
            }
            return utils;
        }
    
        public void initWifi(WifiManager wifiManager, String ssid, String password, WifiCipherType type,
                             String ipAddress, String gateway, String dns, ProgressDialogUtil progress){
            LogUtils.printLog("开始连接WiFi");
            this.SSID = ssid;
            this.wifiManager = wifiManager;
            try {
                removeWifiBySsid(wifiManager);
                Thread.sleep(500);
                connect(ssid, password, type, ipAddress, gateway, dns, progress);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    
        /**
         * 忘记某一个wifi密码
         *
         * @param wifiManager
         */
        public static void removeWifiBySsid(WifiManager wifiManager) {
            List<WifiConfiguration> wifiConfigs = wifiManager.getConfiguredNetworks();
            if (wifiConfigs != null){
                for (WifiConfiguration wifiConfig : wifiConfigs) {
    //            LogUtils.printLog("移除WiFi", wifiConfig.SSID);
                    if (wifiConfig != null){
                        wifiManager.disableNetwork(wifiConfig.networkId);
                        wifiManager.disconnect();
                        wifiManager.removeNetwork(wifiConfig.networkId);
                        wifiManager.saveConfiguration();
                    }
                }
            }
        }
    
        //WIFICIPHER_WEP是WEP ,WIFICIPHER_WPA是WPA,WIFICIPHER_NOPASS没有密码
        public enum WifiCipherType {
            WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
        }
    
        Thread thread = null;
        // 提供一个外部接口,传入要连接的无线网
        public void connect(String ssid, String password, WifiCipherType type,
                            String ipAddress, String gateway, String dns, ProgressDialogUtil progress) {
            thread = new Thread(new ConnectRunnable(ssid, password, type, ipAddress, gateway, dns, progress));
            thread.start();
        }
    
        // 查看以前是否也配置过这个网络
        private WifiConfiguration isExsits(String SSID) {
            List<WifiConfiguration> existingConfigs = wifiManager
                    .getConfiguredNetworks();
            if (existingConfigs != null){
                for (WifiConfiguration existingConfig : existingConfigs) {
                    if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
                        return existingConfig;
                    }
                }
            }
            return null;
        }
    
        private WifiConfiguration createWifiInfo(String SSID, String Password,
                                                 WifiCipherType Type) {
            WifiConfiguration config = new WifiConfiguration();
            config.allowedAuthAlgorithms.clear();
            config.allowedGroupCiphers.clear();
            config.allowedKeyManagement.clear();
            config.allowedPairwiseCiphers.clear();
            config.allowedProtocols.clear();
            config.SSID = "\"" + SSID + "\"";
            // nopass
            if (Type == WifiCipherType.WIFICIPHER_NOPASS) {
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            }
            // wep
            if (Type == WifiCipherType.WIFICIPHER_WEP) {
                if (!TextUtils.isEmpty(Password)) {
                    if (isHexWepKey(Password)) {
                        config.wepKeys[0] = Password;
                    } else {
                        config.wepKeys[0] = "\"" + Password + "\"";
                    }
                }
                config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                config.wepTxKeyIndex = 0;
            }
            // wpa
            if (Type == WifiCipherType.WIFICIPHER_WPA) {
                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功能
        private boolean openWifi() {
            boolean bRet = true;
            if (!wifiManager.isWifiEnabled()) {
                bRet = wifiManager.setWifiEnabled(true);
            }
            return bRet;
        }
    
        class ConnectRunnable implements Runnable {
            private String ssid;
    
            private String password;
    
            private WifiCipherType type;
            private ProgressDialogUtil progress;
    
            private String ipAddress;
            private String gateway;
            private String dns;
    
            public ConnectRunnable(String ssid, String password, WifiCipherType type,
                                   String ipAddress, String gateway, String dns,
                                   ProgressDialogUtil progress) {
                this.ssid = ssid;
                this.password = password;
                this.type = type;
                this.progress = progress;
                this.ipAddress = ipAddress;
                this.gateway = gateway;
                this.dns = dns;
            }
    
            @Override
            public void run() {
                try {
                    // 打开wifi
                    openWifi();
                    Thread.sleep(200);
                    // 开启wifi功能需要一段时间(我在手机上测试一般需要1-3秒左右),所以要等到wifi
                    // 状态变成WIFI_STATE_ENABLED的时候才能执行下面的语句
                    while (wifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLING) {
                        try {
                            // 为了避免程序一直while循环,让它睡个100毫秒检测……
                            Thread.sleep(100);
                        } catch (InterruptedException ie) {
                        }
                    }
    
                    WifiConfiguration wifiConfig = createWifiInfo(ssid, password,
                            type);
                    //
                    if (wifiConfig == null) {
                        return;
                    }
    
                    WifiConfiguration tempConfig = isExsits(ssid);
    
                    if (tempConfig != null) {
                        wifiManager.removeNetwork(tempConfig.networkId);
                    }
    
                    int netID = wifiManager.addNetwork(wifiConfig);
                    boolean enabled = wifiManager.enableNetwork(netID, true);
                    boolean connected = wifiManager.reconnect();
                    LogUtils.printLog("wifi链接--enabled=" + enabled + "---connected=" + connected);
                    if (enabled && connected){
                        Num = 0;
                        Thread.sleep(1000);
                        IPUtils.getIntance().connetWifi(wifiManager, wifiConfig, ipAddress, gateway, dns, progress);
                    }else {
                        if (Num < 3){
                            Num ++;
                            connect(ssid, password, type, ipAddress, gateway, dns, progress);
                        }else {
                            if (progress != null){
                                progress.dismiss();
                                LogUtils.printLog("连接WiFi失败");
                            }
                        }
                    }
                } catch (Exception e) {
                    if (progress != null){
                        progress.dismiss();
                    }
                    LogUtils.printLog("连接WiFi失败---Exception--" + e.getMessage());
                    e.printStackTrace();
                }
            }
        }
    
        private static boolean isHexWepKey(String wepKey) {
            final int 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);
        }
    
        private static boolean isHex(String key) {
            for (int i = key.length() - 1; i >= 0; i--) {
                final char c = key.charAt(i);
                if (!(c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a'
                        && c <= 'f')) {
                    return false;
                }
            }
    
            return true;
        }
    
    public void connetWifi(WifiManager mwifiManager, WifiConfiguration mWifiConfiguration, String ipAddress,
                               String gateway, String dns, ProgressDialogUtil progress){
            try {
                    setStaticIpConfiguration(mwifiManager, mWifiConfiguration,
                            InetAddress.getByName(ipAddress), 24,//IP 网络前缀长度24
                            InetAddress.getByName(gateway),//DNS1域名1 gateway
                            InetAddress.getAllByName(dns), progress);//网关
    
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
        }
    
       public void setStaticIpConfiguration(final WifiManager manager,
                                            WifiConfiguration config, InetAddress ipAddress, int prefixLength,
                                            InetAddress gateway, InetAddress[] dns, ProgressDialogUtil progress)
               throws ClassNotFoundException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException,
               NoSuchMethodException, NoSuchFieldException, InstantiationException {
           // First set up IpAssignment to STATIC.
           Object ipAssignment = getEnumValue(
                   "android.net.IpConfiguration$IpAssignment", "STATIC");
           callMethod(config, "setIpAssignment",
                   new String[] { "android.net.IpConfiguration$IpAssignment" },
                   new Object[] { ipAssignment });
    
           // Then set properties in StaticIpConfiguration.
           Object staticIpConfig = newInstance("android.net.StaticIpConfiguration");
    
           Object linkAddress = newInstance("android.net.LinkAddress",
                   new Class[] { InetAddress.class, int.class }, new Object[] {
                           ipAddress, prefixLength });
           setField(staticIpConfig, "ipAddress", linkAddress);
           setField(staticIpConfig, "gateway", gateway);
           ArrayList<Object> aa = (ArrayList<Object>) getField(staticIpConfig,
                   "dnsServers");
           aa.clear();
           for (int i = 0; i < dns.length; i++)
               aa.add(dns[i]);
           callMethod(config, "setStaticIpConfiguration",
                   new String[] { "android.net.StaticIpConfiguration" },
                   new Object[] { staticIpConfig });
           int updateNetwork = manager.updateNetwork(config);
           boolean saveConfiguration = manager.saveConfiguration();
    
           int netId = manager.addNetwork(config);
           manager.disableNetwork(netId);
           boolean  flag  = manager.enableNetwork(netId, true);
    
           if (flag){
               try {
                   Thread.sleep(3000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               LogUtils.printLog("连接WiFi成功");  
           }else {
               isConnetWifi = false;
               LogUtils.printLog("连接WiFi失败 --IP不可用");
           }
       }
    
       private static Object newInstance(String className)
               throws ClassNotFoundException, InstantiationException,
               IllegalAccessException, NoSuchMethodException,
               IllegalArgumentException, InvocationTargetException {
           return newInstance(className, new Class[0], new Object[0]);
       }
    
       @SuppressWarnings({ "rawtypes", "unchecked" })
       private static Object newInstance(String className,
                                         Class[] parameterClasses, Object[] parameterValues)
               throws NoSuchMethodException, InstantiationException,
               IllegalAccessException, IllegalArgumentException,
               InvocationTargetException, ClassNotFoundException {
           Class clz = Class.forName(className);
           Constructor constructor = clz.getConstructor(parameterClasses);
           return constructor.newInstance(parameterValues);
       }
    
       @SuppressWarnings({ "unchecked", "rawtypes" })
       private static Object getEnumValue(String enumClassName, String enumValue)
               throws ClassNotFoundException {
           Class enumClz = (Class) Class.forName(enumClassName);
           return Enum.valueOf(enumClz, enumValue);
       }
    
       private static void setField(Object object, String fieldName, Object value)
               throws IllegalAccessException, IllegalArgumentException,
               NoSuchFieldException {
           Field field = object.getClass().getDeclaredField(fieldName);
           field.set(object, value);
       }
    
       private static Object getField(Object object, String fieldName)
               throws IllegalAccessException, IllegalArgumentException,
               NoSuchFieldException {
           Field field = object.getClass().getDeclaredField(fieldName);
           Object out = field.get(object);
           return out;
       }
    
       @SuppressWarnings("rawtypes")
       private static void callMethod(Object object, String methodName,
                                      String[] parameterTypes, Object[] parameterValues)
               throws ClassNotFoundException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException,
               NoSuchMethodException {
           Class[] parameterClasses = new Class[parameterTypes.length];
           for (int i = 0; i < parameterTypes.length; i++)
               parameterClasses[i] = Class.forName(parameterTypes[i]);
    
           Method method = object.getClass().getDeclaredMethod(methodName,
                   parameterClasses);
           method.invoke(object, parameterValues);
       }
    
       public String intToIp(int ipAddress) {
           return ((ipAddress & 0xff) + "." + (ipAddress >> 8 & 0xff) + "."
                   + (ipAddress >> 16 & 0xff) + "." + (ipAddress >> 24 & 0xff));
    
       }
    }
    展开全文
  • Ubuntu20.04服务器连接WIFI设置

    万次阅读 2020-08-05 16:01:17
    Ubuntu20.04服务器连接WIFI设置 最近利用家里的旧电脑搞了一个Ubuntu服务器,结果在连接无线网络时,配置一直有问题,通过查找资料,最后配置成功,特此记录。 安装系统:ubuntu-20.04-live-server-amd64 目录...

    Ubuntu20.04服务器连接WIFI设置

    最近利用家里的旧电脑搞了一个Ubuntu服务器,结果在连接无线网络时,配置一直有问题,通过查找资料,最后配置成功,特此记录。

    • 安装系统:ubuntu-20.04-live-server-amd64

    1、查看无线网卡名字

    ifconfig -a
    

    或者用

    ip a
    

    2、安装WPA2加密工具

    sudo apt-get install wpasupplicant
    
    sudo apt-get install network-manager
    

    3、修改配置文件

    • 进入配置文件所在的文件夹
    cd /etc/netplan/
    
    sudo su     
    

    备注:文件一定要在root权限下打开,不然保存不了。

    • 查看文件
    ls
    
    • 打开文件
    vi 你的文件名
    
    • 操作过程:
      在这里插入图片描述
    • 在打开的文件中添加如下
    renderer: NetworkManager
    wifis:
      wlp2s0:
        dhcp4: true
        access-points:
          "你的ssid":
            password: "你的密码"
    
    • 配置后的文件图:
      在这里插入图片描述

    4、重启服务器

    我直接通过重启服务器就OK了,也可以用一下命令。

    sudo netplan generate
    
    sudo netplan apply
    

    参考链接

    https://netplan.io/reference
    https://blog.csdn.net/huning188/article/details/85225258

    展开全文
  • 首先如果已经连接WiFi了,但是提示“不可上网”,那就把WiFi断开重新连接下。 不行的话就试试下面的办法 一、配置注册表 windows键加R键打开以下界面,输入regedit image.png ...

    fiddler抓包,设置代理后,会出现手机连不上网的情况,针对这个情况处理方式为:

    首先如果已经连接上WiFi了,但是提示“不可上网”,那就把WiFi断开重新连接下。

    不行的话就试试下面的办法

    一、配置注册表

    windows键加R键打开以下界面,输入regedit


     
    image.png

    打开注册表,在HKEY_CURRENT_USER\SOFTWARE\Microsoft\Fiddler2下创建一个DWORD,值设置为80(十进制)


     
    image.png

    二、编写FiddlerScript rule

     
    image.png

    Ctrl+F查找到OnBeforeRequest方法


     
    image.png

    在此方法下加入如下代码

            if (oSession.host.toLowerCase() == "webserver:8888") 
            {
                oSession.host = "webserver:80";
    
            }
    
     
    image.png

    三、关闭防火墙

     
    image.png

    四、重启fiddler




    转载于:https://www.cnblogs.com/Susie-/p/11089241.html

    展开全文
  • wifi连接源码

    2018-05-15 19:38:54
    这个是Android简单的WIFI连接源码,之前一直找不到,现在找到了!所以推荐使用! WIFI连接源码
  • arduino+ESP8266模块使用AT指令设置wifi

    千次阅读 2020-11-30 06:29:33
    本文使用ESP8266模块结合arduino设置wifi通信 设备 ESP8066-01模块 ESP8266 是一款超低功耗的 UART-WiFi 透传模块,拥有业内极富竞争力的封装尺寸和超低能耗 技术,专为移动设备和物联网应用设计,可将用户的...
  • 今天刚打开电脑发现,wifi图标一直显示正在连接,但是就是没有连接上,网上也看不到类似的问题,最后求助万能的某宝,维修ubuntu的店家只说让我换ubuntu内核,此外,看到了有个人遇到了类似的问题,他是误删内核,...
  • 树莓派WIFI网络设置与SSH远程连接(ubuntu server) 下面的操作针对新烧录的SD卡,需要有显示器和键盘。 一般把新卡插到树莓派上,连接好键盘和显示器,然后供电,pwr指示灯会一直常亮红灯,表示供电正常;act灯会...
  • 最近一直在想,有没有什么方法可以自动设置安卓手机的wifi代理,曾经想通过修改安卓系统配置文件的方式来修改但是没有找到解决方案。最后决定针对自己的手机进行私人订制,缺点是只能针对固定机型进行设置,不过优点...
  • Macbook Pro睡眠唤醒以后,WIFI用不了,一直在转圈圈。 macOS Mojave v10.14.4 解决办法 最有效的办法:重启 不想重启的话,请打开命令行(Finder > 应用程序 > 实用工具 > 终端.app),然后输入...
  • @[TOC]电脑无法连接WiFi一直显示无法连接此网络 一般来说,Windows无法连接到这个网络,最可能是由于密码错误;还有一种情况则是由于无线网卡驱动不稳定导致的,这种情况常常是在刚刚升级系统之后就出现了无法连接...
  • Mac状态栏wifi图标一直闪烁重复连接但是网络正常的解决办法
  • 2、树莓派设置连接WiFi,开启VNC等等

    千次阅读 多人点赞 2020-07-17 10:41:07
    文章目录2、树莓派设置连接WiFi,开启VNC等等2.1 设置连接WiFi,使用VNC显示2.1.1 手机开启WiFi,树莓派连接2.1.2电脑开启WiFi,树莓派连接(如果没有路由器,建议使用电脑开WiFi,方便查看树莓派IP)2.1.3 树莓派...
  • 问题 解决办法 点击状态栏的WiFi图标,点击最下面的按钮“打开网络偏好设置” 在上面位置的”位置“,选择“编辑位置” 添加一个位置,名字随意,‘完成...Macbook已经网络连接成功,但是图标一直在闪烁,看...
  • 1、手机连接电脑,打开usb调试。电脑打开adb.exe,cmd命令进入在adb.exe所在路径下,输入如下命令: ①adb devices; ②adb shell ③settings put global captive_portal_detection_enabled 03  ④重启手机
  • 360wifi一直在启用中

    2018-11-08 15:34:42
    其实所有的随身wifi都要有三个服务支持。 Internet Connection Sharing (ICS)  WLAN AutoConfig Wired AutoConfig 这三个服务如果第一个没有打开,是无法手动启动的,它是要靠你对本地网卡的共享才能启动的 ...
  • 解决 MacBook Pro 17 wifi一直连接不上的问题

    万次阅读 热门讨论 2017-09-24 09:11:29
    刚买的17年6月的pro,开始用的还好好的,最近一个多月发现wifi很不稳定,经常连接不上,开始以为是信号强弱问题,就把电脑放到离路由器近一点的地方,结果发现还是不行,这让我很头疼,没办法,只能用外接usb共享...
  • esp8266的WIFI设置

    千次阅读 2020-01-08 13:36:46
    WiFi的STA和AP模式指什么? AP,也就是无线接入点,是一个无线网络的创建者,是网络的中心节点。一般家庭或办公室使用的无线路由器就一个AP。 STA站点,每一个连接到无线网络中的终端(如笔记本电脑、PDA及...
  • 电脑连接公司中国电信爱wifi反复验证无法连接wifi最近遇到一个有意思的问题解决方案: 最近遇到一个有意思的问题 情况描述: 之前电脑只需要输入手机号实现wifi登录(不需要密码),过了一段时间之后,自动连接时...
  • 无线网卡驱动报错,无法连接WIFIWIFI信号不停闪断 1.查看无线网卡名称 2.win+x 打开设备管理器 3.找到无线网卡,卸载掉 4.查看直接卸载设备后的日志记录 5.找到品牌笔记本的售后支持,重新下载驱动,然后...
  • Wifi提示正在连接,但是一直连接不上。 换了其他的一个AP,也提示连接不上。 分析: 根据WIFI连接过程可知,显示正在连接时dhcp client会从路由器那边获取ip address. 正常Log: 06-13 14:56:23.697 583 13....
  • 在重装完系统后出现了这个问题,但是网上大部分的文章写得都是修改手机WIFI为静态,并手动填入IP地址,试了一下发现并没有用,于是乎上联想驱动官网(我是联想的笔记本),重新下载网卡驱动,重装发发现好了,希望对...
  • 但是,人们一直在报告的许多问题都是错误,而这些错误只是关于错误应如何工作的其他观点,并且不在原始用例之内。 不幸的是,我没有个人资源可以帮助您解决这些问题。 如果其他人愿意成为贡献者,我将不胜感激。 在...
  • * 设置WiFi静态ip等配置 * * @param context * @param ip * @param gateWay * @param dns1 * @param dns2 */ public boolean changeWifiConfiguration(Context context,String ssid, String ip, String ...
  • 一直很喜欢记录和收集数据以供以后分析,所以我想要一台方便使用的小型设备,而不是通过笔记本电脑,gps,teather或4g互联网连接进行“战争驾驶”设置,很快。 我花了很长时间才决定接受一些接受AVR C / C ++的...
  • 电脑休眠启动后,airportd 这个进程唤醒存在问题,导致 wifi 连接是灰色的,鼠标去点直接转圈卡死了,我们只要把这个进程杀掉,他马上重新起个新的就 ok 了。 先查询出进程号 ps -e | grep "airportd", 然后通过 ...
  • 最近在使用树莓派时,不知什么原因连接Wifi之后ip地址要发生变化,之前都没有出现这种情况,导致每次远程连接很麻烦,所以只好对其进行设置静态的ip地址。 更改wifi设置 在没有图形画界面时,可以直接通过以下命令...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,548
精华内容 8,619
关键字:

如何设置wifi一直连接