A33 android4.4增加上层有线网络设置接口及相关说明

最新推荐文章于 2023-05-10 19:00:38 发布
最新推荐文章于 2023-05-10 19:00:38 发布
阅读量679 收藏 1
点赞数
分类专栏： android系统 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hclydao/article/details/106419714
版权

A33 android4.4增加有线网络设置接口及相关说明

framework修改

获取有线网络ip地址相关修改

修改frameworks/base/ethernet/java/android/net/ethernet/EthernetDataTracker.java
增加函数setDevInfo

    public void setDevInfo(EthernetDevInfo devinfo) {
        if ((mLinkProperties == null) || (devinfo == null))
			return;
		//Slog.d(TAG,"devinfo.getIfName():" + devinfo.getIfName() + "mLinkProperties.getInterfaceName()" + mLinkProperties.getInterfaceName());
		if(!devinfo.getIfName().equals(mLinkProperties.getInterfaceName()))
			return;
        DhcpInfo info = new DhcpInfo();
        for (LinkAddress la : mLinkProperties.getLinkAddresses()) {
            InetAddress addr = la.getAddress();
            if (addr instanceof Inet4Address) {
                //Slog.d(TAG,"ip:" + addr.getHostAddress());
				devinfo.setIpAddress(addr.getHostAddress());
                break;
            }
        }
        for (RouteInfo r : mLinkProperties.getRoutes()) {
            if (r.isDefaultRoute()) {
                InetAddress gateway = r.getGateway();
                if (gateway instanceof Inet4Address) {
					//Slog.d(TAG,"gateway:" + gateway.getHostAddress());
					devinfo.setGateWay(gateway.getHostAddress());
                }
            } else if (r.hasGateway() == false) {
                LinkAddress dest = r.getDestination();
                if (dest.getAddress() instanceof Inet4Address) {
					int netmask = NetworkUtils.prefixLengthToNetmaskInt(dest.getNetworkPrefixLength());
					//Slog.d(TAG,"netmask:" + netmask + " NetworkUtils.intToInetAddress(netmask):" + NetworkUtils.intToInetAddress(netmask));
					//Slog.d(TAG," NetworkUtils.intToInetAddress(netmask).getHostAddress():" + NetworkUtils.intToInetAddress(netmask).getHostAddress());
					devinfo.setNetMask(NetworkUtils.intToInetAddress(netmask).getHostAddress());
                }
            }
        }
        int dnsFound = 0;
        for (InetAddress dns : mLinkProperties.getDnses()) {
            if (dns instanceof Inet4Address) {
                if (dnsFound == 0) {
                    //info.dns1 = NetworkUtils.inetAddressToInt((Inet4Address)dns);
					//Slog.d(TAG,"dns1:" + dns.getHostAddress());
					devinfo.setDnsAddr(dns.getHostAddress());
                } else {
                    //info.dns2 = NetworkUtils.inetAddressToInt((Inet4Address)dns);
					//Slog.d(TAG,"dns2:" + dns.getHostAddress());
					devinfo.setDnsAddr(dns.getHostAddress());
                }
                if (++dnsFound > 1) break;
            }
        }
        return;
    }

修改frameworks/base/services/java/com/android/server/EthernetService.java
中getDeviceNameList函数

	public List<EthernetDevInfo> getDeviceNameList() {
		List<EthernetDevInfo> reDevs = new ArrayList<EthernetDevInfo>();

		synchronized(mDeviceMap){
			if(mDeviceMap.size() == 0)
				return null;
			for(EthernetDevInfo devinfo : mDeviceMap.values()){
				mTracker.setDevInfo(devinfo);
				reDevs.add(devinfo);
			}
		}
		return reDevs;
	}

增加

mTracker.setDevInfo(devinfo);

这样应用层就能获取到有线网络ip,应用层获取后面在说

设置有线网络相关修改

修改frameworks/base/ethernet/java/android/net/ethernet/EthernetManager.java
增加

public static final String EXTRA_DEV_INFO	= "devinfo";
public static final int EVENT_TURN_ON                      = 8;
public static final int EVENT_TURN_OFF                      = 9;
public static final int EVENT_UPDATE_INFO                      = 10;

