精华内容
下载资源
问答
  • 以太网设置ip地址
    千次阅读
    2022-02-22 11:07:56

    前提

    只有系统APP才具备此功能,即APP的uid必须使用系统用户,APK必须进行系统签名

    这个不懂的请翻阅本专栏前面的博客

    核心代码

    由于以太网相关接口是隐藏的,只能通过反射调用

    
    	package com.android.commons.framework;
    	
    	import android.content.ContentResolver;
    	import android.content.Context;
    	import android.provider.Settings;
    	
    	import com.easing.commons.android.code.Console;
    	
    	import java.lang.reflect.Constructor;
    	import java.lang.reflect.Field;
    	import java.lang.reflect.Method;
    	import java.net.InetAddress;
    	import java.util.LinkedHashMap;
    	import java.util.List;
    	import java.util.Map;
    	
    	import lombok.SneakyThrows;
    	
    	@SuppressWarnings("all")
    	public class EthernetHandlerInternal {
    	
    	    //设置以太网动态IP
    	    public static boolean setDynamicIp(Context context) {
    	        try {
    	            //创建EthernetManager实例
    	            Class ethernetManagerClass = Class.forName("android.net.EthernetManager");
    	            Object ethernetManager = context.getSystemService("ethernet");
    	            //创建IpConfiguration
    	            Class ipConfigurationClass = Class.forName("android.net.IpConfiguration");
    	            Object ipConfiguration = ipConfigurationClass.newInstance();
    	            //获取所有枚举常量
    	            Map<String, Object> enumMap = getIpConfigurationEnumMap(ipConfigurationClass);
    	            //设置ipAssignment
    	            Field ipAssignment = ipConfigurationClass.getField("ipAssignment");
    	            ipAssignment.set(ipConfiguration, enumMap.get("IpAssignment.DHCP"));
    	            //设置proxySettings
    	            Field proxySettings = ipConfigurationClass.getField("proxySettings");
    	            proxySettings.set(ipConfiguration, enumMap.get("ProxySettings.NONE"));
    	            //设置Configuration
    	            Method setConfigurationMethod = ethernetManagerClass.getDeclaredMethod("setConfiguration", ipConfiguration.getClass());
    	            setConfigurationMethod.invoke(ethernetManager, ipConfiguration);
    	            return true;
    	        } catch (Throwable e) {
    	            Console.error(e);
    	            return false;
    	        }
    	    }
    	
    	    //设置以太网静态IP
    	    public static boolean setStaticIp(Context context, String address, String mask, String gateway, String dns) {
    	        try {
    	            //创建EthernetManager实例
    	            Class ethernetManagerClass = Class.forName("android.net.EthernetManager");
    	            Object ethernetManager = context.getSystemService("ethernet");
    	            //设置IpConfiguration
    	            Object staticIpConfiguration = newStaticIpConfiguration(address, gateway, mask, dns);
    	            Object ipConfiguration = newIpConfiguration(staticIpConfiguration);
    	            //保存IP设置
    	            saveIpSettings(context, address, gateway, mask, dns);
    	            //设置Configuration
    	            Method setConfigurationMethod = ethernetManagerClass.getDeclaredMethod("setConfiguration", ipConfiguration.getClass());
    	            setConfigurationMethod.invoke(ethernetManager, ipConfiguration);
    	            return true;
    	        } catch (Throwable e) {
    	            Console.error(e);
    	            return false;
    	        }
    	    }
    	
    	    //创建LinkAddress
    	    @SneakyThrows
    	    protected static Object newLinkAddress(String address, String mask) {
    	        Class linkAddressClass = Class.forName("android.net.LinkAddress");
    	        Constructor constructor = linkAddressClass.getDeclaredConstructor(InetAddress.class, int.class);
    	        return constructor.newInstance(InetAddress.getByName(address), getPrefixLength(mask));
    	    }
    	
    	
    	    //创建StaticIpConfiguration
    	    @SneakyThrows
    	    protected static Object newStaticIpConfiguration(String address, String gateway, String mask, String dns) {
    	        //创建StaticIpConfiguration
    	        Class clazz = Class.forName("android.net.StaticIpConfiguration");
    	        Object staticIpConfiguration = clazz.newInstance();
    	        //设置IP
    	        Field addressField = clazz.getField("ipAddress");
    	        addressField.set(staticIpConfiguration, newLinkAddress(address, mask));
    	        //设置网关
    	        Field gatewayField = clazz.getField("gateway");
    	        gatewayField.set(staticIpConfiguration, InetAddress.getByName(gateway));
    	        //设置子网掩码
    	        Field domainField = clazz.getField("domains");
    	        domainField.set(staticIpConfiguration, mask);
    	        //设置DNS
    	        Field dnsField = clazz.getField("dnsServers");
    	        List<InetAddress> dnsList = (List) dnsField.get(staticIpConfiguration);
    	        dnsList.add(InetAddress.getByName(dns));
    	        return staticIpConfiguration;
    	    }
    	
    	
    	    //创建IpConfiguration
    	    @SneakyThrows
    	    protected static Object newIpConfiguration(Object staticIpConfiguration) {
    	        //创建IpConfiguration
    	        Class clazz = Class.forName("android.net.IpConfiguration");
    	        Object ipConfiguration = clazz.newInstance();
    	        //设置staticIpConfiguration
    	        Field staticIpConfigurationField = clazz.getField("staticIpConfiguration");
    	        staticIpConfigurationField.set(ipConfiguration, staticIpConfiguration);
    	        Map<String, Object> ipConfigurationEnum = getIpConfigurationEnumMap(clazz);
    	        //设置ipAssignment
    	        Field ipAssignment = clazz.getField("ipAssignment");
    	        ipAssignment.set(ipConfiguration, ipConfigurationEnum.get("IpAssignment.STATIC"));
    	        //设置proxySettings
    	        Field proxySettings = clazz.getField("proxySettings");
    	        proxySettings.set(ipConfiguration, ipConfigurationEnum.get("ProxySettings.STATIC"));
    	        return ipConfiguration;
    	    }
    	
    	    //获取IpConfiguration类中的所有枚举常量
    	    protected static Map<String, Object> getIpConfigurationEnumMap(Class ipConfigurationClass) {
    	        Map<String, Object> enumMap = new LinkedHashMap();
    	        Class[] classes = ipConfigurationClass.getDeclaredClasses();
    	        for (Class clazz : classes) {
    	            Object[] enumConstants = clazz.getEnumConstants();
    	            if (enumConstants == null)
    	                continue;
    	            for (Object constant : enumConstants)
    	                enumMap.put(clazz.getSimpleName() + "." + constant.toString(), constant);
    	        }
    	        return enumMap;
    	    }
    	
    	    //保存IP设置
    	    protected static void saveIpSettings(Context context, String address, String gateway, String mask, String dns) {
    	        ContentResolver contentResolver = context.getContentResolver();
    	        Settings.Global.putString(contentResolver, "ethernet_static_ip", address);
    	        Settings.Global.putString(contentResolver, "ethernet_static_mask", mask);
    	        Settings.Global.putString(contentResolver, "ethernet_static_gateway", gateway);
    	        Settings.Global.putString(contentResolver, "ethernet_static_dns1", dns);
    	    }
    	
    	    //根据子网掩码,自动计算前缀长度
    	    protected static int getPrefixLength(String mask) {
    	        String[] strs = mask.split("\\.");
    	        int count = 0;
    	        for (String str : strs)
    	            if (str.equals("255"))
    	                ++count;
    	        return count * 8;
    	    }
    	}
    
    
    
    
    
    	package com.android.commons.framework;
    	
    	import com.easing.commons.android.app.CommonApplication;
    	import com.easing.commons.android.code.Console;
    	
    	import lombok.SneakyThrows;
    	
    	@SuppressWarnings("all")
    	public class EthernetHandler {
    	
    	    //设置动态IP
    	    @SneakyThrows
    	    public static boolean setDynamicIP() {
    	        try {
    	            boolean ret = EthernetHandlerInternal.setDynamicIp(CommonApplication.ctx);
    	            return ret;
    	        } catch (Throwable e) {
    	            Console.error(e);
    	            return false;
    	        }
    	    }
    	
    	    //设置以太网静态IP
    	    //子网掩码和DNS使用默认值
    	    @SneakyThrows
    	    public static boolean setStaticIP(String address, String gateway) {
    	        try {
    	            boolean ret = EthernetHandlerInternal.setStaticIp(CommonApplication.ctx, address, "255.255.255.0", gateway, "119.29.29.29");
    	            return ret;
    	        } catch (Throwable e) {
    	            Console.error(e);
    	            return false;
    	        }
    	    }
    	}
    
    
    
    更多相关内容
  • Android设置静态IP

    以下转载内容亲自测试示例代码有效。提几个注意事项:

    使用AS版本( Android Studio 4.1.2)

    新建一个helloword工程,然后将实例中的代码拷贝到工程。然后将framework.jar加入到工程。

    1.如图右键framework.jar,选择“Add As Library”:

    2.在Module下面的build.gradle里找到defaultConfi加入multiDexEnabled = true;

    3.加上系统签名, 

     

    platform.keystore签名文件,可以通过源码中的platform.pk8/platform.x509.pem转换处理,网上有有脚本工具keytool-importkeypair。

    keytool-importkeypair 使用_ngyzqf的博客-CSDN博客_keytool-importkeypair

     

    [转]android:APP设置以太网静态IP_简要步骤 - caesura_k - 博客园

    手持机开机默认为手动获取动态IP,每次都要重新手动设置成静态获取IP,客户觉得有点麻烦,想改成可以自动设置。

    于是就在网上找了个能用的示例代码,于是就有了这篇博文。

    手持机系统为android 7.0

    1、示例代码: staticIp: 以太网固定ip

      经笔者多方查找测试过几个代码之后,发现以上代码经过以下几个步骤后,可以运行在android7.0系统的手机上;

    2、设置静态IP流程: AndroidThings设置以太网卡静态ip_weixin_41722842的博客-CSDN博客_android 设置网卡ip

      主要步骤大致上和这篇博文差不多,先有个轮廓;

    3、在<manifest>标签内加上  android:sharedUserId="android.uid.system"   使其成为系统应用得以调用API隐藏方法

      使用压缩软件打开apk,进入META-INF目录下,删除应用程序的3个签名文件:CERT.RSA  ; CERT.SF ; MANIFEST.MT

      将app-debug.apk和以下三个文件放在一个文件夹下
      signapk.jar
      platform.x509.pem 
      platform.pk8  

      shift+右键进入cmd中,用以下命令打包签名:
      java -jar signapk.jar platform.x509.pem platform.pk8 app-debug.apk.apk staticip.apk

    4、代码分析和调用的系统源码解析的博文参考:  Android 以太网/有线网Ethernet功能开发_Purple7826的博客-CSDN博客_android 以太网

      十分详细地讲解了class.jar文件内调用的隐藏方法的实现函数,以及程序源码的解析

    /******以下为补充说明,仅仅是为了方便理解;******/

    5、class.jar(位于framework框架下)

      Android 有两种类型的 API 不能通过 SDK 访问。

      一种是在 com.android.internal 包中的 API,称之为 internal API。

      另一种是被标记为 @hide 属性的类和方法,这是一组小级别的被隐藏的 API,称之为 hidden API。

      当使用 Android SDK 进行开发的时候,应用默认引用了SDK自带的 android.jar,

      它位于 SDK路径\platforms\android-X 目录下(X 代表 API 级别),

      默认移除了所有的被@hide标识的方法或者类以及 internal 包下的类。

      class.jar 和 android.jar 本质上是一样的代码,但是没有移除 internal API 和 hidden API。

      5.1、调用framework接口有两种方法:

        5.1.1、反射调用

        5.1.2、直接把framework的jar放在app里面,让app直接调用

      5.2、jar包所在位置:   

        这些方法或常量的前面的注释处加了一个@hide,另外还有MTK,高通等在Framework里定义的一些类肯定是找不到的,

        所以就通过编译系统源码,把class.jar拷贝出来,放入工程的Module里。(网上找或者找linux开发拿)

        (以MTK为例,如果编译debug版本,直接在out/target/product/projectXX/system/framework下面拷出来,)

        (如果是user版本,目录为out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/classes.jar或是classes_full_debug.jar)

      5.3、Android Studio 加入jar包的几个博文,看起来具有可执行性,先放着吧,我也没用过。

         Android Studio 优先源码编译的framework.jar(android.jar)_leitongzhuang1的博客-CSDN博客_android.jar  

        android系统APP开发,优先使用源码编译的framework jar包_星极科技的博客-CSDN博客

        android studio中导入源码编译的framework.jar_abs625的博客-CSDN博客

      5.4、Android的四层架构:Linux内核层,核心库层,应用框架层(framework),应用层

        Framework提供API给上层重复调用,在这层里定义的API都是用Java语言编写,同时也包含了JNI的方法、

    展开全文
  • Android 9.0 以太网静态IP设置

    千次阅读 2020-09-11 10:42:15
    吐槽一下,官方貌似没有以太网和WiFi的配置流程,网络设置这部分主要借鉴的是Settings中的内容 以太网配置需要使用EthernetManager类,我们看下这个类的特点: /** * A class representing the IP configuration ...

    吐槽一下,官方貌似没有以太网和WiFi的配置流程,网络设置这部分主要借鉴的是Settings中的内容

    以太网配置需要使用EthernetManager类,我们看下这个类的特点:

    /**
     * A class representing the IP configuration of the Ethernet network.
     *
     * @hide
     */
    @SystemApi
    @TestApi
    @SystemService(Context.ETHERNET_SERVICE)
    public class EthernetManager
    

    这个类对普通应用并不开放,需要一些特别的权限

    环境准备工作

    1. 进行静态网络设置需要先把app配置为系统级
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.xxxx.xxxx"
        android:sharedUserId="android.uid.system">
    
    1. 由于使用到了EthernetManager类,这个类Android定义为隐藏的,所以我们需要依赖一个framework.jar
    compileOnly files('frameworks.jar')
    

    compileOnly即可

    • 此时在AS中还是会显示找不到EthernetManager
    • AS管理的每个module中有一个.yml文件
    • .yml文件中的framework.jar的顺序放到最前面就可以了

    像这样

        <orderEntry type="sourceFolder" forTests="false" />
        <orderEntry type="library" name="Gradle: ./../../fm-libs/ironman_frameworks.jar" level="project" />
        //......
        <orderEntry type="module" module-name="factory_test_interf" />
        <orderEntry type="jdk" jdkName="Android API 29 Platform" jdkType="Android SDK" />
    

    这样,AS就会优先查找framework.jar中的类。

    如果启动编译,应该还会出现找不到类的情况,此时我们还需要在Projectbuild.gradle中进行如下配置:

    allprojects {
        repositories {
            //......
        }
        gradle.projectsEvaluated {
            tasks.withType(JavaCompile) {
                //......
                options.compilerArgs.add('-Xbootclasspath/p:/Users/lijie/fm-libs/frameworks.jar')
            }
        }
    }
    

    这样编译时应该就会查找framework.jar中的类了

    代码开始

    1. 一个接口类NetworkConfiguration,从Settings中借鉴过来的。
    import android.net.IpConfiguration;
    import android.net.wifi.WifiManager;
    /**
     * Provide unified interface for network configuration that works for both Wi-Fi and Ethernet.
     */
    public interface NetworkConfiguration {
        /**
         * Set IpConfiguration
         *
         * @param configuration IpConfiguration to set
         */
        public void setIpConfiguration(IpConfiguration configuration);
        /**
         * Get IpConfiguration
         *
         * @return IpConfiguration
         */
        public IpConfiguration getIpConfiguration();
        /**
         * Save current network configuration to system
         *
         * @param listener listener to notify the result
         */
        public void save(WifiManager.ActionListener listener);
        /**
         * Get printable name for this network.
         *
         * @return Printable name
         */
        public String getPrintableName();
    }
    
    1. 以太网配置实现类EthernetConfig,实现了NetworkConfiguration接口
    import android.content.Context;
    import android.net.EthernetManager;
    import android.net.IpConfiguration;
    import android.net.wifi.WifiManager;
    import android.os.Looper;
    /**
     * Ethernet configuration that implements NetworkConfiguration.
     */
    class EthernetConfig implements NetworkConfiguration {
        private EthernetManager mEthernetManager;
        private IpConfiguration mIpConfiguration;
        private String mName;
        private String mInterfaceName;
        EthernetConfig(Context context) {
            if (Thread.currentThread().getId() != context.getMainLooper().getThread().getId()) {
                // 由于 EthernetManager 在初始化的时候会启动一个Handler
                // 如果不是在主线程中,并且没有调用Looper.prepare(),会出现异常
                if (Looper.myLooper() == null) {
                    Looper.prepare();
                }
            }
            mEthernetManager = (EthernetManager) context.getSystemService(Context.ETHERNET_SERVICE);
            mIpConfiguration = new IpConfiguration();
            mName = "Ethernet";
        }
        @Override
        public IpConfiguration getIpConfiguration() {
            return mIpConfiguration;
        }
        @Override
        public void setIpConfiguration(IpConfiguration configuration) {
            mIpConfiguration = configuration;
        }
        @Override
        public void save(WifiManager.ActionListener listener) {
            if (mInterfaceName != null) {
                mEthernetManager.setConfiguration(mInterfaceName, mIpConfiguration);
            }
    
            if (listener != null) {
                listener.onSuccess();
            }
        }
        /**
         * Load IpConfiguration from system.
         */
        public void load() {
            String[] ifaces = mEthernetManager.getAvailableInterfaces();
            if (ifaces.length > 0) {
                mInterfaceName = ifaces[0];
                mIpConfiguration = mEthernetManager.getConfiguration(mInterfaceName);
            }
        }
    
        @Override
        public String getPrintableName() {
            return mName;
        }
    }
    
    1. 配置流程工具类EthernetUtils,注释很详细了哈
    import android.content.Context;
    import android.net.IpConfiguration;
    import android.net.LinkAddress;
    import android.net.StaticIpConfiguration;
    import android.net.wifi.WifiManager;
    import android.text.TextUtils;
    import android.util.Log;
    
    import java.net.Inet4Address;
    import java.util.concurrent.CountDownLatch;
    
    import static com.fengmi.factory_test_interf.sdk_utils.NetworkUtil.netMask2Length;
    
    public final class EthernetUtils {
        private static final String TAG = "EthernetUtils";
        private static volatile boolean res = false;
        private EthernetUtils() {
        }
        /**
         * 设置 IP 获取方式为 DHCP 动态分配
         *
         * @param context 上下文对象
         * @return 配置是否保存成功
         */
        public static boolean saveDHCPEthernetConfig(Context context) {
            res = false;
            //1. 创建一个EthernetConfig对象
            EthernetConfig netConfig = new EthernetConfig(context);
            //2. load 加载系统配置到对象中
            netConfig.load();
            //3. 设置IP获取方式为 DHCP
            netConfig.getIpConfiguration().setIpAssignment(IpConfiguration.IpAssignment.DHCP);
            //4. 设置一个等待latch
            CountDownLatch latch = new CountDownLatch(1);
            //5. 保存配置到系统,并监听是否设置成功
            netConfig.save(new WifiManager.ActionListener() {
                @Override
                public void onSuccess() {
                    Log.d(TAG, "set IP assignment DHCP success");
                    res = true;
                    latch.countDown();
                }
    
                @Override
                public void onFailure(int i) {
                    Log.d(TAG, "set IP assignment DHCP failed, code=" + i);
                    res = false;
                    latch.countDown();
                }
            });
    
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return res;
        }
        /**
         * 设置以太网静态IP<p/>
         * 网上都没能找到正规的流程说明,从Settings中借鉴来的代码<p/>
         * 人性化的我添加了注释,吼吼吼<p/>
         * 网络配置相关的科普链接{https://blog.51cto.com/zhoutao/93629}
         *
         * @param context   上下文
         * @param ipAddress ip 地址,格式为:10.10.10.10
         * @param netMask   子网掩码,格式为:255.255.255.0
         * @param gateway   默认网关,格式为:10.10.10.1
         * @param dns       dns服务地址,google 提供了两个免费的
         * @return 配置是否成功
         */
        public static boolean saveStaticEthernetConfig(Context context,
                                                       String ipAddress,
                                                       String netMask,
                                                       String gateway,
                                                       String dns) {
            res = false;
            // 创建一个 StaticIpConfiguration 对象,用来保存静态IP相关的信息
            StaticIpConfiguration staticConfig = new StaticIpConfiguration();
            // 创建一个EthernetConfig对象
            EthernetConfig netConfig = new EthernetConfig(context);
            // load 加载系统配置到对象中
            netConfig.load();
            // 关联配置信息对象
            netConfig.getIpConfiguration().setStaticIpConfiguration(staticConfig);
    
            // 针对 IP地址 做一些异常判断
            if (TextUtils.isEmpty(ipAddress)) {
                Log.i(TAG, "empty ipv4 addr");
                return false;
            }
    
            // 根据子网掩码计算Prefix Length,看看究竟掩护了多少位
            // 其实就是计算子网掩码比特位为1的位数。
            int networkPrefixLength;
            try {
                networkPrefixLength = netMask2Length(netMask);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
            //根据 IP 和 子网掩码的Prefix Length信息 生成 ipAddress 对象
            Inet4Address inetAddr;
            try {
                // 将IP 转化为 Inet4Address 对象
                inetAddr = (Inet4Address) android.net.NetworkUtils.numericToInetAddress(ipAddress);
                // 将 `Inet4Address 对象` 和 `子网掩码的Prefix Length信息` 打包成LinkAddress对象
                // 赋值给 StaticIpConfiguration 对象中的 ipAddress
                staticConfig.ipAddress = new LinkAddress(inetAddr, networkPrefixLength);
            } catch (IllegalArgumentException | ClassCastException e) {
                e.printStackTrace();
                return false;
            }
    
            // 将网关信息设置给 StaticIpConfiguration 对象中的 gateway
            if (!TextUtils.isEmpty(gateway)) {
                try {
                    staticConfig.gateway =
                            android.net.NetworkUtils.numericToInetAddress(gateway);
                } catch (IllegalArgumentException | ClassCastException e) {
                    e.printStackTrace();
                    return false;
                }
            }
    
            //将 dns 添加到 StaticIpConfiguration 对象的 DNS 服务列表中
            if (!TextUtils.isEmpty(dns)) {
                try {
                    staticConfig.dnsServers.add(
                            android.net.NetworkUtils.numericToInetAddress(dns));
                } catch (IllegalArgumentException | ClassCastException e) {
                    e.printStackTrace();
                    return false;
                }
            }
    
            // 添加两个Google提供的免费DNS服务器的IP地址
            try {
                staticConfig.dnsServers.add(
                        android.net.NetworkUtils.numericToInetAddress("8.8.8.8"));
                staticConfig.dnsServers.add(
                        android.net.NetworkUtils.numericToInetAddress("8.8.4.4"));
            } catch (IllegalArgumentException | ClassCastException e) {
                e.printStackTrace();
                return false;
            }
    
            // 设置 IpAssignment 为 Static 模式
            netConfig.getIpConfiguration().setIpAssignment(IpConfiguration.IpAssignment.STATIC);
            // 设置一个等待latch
            CountDownLatch latch = new CountDownLatch(1);
            // 保存配置信息到系统,并监听设置结果
            netConfig.save(new WifiManager.ActionListener() {
                @Override
                public void onSuccess() {
                    Log.d(TAG, "set static IP assignment success");
                    res = true;
                    latch.countDown();
                }
    
                @Override
                public void onFailure(int i) {
                    Log.d(TAG, "set static IP assignment failed, code=" + i);
                    res = false;
                    latch.countDown();
                }
            });
    
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return res;
        }
        /**
         * 计算子网掩码的 Prefix Length
         *
         * @param netMask 子网掩码
         * @return Prefix Length
         */
        private static int netMask2Length(String netMask) {
            byte[] array = netMask2ByteArray(netMask);
            if (array == null) {
                return -1;
            }
            int i = array[0] << 24 | array[1] << 16 | array[2] << 8 | array[3];
            int j = 32;
            int k = 1;
            while (((i & k) == 0) && (k != 0)) {
                k <<= 1;
                j--;
            }
            return j;
        }
        /**
         * 将子网掩码转化为字节数组
         *
         * @param str 子网掩码
         * @return 字符数组,格式不正确返回null
         */
        private static byte[] netMask2ByteArray(String str) {
            if (str == null || str.length() == 0) {
                return null;
            }
            StringTokenizer tokenizer = new StringTokenizer(str, ".");
            if (tokenizer.countTokens() != 4) {
                return null;
            }
            byte[] arrayOfByte = new byte[4];
            for (int i = 0; tokenizer.hasMoreTokens(); i++) {
                int j = Integer.parseInt(tokenizer.nextToken());
                arrayOfByte[i] = (byte) j;
            }
            return arrayOfByte;
        }
    }
    
    

    总结

    想要完成这个功能

    • EthernetManager这种隐藏类的导入上需要费些时间
    • 熟悉网络配置相关的名词需要些时间
      • IP 地址
      • 子网掩码
      • 默认网关
      • dns
    • 熟悉配置流程需要些时间
      • 首先加载系统网络配置
      • 然后设置对应的网络参数
      • 然后设置不同的类型
        • DHCP
        • STATIC
      • 最后保存配置

    实测可用,WiFi的实现和这个流程也差不多,功能虽然已经完成,但是在流程上还有些疑惑,就不先贴出来了,嘻嘻!

    展开全文
  • android app 设置以太网静态Ip

    千次阅读 2020-07-21 16:29:05
    公司是做工控和楼宇智能方面产品,使用的设备有rk和全志平台,运行的是android操作系统,部分场景需要设置有线网络的静态Ip。所以针对这一需求做了如下工作,并以此文作为总结。 遇到的问题 工作前也有百度过相关...

    写文目的

    • 公司是做工控和楼宇智能方面产品,使用的设备有rk和全志平台,
      运行的是android操作系统,部分场景需要设置有线网络的静态Ip。
      所以针对这一需求做了如下工作,并以此文作为总结。

    遇到的问题

    • 之前也有百度过相关方案,但大部分使用的是busybox ifconfig来设置,而这种方式有很多弊端,如设置的app必须拥有root权限、不能实时切换static和dhcp、重启后设置的就不生效、不能通过系统的settings参看设置的状态。经过一番折腾后发现为了解决这些问题必须从android的系统应用settings apk入手!
    • 注意:若手上没有android系统源码,那这个解决方案就不适用哦。

    实现思路

    • 在settings中注册一个静态广播,广播的接收函数中完成ip的设置。当用户层要设置ip时,只需发送广播给settings即可。

    用户app设置样例

    Intent intent = new Intent();
            intent.putExtra("netMode", "static");
            intent.putExtra("ipaddr", "192.168.1.223");
            intent.putExtra("netMask", "255.255.255.0");
            intent.putExtra("gateway", "192.168.1.198");
            intent.putExtra("dns1", "192.168.1.198");
            intent.putExtra("dns2", "8.8.8.8");
            intent.setAction("android.net.action.ETHERNET_IP_CHANGED");
            sendBroadcast(intent);
    

    settings修改部分

    一、修改AndroidManifest.xml
    1.新增如下内容

    <uses-permission android:name="android.net.action.ETHERNET_IP_CHANGED"/>
    <receiver android:name="com.android.settings.EtherentBoardcastReceive"
    			 android:enabled="true"
    			 android:exported="true">
                 <intent-filter android:priority="1000">
                    <action android:name="android.net.action.ETHERNET_IP_CHANGED" />
                </intent-filter>
            </receiver>
    

    2.在目录Settings\src\com\android\settings\ethernet 下新增文件EtherentBoardcastReceive.java

    package com.android.settings;
    
    import com.android.settings.R;
    import android.app.Activity;
    import android.app.AlertDialog;
    import android.app.Dialog;
    import android.app.admin.DevicePolicyManager;
    import android.content.ActivityNotFoundException;
    import android.content.BroadcastReceiver;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.DialogInterface;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.content.pm.PackageManager;
    import android.content.res.Resources;
    import android.net.ConnectivityManager;
    import android.net.NetworkInfo;
    import android.net.Uri;
    import android.os.Bundle;
    import android.os.SystemProperties;
    import android.os.UserHandle;
    import android.os.UserManager;
    import android.preference.CheckBoxPreference;
    //import android.preference.Preference;
    import android.preference.Preference.OnPreferenceChangeListener;
    import android.preference.PreferenceScreen;
    //import android.preference.SwitchPreference;
    import android.support.v14.preference.SwitchPreference;
    import android.support.v7.preference.ListPreference;
    import android.support.v7.preference.Preference;
    import android.provider.SearchIndexableResource;
    import android.provider.Settings;
    import android.telephony.TelephonyManager;
    import android.text.TextUtils;
    import android.util.Log;
    import android.content.Intent;
    
    import java.io.File;
    import java.io.FileDescriptor;
    import java.io.File;
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.File;
    import java.io.FileDescriptor;
    import java.io.File;
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    import java.util.regex.Pattern;
    import java.lang.Integer;
    import java.net.InetAddress;
    import java.net.Inet4Address;
    import java.util.Iterator;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.List;
    
    
    
    /*for 5.0*/
    import android.net.EthernetManager;
    import android.net.IpConfiguration;
    import android.net.IpConfiguration.IpAssignment;
    import android.net.IpConfiguration.ProxySettings;
    import android.net.wifi.SupplicantState;
    import android.net.wifi.WifiInfo;
    import android.net.wifi.WifiManager;
    import android.net.StaticIpConfiguration;
    import android.net.NetworkUtils;
    import android.net.LinkAddress;
    import android.net.LinkProperties;
    //import android.preference.ListPreference;
    import com.android.internal.logging.MetricsProto.MetricsEvent;
    
    import com.android.settings.ethernet_static_ip_dialog;
    import com.android.settings.pppoe_dialog;
    
    import com.android.settings.EthernetSettings;  
    
    public class EtherentBoardcastReceive extends BroadcastReceiver  {
    	private static final String TAG = "EtherentBoardcastReceive";
    	 
    	private  static String mEthMode = null;//"static";
        private  static String mEthIpAddress = null;//"192.168.1.254";
        private  static String mEthNetmask = null;//"255.255.255.0";
        private  static String mEthGateway = null;//"192.168.1.1";
        private  static String mEthdns1 = null;//"192.168.1.1";
        private  static String mEthdns2 = null;//"null";
    
        private final static String nullIpInfo = "0.0.0.0";
    
    	 @Override
        public void onReceive(Context context, Intent intent) {
    
    			IpConfiguration mIpConfiguration;
    			StaticIpConfiguration mStaticIpConfiguration;
    			String action = intent.getAction();
    		    Log.i(TAG, "receive a new action : " + action);
    			
    			EthernetManager mEthManager = (EthernetManager) context.getSystemService(Context.ETHERNET_SERVICE);
    			if(mEthManager == null){
    				Log.i(TAG, "fail to getSystemService :  "+Context.ETHERNET_SERVICE);
    			}
    
    		  mStaticIpConfiguration =new StaticIpConfiguration();
    		  getNetConfigFromIntent(intent);
    		 /*
    		  * get ip address, netmask,dns ,gw etc.
    		  */
    		
    
    
    		if (mEthMode  == null ||mEthMode.equals("static"))
    		{
    			 Inet4Address inetAddr = getIPv4Address(this.mEthIpAddress);
    			int prefixLength = maskStr2InetMask(this.mEthNetmask); 
    			InetAddress gatewayAddr = getIPv4Address(this.mEthGateway); 
    			InetAddress dnsAddr1 = getIPv4Address(this.mEthdns1);
    			InetAddress dnsAddr2 = getIPv4Address(this.mEthdns2);
    			if(inetAddr ==null || gatewayAddr == null || prefixLength <= 0  ){
    				  Log.e(TAG,"ip,mask or dnsAddr is wrong");
    				  return ;
    			}
    			if (inetAddr.getAddress().toString().isEmpty() || prefixLength ==0 || gatewayAddr.toString().isEmpty()
    			  ) {
    				   Log.e(TAG,"ip,mask or dnsAddr is wrong");
    				  return ;
    			}
    			  
    			mStaticIpConfiguration.ipAddress = new LinkAddress(inetAddr, prefixLength);
    			mStaticIpConfiguration.gateway=gatewayAddr;
    			if(dnsAddr1 != null && !dnsAddr1.toString().isEmpty())
    				mStaticIpConfiguration.dnsServers.add(dnsAddr1);
    			if(dnsAddr2 != null && !dnsAddr2.toString().isEmpty())
    				mStaticIpConfiguration.dnsServers.add(dnsAddr2);
    		
    			mIpConfiguration=new IpConfiguration(IpAssignment.STATIC, ProxySettings.NONE,mStaticIpConfiguration,null);  
    			mEthManager.setConfiguration(mIpConfiguration); 
    		}else{
    			mEthManager.setConfiguration(new IpConfiguration(IpAssignment.DHCP, ProxySettings.NONE,null,null));
    		}
           
    		//
    		
        }
    	
    	private void getNetConfigFromIntent(Intent intent){
    		Bundle bundle = intent.getExtras();
            if (bundle.getString("netMode") != null)
    			this.mEthMode = bundle.getString("netMode");
    		if (bundle.getString("ipaddr") != null)
    			this.mEthIpAddress = bundle.getString("ipaddr");
    		if (bundle.getString("netMask")!= null)
    			this.mEthNetmask = bundle.getString("netMask");
    		if (bundle.getString("gateway")!= null)
    			this.mEthGateway = bundle.getString("gateway");
    		if (bundle.getString("dns1") != null)
    			this.mEthdns1 = bundle.getString("dns1");
    		if (bundle.getString("dns2") != null)
    			this.mEthdns2 = bundle.getString("dns2");
    	}
    	 private Inet4Address getIPv4Address(String text) {
            try {
                return (Inet4Address) NetworkUtils.numericToInetAddress(text);
            } catch (IllegalArgumentException|ClassCastException e) {
                return null;
            }
        }
    
    	 /*
         * convert subMask string to prefix length
         */
        private 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;
        }
    
    
    
    }
    
    

    代码就不多介绍了,大体流程是接收到广播后就解析字符串后进行IP设置
    ,有明白处可给我留言。
    最后打个小广告,本人还承接一些android、linux主板软硬件开发的项目,有兴趣的可以加我微信(CSDN账号同名)详聊。

    展开全文
  • 安卓9.0设置以太网静态IP地址

    千次阅读 热门讨论 2019-08-14 19:41:37
    前言:因为项目需要设置安卓9.0系统的以太网静态ip地址,于是网上搜索相关资料。9.0系统以太网设置静态ip有关的,只有Github上有个MTK开发人员的分享,github链接:...
  • android 以太网设置静态ip

    千次阅读 2018-04-26 09:01:01
    先是查到了以下的方法,发现是设置Wi-Fi的。 public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); ContentResolver cr = this....
  • 在做android设备时候有设置设备的静态IP,因为这个方法是系统隐藏方法,而且还是9.0的系统目前测试...原博客:安卓9.0设置以太网静态IP地址 博客来源地址:https://blog.csdn.net/zzhceo/article/details/99596435 ...
  • 在添加以太网后,可以顺利设置静态ip.但是当我设置静态后,出现需要将网线拔插一次更新网络后才能刷新ip地址的bug。当时以为只要像7.0和8.0那样新增就没有问题了,没想到这次9.0又改变了代码结构。下面我将详细介绍...
  • 施耐德PLC的常见设备默认IP地址大全,包括PLC,交换机等
  • checkStaticIP .setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { @Override public void onCheckedChanged(CompoundButton buttonView, ...contentResolver, ETHERNET_USE_STATIC_IP
  • 然后在系统设置页面有个以太网菜单可以进行IP、网关等设置,如下: 二、那怎么通过代码去设置呢? 1、Android系统在Framework层是有提供操作以太网Api的也就是android.net.EthernetManager,但是Google把Api给隐藏...
  • 设置设置以太网静态ip设置后使用ifconfig查看ip显示正常。然后重启,极大概率出现开机后设备没有获取到ip. 分析解决 测试后发现了几点规律: 设置静态ip会开机获取不到ip,但是设置动态ip无问题 没有获取到ip...
  • packages/apps/Settings/src/... public interface getStaticIpInfo { public boolean getStaticIp(String ipAddr); public boolean getStaticNetMask(String netMask); public boolean getStaticGa
  • IDF4.4 ESP32-S2给以太网接口设置静态IP

    千次阅读 2022-02-17 23:50:13
    需求: 实际Lora网关需要...Esp32-Ethernet-kit_A_1.2以太网设置静态ip,windows与板子ping通_Linux_zhicheng的博客-CSDN博客_esp32静态ip 接着找,发现了这个 How to assign Ethernet Static IP address - ESP32 For
  • 电脑设置静态ip; 电脑和板子在同一网段; ipconfig查看本机以太网ipv4地址 编译如果代码被编译过可以清一下: idf.py fullclean 删掉build文件,或者直接拷贝原来的代码基础上修改,然后编译并烧录: ...
  • 代码路径: device/sprd/sharkl3/uis8581a2h10/system.prop ...在system.prop文件中添加一个属性控制是否配置静态IP diff --git a/system.prop b/system.prop index fce9347..e8e5f81 100755 --- a/system.prop
  • Netplan是Ubuntu 17.10中引入的一种新的命令行网络配置实用程序,用于在Ubuntu系统中轻松管理和配置网络设置。这篇文章主要介绍了Ubuntu 18.04 Server 设置静态IP 的方法,需要的朋友可以参考下
  • 3 个答案:答案 0 :(得分:1)我能够将Ip设置以太网连接,如下所示。我正在使用Allwinner A31s安卓板。String command1 = "su -c ifconfig eth0 "+ terminalIpAddressString+" netmask "+ subnetMaskAddressString+...
  • Android7.1.2修改以太网静态设置

    千次阅读 2022-04-24 10:51:20
    如何设置以太网有线网络静态配置 从源码看设置以太网配置调用的是EthernetManager的setConfiguration方法, 所以我们就只需要创建IpConfiguration这个实例,他的构造方法传入值是 最终配置的参数就是StaticIp...
  • 这个项目已经很老了,其实是从 Android 4.4.4 的系统 Settings 中 copy 出来的。 其实原理都是编译运行系统 ...Android 操作以太网的项目,提供了监听网线插拔和以太网开关,设置以太网静态IP、网关、子网掩码、dns等。
  • EthernetManager Android设置以太网静态IP

    千次阅读 2020-11-13 17:19:55
    想要设置以太网静态IP通过搜索是需用到EthernetManager,但是EthernetManager是谷歌隐藏的API,app是无法调用到的,所以只能通过反射来进行设置 也可以通过下载系统的class.jar包,放到自己的项目中,就可以不用...
  • 设置 -> 更多 -> 以太网功能: 1. 支持以太网开启与禁用 2. 支持以太网静态IP和动态获取切换
  • 判断网络是否可用: 注意!是判断网络是否可用,但网络可用不代表一定能上外网的! public static boolean isNetworkAvailable(Context context) { ConnectivityManager manager = (ConnectivityManager) context...
  • 三菱plcsocket通讯例子,客户端和服务器的例子
  • 树莓派设置静态IP地址(有线网络)

    千次阅读 2022-04-04 16:56:38
    每次开机树莓派的IP地址都变,特别麻烦。 1、查看树莓派IP地址 2、修改网络配置文件 dhcpcd.conf sudo nano /etc/dhcpcd.conf 输入后摁回车进入dhcpcd.conf文件 3、找到以太网接口配置(interface eth0...
  • 使用命令行修改android以太网,看博客文章:https://blog.csdn.net/weixin_44442049/article/details/110038529
  • AB_IP地址设置方法

    2019-01-22 16:25:42
    详细介绍ABPLC的IP地址设置,图文并茂进行介绍。使读者更加清晰。
  • android实现wifi静态IP设置

    热门讨论 2013-08-04 19:08:32
    实现wifi静态IP设置,4.2以下版本都可使用,封装好,方便使用
  • 本补丁是在安卓6.0.1设置界面增加以太网静态IP配置功能,基于全志A64平台,SDK_V2.1.1安卓6.0.1 补丁名称里已经包含了路径,在源码对应路径用patch -p1 即可

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 128,746
精华内容 51,498
关键字:

以太网设置ip地址