修改frameworks/base/services/java/com/android/server/EthernetService.java
handleReceive函数中增加

case EthernetManager.EVENT_TURN_ON:
    //Log.d(TAG, "handleReceive EthernetManager.EVENT_TURN_ON");
    setState(EthernetManager.ETHERNET_STATE_ENABLED);
    break;
case EthernetManager.EVENT_TURN_OFF:
    //Log.d(TAG, "handleReceive EthernetManager.EVENT_TURN_OFF");
    setState(EthernetManager.ETHERNET_STATE_DISABLED);
    break;
case EthernetManager.EVENT_UPDATE_INFO:
    //Log.d(TAG, "handleReceive EthernetManager.EVENT_UPDATE_INFO");
    final EthernetDevInfo info = (EthernetDevInfo)intent.getParcelableExtra(EthernetManager.EXTRA_DEV_INFO);
    updateDevInfo(info);
    break;

AS导入编译的framework使用

拷贝编译的
out/target/common/obj/JAVA_LIBRARIES/framework-base_intermediates/classes-full-debug.jar
到AS工程libs目录中
修改工程build.gradle文件修改如下

allprojects {
    repositories {
        google()
        jcenter()
    }
	<font color=red>
    gradle.projectsEvaluated {
        tasks.withType(JavaCompile) {
            options.compilerArgs.add
            ('-Xbootclasspath/p:app\\libs\\classes-full-debug.jar')
        }
    }
	</font>
}

增加gradle.projectsEvaluated
修改app模块下build.gradle文件

    defaultConfig {
        multiDexEnabled = true
        applicationId "com.gzease.sfjdemo"
        minSdkVersion 19
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }

defaultConfig中增加multiDexEnabled

dependencies {
    //implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation fileTree(dir: 'libs/armeabi-v7a')
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
    //compile project(path: ':hwc')
    compile 'com.android.support:multidex:1.0.0'
    compile(name: 'sfj-release-1.0', ext: 'aar')
    compileOnly files('libs/classes-full-debug.jar')
}

修改了

//implementation fileTree(include: ['*.jar'], dir: 'libs')
implementation fileTree(dir: 'libs/armeabi-v7a')
compile 'com.android.support:multidex:1.0.0'
compileOnly files('libs/classes-full-debug.jar')

在最后增加

preBuild {
    doLast {
        def imlFile = file(project.name + ".iml")
        println 'Change ' + project.name + '.iml order'
        try {
            def parsedXml = (new XmlParser()).parse(imlFile)
            def jdkNode = parsedXml.component[1].orderEntry.find { it.'@type' == 'jdk' }
            parsedXml.component[1].remove(jdkNode)
            def sdkString = "Android API " + android.compileSdkVersion.substring("android-".length()) + " Platform"
            new Node(parsedXml.component[1], 'orderEntry', ['type': 'jdk', 'jdkName': sdkString, 'jdkType': 'Android SDK'])
            groovy.xml.XmlUtil.serialize(parsedXml, new FileOutputStream(imlFile))
        } catch (FileNotFoundException e) {
            // nop, iml not found
        }
    }
}

修改完成后就能调用标准api没有的接口函数了
其中有有线网络中的一些接口会提示，api版本要求21但我的是android4.4 api是19
还会有一些接口抛安全异常，需要系统级应用才能调用，所以需要对文件系统进行修改

测试demo

下面是截取的代码主要功能代码已经全部包括

package com.gzease.sfjdemo;

import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.AssetFileDescriptor;
import android.content.res.AssetManager;
import android.graphics.Color;
import android.media.MediaPlayer;
import android.net.ConnectivityManager;
import android.net.DhcpInfo;
import android.net.LinkAddress;
import android.net.LinkProperties;
import android.net.NetworkInfo;
import android.net.ethernet.EthernetDevInfo;
import android.net.ethernet.EthernetManager;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;

import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class Main extends Activity implements RadioGroup.OnCheckedChangeListener {
    private final String TAG = "Gzease-SfjDemo";
    private Handler handler = new Handler();
    private ConnectivityManager mService;
    private EthernetManager mEthManager;
    private BroadcastReceiver mEthStateReceiver;
    private IntentFilter mFilter;
    private List<EthernetDevInfo> mListDevices = new ArrayList<EthernetDevInfo>();
    private CheckBox mEthEnable;
    private TextView ethsta;
    private RadioButton ethmoded;
    private RadioButton ethmodes;
    private EditText ethmac;
    private EditText ethip;
    private EditText ethmask;
    private EditText ethgw;
    private EditText ethdns;
    private RadioGroup moderg;
    private Button ethset;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mEthEnable = (CheckBox)findViewById(R.id.echeck);
        ethsta = (TextView)findViewById(R.id.ethsta);
        ethmac = (EditText)findViewById(R.id.ethmac);
        ethmac.setEnabled(false);
        ethmoded = (RadioButton) findViewById(R.id.ethmoded);
        ethmodes = (RadioButton) findViewById(R.id.ethmodes);
        moderg = (RadioGroup)findViewById(R.id.moderg);
        ethip = (EditText)findViewById(R.id.ethip);
        ethmask = (EditText)findViewById(R.id.ethmask);
        ethgw = (EditText)findViewById(R.id.ethgw);
        ethdns = (EditText)findViewById(R.id.ethdns);
        ethset = (Button)findViewById(R.id.ethset);

        mFilter = new IntentFilter();
        mFilter.addAction(EthernetManager.ETHERNET_STATE_CHANGED_ACTION);
        mFilter.addAction(EthernetManager.NETWORK_STATE_CHANGED_ACTION);

        mEthStateReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                handleEvent(context, intent);
            }
        };

        mService = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        mEthManager = EthernetManager.getInstance();

        if(mEthManager.getState() == EthernetManager.ETHERNET_STATE_ENABLED) {
            mEthEnable.setChecked(true);
            ethset.setEnabled(true);
        } else {
            mEthEnable.setChecked(false);
            ethset.setEnabled(false);
        }
        getMac();
        EthernetDevInfo saveInfo = mEthManager.getSavedConfig();
        updateInfo(saveInfo);

        mEthEnable.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
                Log.d(TAG,"ischeck: " + b);
                setEthEnabled(b);
                mEthEnable.setEnabled(false);
                ethset.setEnabled(b);
            }
        });
        moderg.setOnCheckedChangeListener(this);
        ethset.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                ethset.setEnabled(false);
                mEthEnable.setEnabled(false);
                sendStateBroadcast(EthernetManager.EVENT_UPDATE_INFO);
            }
        });
    }

    private void setEthEnabled(final boolean enable){
        if(enable) {
            sendStateBroadcast(EthernetManager.EVENT_UPDATE_INFO);
            sendStateBroadcast(EthernetManager.EVENT_TURN_ON);
        } else
            sendStateBroadcast(EthernetManager.EVENT_TURN_OFF);
    }

    private void sendStateBroadcast(int event) {
        Intent intent = new Intent(EthernetManager.NETWORK_STATE_CHANGED_ACTION);
        intent.putExtra(EthernetManager.EXTRA_ETHERNET_STATE, event);
        EthernetDevInfo info = new EthernetDevInfo();
        if(moderg.getCheckedRadioButtonId() == R.id.ethmodes)
            info.setConnectMode(EthernetDevInfo.ETHERNET_CONN_MODE_MANUAL);
        else
            info.setConnectMode(EthernetDevInfo.ETHERNET_CONN_MODE_DHCP);
        info.setDnsAddr(ethdns.getText().toString());
        info.setGateWay(ethgw.getText().toString());
        info.setIpAddress(ethip.getText().toString());
        EthernetDevInfo saveInfo = mEthManager.getSavedConfig();
        Log.d(TAG," saveInfo:" + saveInfo);
        if(saveInfo != null) {
            Log.d(TAG," sendStateBroadcast saveInfo.getIfName(): " + saveInfo.getIfName());
            info.setIfName(saveInfo.getIfName());

        } else
            info.setIfName("eth0");
        info.setHwaddr(getMac());
        info.setNetMask(ethmask.getText().toString());
        intent.putExtra(EthernetManager.EXTRA_DEV_INFO, info);
        sendBroadcast(intent);
    }

    private String getMac() {
        mListDevices = mEthManager.getDeviceNameList();
        for(EthernetDevInfo deviceinfo : mListDevices) {
            if(deviceinfo.getIfName().equals("eth0")) {
                Log.d(TAG,"deviceinfo.getHwaddr():" + deviceinfo.getHwaddr());
                return deviceinfo.getHwaddr();
            }
        }
        return "";
    }

    private void updateInfo(final EthernetDevInfo DevIfo) {
        handler.post(new Runnable() {
            @Override
            public void run() {
                String ifname = "";
                if(mService != null) {
                    NetworkInfo networkinfo = mService.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
                    if(networkinfo.isConnected()) {
                        if(DevIfo != null)
                            ethsta.setText("已连接 设备:" + DevIfo.getIfName());
                        else
                            ethsta.setText("已连接");
                    } else {
                        ethsta.setText("未连接");
                    }
                }
                Log.d(TAG,"DevIfo:" + DevIfo);
                if(DevIfo != null)
                    ifname = DevIfo.getIfName();
                else
                    return;

                mListDevices = mEthManager.getDeviceNameList();
                if(mListDevices != null) {
                    for(EthernetDevInfo deviceinfo : mListDevices) {
                        Log.d(TAG,"DevIfo.getIfName():" + DevIfo.getIfName() + " deviceinfo.getIfName():" +deviceinfo.getIfName());
                        Log.d(TAG,"deviceinfo.getHwaddr():" + deviceinfo.getHwaddr());
                        if(deviceinfo.getIfName().equals(DevIfo.getIfName())) {
                            DevIfo.setHwaddr(deviceinfo.getHwaddr());
                            ethmac.setText(deviceinfo.getHwaddr().toUpperCase());
                            ethip.setText(deviceinfo.getIpAddress());
                            ethmask.setText(deviceinfo.getNetMask());
                            ethgw.setText(deviceinfo.getGateWay());
                            ethdns.setText(deviceinfo.getDnsAddr());
                            if(deviceinfo.getConnectMode() == EthernetDevInfo.ETHERNET_CONN_MODE_DHCP){
                                ethmoded.setChecked(true);
                                //ethmac.setEnabled(false);
                                ethip.setEnabled(false);
                                ethmask.setEnabled(false);
                                ethgw.setEnabled(false);
                                ethdns.setEnabled(false);
                            }else{
                                ethmodes.setChecked(true);
                                //ethmac.setEnabled(true);
                                ethip.setEnabled(true);
                                ethmask.setEnabled(true);
                                ethgw.setEnabled(true);
                                ethdns.setEnabled(true);
                            }
                        }
                    }
                }
            }
        });

    }

    private void handleEvent(Context context, Intent intent) {
        String action = intent.getAction();
        Log.d(TAG," action:" + action);
        if (EthernetManager.ETHERNET_STATE_CHANGED_ACTION.equals(action)) {
            final EthernetDevInfo devinfo = (EthernetDevInfo)
                    intent.getParcelableExtra(EthernetManager.EXTRA_ETHERNET_INFO);
            final int event = intent.getIntExtra(EthernetManager.EXTRA_ETHERNET_STATE,
                    EthernetManager.EVENT_NEWDEV);

            if(event == EthernetManager.EVENT_NEWDEV || event == EthernetManager.EVENT_DEVREM) {

            }
        } else if (EthernetManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {
            final int event = intent.getIntExtra(EthernetManager.EXTRA_ETHERNET_STATE,
                    EthernetManager.EVENT_CONFIGURATION_SUCCEEDED);
            //Log.d(TAG," event:" + event);
            switch(event) {
                case EthernetManager.EVENT_CONFIGURATION_SUCCEEDED:
                    mEthEnable.setEnabled(true);
                    ethset.setEnabled(true);
                    break;
                case EthernetManager.EVENT_CONFIGURATION_FAILED:
                    break;
                case EthernetManager.EVENT_DISCONNECTED:
                    mEthEnable.setEnabled(true);
                    break;
                default:
                    break;
            }
            EthernetDevInfo saveInfo = mEthManager.getSavedConfig();
            updateInfo(saveInfo);
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.d(TAG,"onResume");
        registerReceiver(mEthStateReceiver, mFilter);
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG,"onPause");
        unregisterReceiver(mEthStateReceiver);
    }

    @Override
    public void onCheckedChanged(RadioGroup radioGroup, int id) {
        switch (id) {
            case R.id.ethmoded:
                //ethmac.setEnabled(false);
                ethip.setEnabled(false);
                ethmask.setEnabled(false);
                ethgw.setEnabled(false);
                ethdns.setEnabled(false);
                break;
            case R.id.ethmodes:
                //ethmac.setEnabled(true);
                ethip.setEnabled(true);
                ethmask.setEnabled(true);
                ethgw.setEnabled(true);
                ethdns.setEnabled(true);
                break;
        }
    }
}

======================================
作者：hclydao
http://blog.csdn.net/hclydao
版权没有，但是转载请保留此段声明

===========================================

参考链接

https://blog.csdn.net/abs625/article/details/79611411

红尘六欲
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全志A33-USB虚拟网卡的配置与使用
ARM-Linux
08-05 4592
开发环境 开发板：A33-Vstar 开发板系统：Linux USB网卡：三星S4、华为P8（USB共享网络） ------------------------------------------------ 1. 配置内核 运行：make menuconfig ARCH=arm 依次进入： Device Drivers ---&gt;Network device suppor......
全志r16/a33安卓6.0系统让ethernet和wifi同时在线
chenfeifei521的博客
05-12 1424
这是安卓7.0中修改方法，并没有在安卓6.0中试过，如果我测试成功了，我会重写这篇文章。 这边文章来自于：https://www.jianshu.com/p/d1be03c15263 感谢老哥的帮助。 这个老哥为了修改路由表在写了个函数执行下面修改路由表的指令，感觉没有必要啊，不如加入到init.sun8i.rc,或者是init.rc中执行。 1、/services/core/java/com/android/server/ConnectivitySe...
android 以太网 添加设置Ethernet
11-27
android在设置中添加以太网ethernet方法， 在可以是学习框架的一种好方法。
android ip to int,Java: convert int to InetAddress
weixin_31951365的博客
05-28 139
Not enough reputation to comment on skaffman's answer so I'll add this as a separate answer.The solution skaffman proposes is correct with one exception. BigInteger.toByteArray() returns a byte array ...
Android 以太网转 WiFi 热点 （并在同一网段 192.168.0.xx）
PCWUNG的专栏
08-01 4185
命令如下： 首先打开盒子的 wifi 热点功能，再用以下命令 ip link set eth0 up; ip link add eth1 type bridge ; ip link set eth0 master eth1; busybox ifconfig eth0 0.0.0.0 ip link set wlan0 master eth1 busybox ifconfig wlan0 0.0...
A33Android4.4 rtl8723ds驱动源码
12-21
在《全志A33 Android 4.4 rtl8723ds驱动源码》的压缩包中，包含了rtl8723ds驱动的相关源文件，这些文件详细描述了驱动的实现细节。开发者可以通过阅读和分析这些源代码，了解驱动的结构、函数功能以及与内核、硬件的...
全志A33Android4.4 rtl8723ds移植补丁.diff
12-21
该补丁为全志A33Android4.4 rtl8723ds移植补丁，移植文档参考：https://blog.csdn.net/Mrdeath/article/details/111406660
rtl8723ds linuxandroid 驱动 内含详细移植说明，支持android4.4 -- android10.x.zip
07-09
另一部分是上层驱动，它作为内核与用户空间应用之间的桥梁，提供了标准的接口供Android系统调用。驱动的移植通常涉及到对这两部分的适配工作。 在描述中提到的"详细移植说明"，可能包含以下内容： 1. **环境准备**...
a33_bootloader:来自全志 A33 SDK 4.4 的引导加载程序源代码
07-09
在本文中，我们将深入探讨全志A33 SDK 4.4中的引导加载程序源代码，以及与C语言相关的编程知识点。 首先，引导加载程序（Bootloader）是系统启动时运行的第一段代码，它在硬件初始化阶段起到关键作用。全志A33 ...
Android5.1以太网开关控制以及动静态IP设置
03-21
在Android系统中，网络连接的配置通常通过用户界面完成，如Wi-Fi和移动数据的开关。然而，在一些特定场景下，比如嵌入式设备或定制的开发板，可能需要通过编程方式来控制以太网连接及配置IP地址。在Android 5.1版本...
android设置有线网卡IP
10-17
前段时间在学习设置android有线网卡的IP，其重点是怎样获得root权限。
路由配置信息的获取
sjz4860402的专栏
04-10 6022
路由配置信息的获取有多种方式，wifi，mobile data，Tethering，VPN。这里主要分析由mobile data获取路由配置信息的过程。 结合ConnectivityService类，其大致的类图与流程图如下： 从打开数据开关到获取到路由配置信息的时序图如下： 本篇博客只介绍DcTracker，DataConnection，GsmCdmaPhone，RIL层的AT指令...
Android 13 有线网变更(用到的可以收藏)
最新发布
wenzhi的博客
05-10 3191
有线网设置新路径：try {try {try {从上面看，主要是api加了限制 ：maxTargetSdk = Build.VERSION_CODES.R //Android11maxTargetSdk 表明最大支持的SDK 版本，R 表示Android11 .所以Android 12 或者更新的版本，在EthernetManager 是调用不到上面几个接口方法的！(1) 限制了设置有线网参数设置 setConfiguration 接口方法 等方法使用。
Allwinner A33/A31 FrameWare基本配置
zzk_going的博客
09-19 5684
前几个月工作主要是针对Cortex-A7处理器：全志A33和A31的固件进行的一些配置和编译。 现基本总结一下配制方法，供大家参考： 对于初搞交叉编译的同学而言，最先需要注意的就是menuconfig时需要加上ARCH选项，即：make ARCH=arm menuconfig  巴拉拉。。在这说废话了，大神请略过轻喷。 下面说一下全志源码， 1、sys_config.fex 对于
Android4.2 以太网Ethernet DHCP和静态设置实现
热门推荐
人工智能，深度学习，人脸识别
03-03 1万+
前提：下面涉及的内容均需要系统权限，也就是系统应用，开发非系统app则饶边。 以太网设置一般是进入系统原生的设置APP，进入到以太网选项进行设置的。在一些专用场合，需要定制APP，不直接调用系统的设置，那么就要自己实现以太网动态和静态的设置。 权限： <uses-permission android:name="android.permission.WRITE_SETTIN...
couldn't find import for class android.net.ethernet.EthernetDevInfo
waterzhou的专栏
02-05 2482
android 添加系统service的关键一步   2010-11-09 11:39:43|  分类： Android|字号 订阅 本想打算直接将android-x86的有线网服务直接移植过来arm版本的android-froyo上，按照从 http://code.google.com/p/android-x86/downloads/detail?name=
andorid跳过系统API获取以太网IP，网关，DNS，MAC的方法
呆屁的博客
04-17 2331
最近在android平台上构建出windows的效果，之前通过EthernetManager和EthernetDevInfo获取以太网相关信息，但为了边敲代码边运行，想要跳过系统层的api调用，方法如下： 获取DNS： private String getLocalDNS(){ Process cmdProcess = null; Buffere...
Android开启热点进行UDP通信中的坑
小米
01-18 7697
android 开启热点进行udp通信
A33 Android系统移植详解
- **TouchPanel配置**：说明触控屏的配置文件修改，以及Android层的相关设置。 - **G-Sensor配置**：涉及打包配置文件的修改和Android层的配置，以支持重力感应器功能。 - **Camera配置**：讲解相机的打包配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值