android 添加系统服务

最新推荐文章于 2024-05-10 14:53:40 发布
最新推荐文章于 2024-05-10 14:53:40 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： android-framework
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ansondroider/article/details/53911069
版权

android 添加系统服务

在android系统中, 许许多的系统服务都是在系统启动时加载启动的,

如: PowerManager, WifiManager, InputMethodManager, 等等;

 

注: 本文参考自RK所提供的一部份补丁, 若涉及侵权, 请及时与我联系.

 

本文主要用于记录如何添加一个(Pppoe拨号)系统服务:

 

1. 添加IXManager.aidl(AIDL)文件:

 

frameworks/base/pppoe/java/android/net/pppoe/IPppoeManager.aidl

package android.net.pppoe;
interface IPppoeManager
{
    int getPppoeState();
    boolean setupPppoe(String user, String iface, String dns1, String dns2, String password);
    boolean startPppoe();
    boolean stopPppoe();
    String getPppoePhyIface();
}

 frameworks/base/Android.mk中添加编译文件:

 

LOCAL_SRC_FILES += \
	core/java/android/accessibilityservice/IAccessibilityServiceConnection.aidl \
	core/java/android/accessibilityservice/IAccessibilityServiceClient.aidl \
	core/java/android/accounts/IAccountManager.aidl \
	core/java/android/accounts/IAccountManagerResponse.aidl \
	core/java/android/accounts/IAccountAuthenticator.aidl \
	core/java/android/accounts/IAccountAuthenticatorResponse.aidl \
	core/java/android/app/IActivityController.aidl \
	core/java/android/app/IActivityPendingResult.aidl \
	core/java/android/app/IAlarmManager.aidl \
	core/java/android/app/IBackupAgent.aidl \
	core/java/android/app/IInstrumentationWatcher.aidl \
	core/java/android/app/INotificationManager.aidl \
	core/java/android/app/IProcessObserver.aidl \
	core/java/android/app/ISearchManager.aidl \
	core/java/android/app/ISearchManagerCallback.aidl \
	core/java/android/app/IServiceConnection.aidl \
	location/java/android/location/ILocationManager.aidl \
	pppoe/java/android/net/pppoe/IPppoeManager.aidl

 添加XManager.java

frameworks/base/pppoe/java/android/net/pppoe/PppoeManager.java
/*  
 *  Copyright(C), 2009-2010, Fuzhou Rockchip Co. ,Ltd.  All Rights Reserved.
 *
 *  File:   PppoeManager.java
 *  Desc:   
 *  Usage:
 *  Note:
 *  Author: cz@rock-chips.com
 *  Version:
 *          v1.0
 *  Log:
    ----Thu Sep 8 2011            v1.0
 */
package android.net.pppoe;

import android.annotation.SdkConstant;
import android.annotation.SdkConstant.SdkConstantType;
import android.net.DhcpInfo;
import android.os.Binder;
import android.os.IBinder;
import android.os.Handler;
import android.os.Message;
import android.os.Looper;
import android.os.HandlerThread;
import android.os.RemoteException;
import android.util.Log;

import java.util.List;

public class PppoeManager {
    private static final String TAG = "PppoeManager";
    public static final boolean DEBUG = true;
    private static void LOG(String msg) {
        if ( DEBUG ) {
            Log.d(TAG, msg);
        }
    }
    
    /**
     *  Broadcast intent action 
     *      indicating that PPPOE has been enabled, disabled, enabling, disabling, or unknown. 
     *  One extra provides current state as an int.
     *  Another extra provides the previous state, if available.
     * 
     * @see #EXTRA_PPPOE_STATE
     * @see #EXTRA_PREVIOUS_PPPOE_STATE
     */
    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
    public static final String PPPOE_STATE_CHANGED_ACTION 
        = "android.net.pppoe.PPPOE_STATE_CHANGED";
    /**
     *  Retrieve it with {@link android.content.Intent#getIntExtra(String,int)}.
     * 
     * @see #PPPOE_STATE_DISABLED
     * @see #PPPOE_STATE_DISABLING
     * @see #PPPOE_STATE_INIT_ENABLED
     * @see #PPPOE_STATE_ENABLING
     * @see #PPPOE_STATE_UNKNOWN
     */
    public static final String EXTRA_PPPOE_STATE = "pppoe_state";
    /**
     * The previous PPPOE state.
     * 
     * @see #EXTRA_PPPOE_STATE
     */
    public static final String EXTRA_PREVIOUS_PPPOE_STATE = "previous_pppoe_state";

    public static final int PPPOE_STATE_CONNECTING = 0;
    public static final int PPPOE_STATE_CONNECTED = 1;
    public static final int PPPOE_STATE_DISCONNECTING = 2;
    public static final int PPPOE_STATE_DISCONNECTED = 3;
    public static final int PPPOE_STATE_UNKNOWN = 4;

    IPppoeManager mService;

    Handler mHandler;
    private PppoeHandler mPppoeHandler;
/**
另一种做法:
    static public IXManager getService()
    {
        if (sService != null) {
            return sService;
        }
        IBinder b = ServiceManager.getService(name);
        sService = IXManager.Stub.asInterface(b);
        return sService;
    }
**/
    public PppoeManager(IPppoeManager service, Handler handler) {
        mService = service;
        mHandler = handler;

        if ( null == mPppoeHandler ) {
            LOG("PppoeManager() : start 'pppoe handle thread'.");
            HandlerThread handleThread = new HandlerThread("Pppoe Handler Thread");
            handleThread.start();
            mPppoeHandler = new PppoeHandler(handleThread.getLooper()/*, this*/);
        }
    }

    private class PppoeHandler extends Handler {
        private static final int COMMAND_START_PPPOE = 1;
        private static final int COMMAND_STOP_PPPOE = 2;

        private Handler mTarget;
        
        public PppoeHandler(Looper looper) {
            super(looper);
        }

        public void handleMessage(Message msg) {       
            
            int event;
            LOG("PppoeHandler::handleMessage() : Entered : msg = " + msg);

            switch (msg.what) {
                case COMMAND_START_PPPOE:
                    try {
                        mService.startPppoe();
                    } catch (RemoteException e) {
                        Log.e(TAG, "startPppoe failed");
                    }
                    break;
                case COMMAND_STOP_PPPOE:
                    try {
                        mService.stopPppoe();
                    } catch (RemoteException e) {
                        Log.e(TAG, "stopPppoe failed");
                    }
                    break;
                default:
                    break;
            }
        }
    }

    public int getPppoeState() {
        try {
            return mService.getPppoeState();
        } catch (RemoteException e) {
            Log.e(TAG, "stopPppoe failed");
            return -1;
        }
    }

    public boolean startPppoe() {
        return mPppoeHandler.sendEmptyMessage(PppoeHandler.COMMAND_START_PPPOE);
    }

    public boolean stopPppoe() {
        return mPppoeHandler.sendEmptyMessage(PppoeHandler.COMMAND_STOP_PPPOE);
    }

    public boolean setupPppoe(String user, String iface, String dns1, String dns2, String password) {
        try {
            return mService.setupPppoe(user, iface, dns1, dns2, password);
        } catch (RemoteException e) {
            return false;
        }
    }

    public String getPppoePhyIface() {
        try {
            return mService.getPppoePhyIface();
        } catch (RemoteException e) {
            return null;
        }
    }
}

 再去看看真正干活的地方:XManagerService.java 也可用XService.java

frameworks/base/services/java/com/android/server/PppoeService.java
/*$_FOR_ROCKCHIP_RBOX_$*/
//$_rbox_$_modify_$_chenzhi_20120309: add for pppoe
/*  
 *  Copyright(C), 2009-2010, Fuzhou Rockchip Co. ,Ltd.  All Rights Reserved.
 *
 *  File:   PppoeService.java
 *  Desc:   
 *  Usage:        
 *  Note:
 *  Author: cz@rock-chips.com
 *  Version:
 *          v1.0
 *  Log:
    ----Thu Sep 8 2011            v1.0
 */

package com.android.server;

import android.app.AlarmManager;
import android.app.PendingIntent;

import android.content.BroadcastReceiver;

import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.net.pppoe.IPppoeManager;
import android.net.pppoe.PppoeManager;
import android.net.NetworkStateTracker;
import android.net.DhcpInfo;
import android.net.NetworkInfo;
import android.net.NetworkInfo.DetailedState;
import android.os.Binder;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
import android.os.Process;
import android.os.RemoteException;
import android.os.UEventObserver;
import android.provider.Settings;
import android.util.Log;
import android.text.TextUtils;

import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import java.io.FileDescriptor;
import java.io.PrintWriter;

public class PppoeService extends IPppoeManager.Stub {
    private static final String TAG = "PppoeService";
    private static final boolean DEBUG = true;
    private static void LOG(String msg) {
        if ( DEBUG ) {
            Log.d(TAG, msg);
        }
    }

    private Context mContext;
    private PppoeObserver mObserver;
    private NetworkInfo mNetworkInfo;
    int mPppoeState = PppoeManager.PPPOE_STATE_DISCONNECTED;
    private String mIface;
    
    /*-------------------------------------------------------*/

    PppoeService(Context context) {
        LOG("PppoeService() : Entered.");
       
        mContext = context;
        mObserver = new PppoeObserver(mContext);
    }

    public int getPppoeState() {
        return mPppoeState;
    }
    
    private void setPppoeStateAndSendBroadcast(int newState) {
        int preState = mPppoeState;
        mPppoeState = newState;
        
        final Intent intent = new Intent(PppoeManager.PPPOE_STATE_CHANGED_ACTION);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);     
        intent.putExtra(PppoeManager.EXTRA_PPPOE_STATE, newState);
        intent.putExtra(PppoeManager.EXTRA_PREVIOUS_PPPOE_STATE, preState);
        LOG("setPppoeStateAndSendBroadcast() : preState = " + preState +", curState = " + newState);
        mContext.sendStickyBroadcast(intent);
    }
    
    public boolean startPppoe() {
        LOG("startPppoe");
        setPppoeStateAndSendBroadcast(PppoeManager.PPPOE_STATE_CONNECTING);
        if ( 0 != startPppoeNative() ) {
            LOG("startPppoe() : fail to start pppoe!");
            setPppoeStateAndSendBroadcast(PppoeManager.PPPOE_STATE_DISCONNECTED);
            return false;
        } else {
            setPppoeStateAndSendBroadcast(PppoeManager.PPPOE_STATE_CONNECTED);
            return true;
        }
    }
    
    public boolean stopPppoe() {
        setPppoeStateAndSendBroadcast(PppoeManager.PPPOE_STATE_DISCONNECTING);    
        if ( 0 != stopPppoeNative() ) {
            LOG("stopPppoe() : fail to stop pppoe!");
            return false;
        } else {
            setPppoeStateAndSendBroadcast(PppoeManager.PPPOE_STATE_DISCONNECTED);
            return true;
        }
    }
    
    public boolean setupPppoe(String user, String iface, String dns1, String dns2, String password) {
        int ret;
        
        LOG("setupPppoe: ");
        LOG("user="+user);
        LOG("iface="+iface);
        LOG("dns1="+dns1);
        LOG("dns2="+dns2);
//        LOG("password="+password);

        mIface = iface;

        if (0 == setupPppoeNative(user, iface, dns1, dns2, password)) {
            return true;
        } else {
            return false;
        }
    }

    public String getPppoePhyIface() {
        return mIface;	
    }
    	
    private class PppoeObserver extends UEventObserver {
        private static final String PPPOE_UEVENT_MATCH = "SUBSYSTEM=net";
        
        private Context mContext;
        
        public PppoeObserver(Context context) {
            mContext = context;
            LOG("PppoeObserver() : to start observing, to catch uevent with '" + PPPOE_UEVENT_MATCH + "'.");
            startObserving(PPPOE_UEVENT_MATCH);
            init();
        }

        private synchronized final void init() {
        }

        @Override
        public void onUEvent(PppoeObserver.UEvent event) {
            LOG("onUEvent() : get uevent : '" + event + "'.");

            String netInterface = event.get("INTERFACE");
            String action = event.get("ACTION");            
            if ( null != netInterface && netInterface.equals("ppp0") ) {
                if ( action.equals("add") ) {
                    LOG("onUEvent() : pppoe started");
//                    setEthernetEnabled(true);
                }
                else if ( action.equals("remove") ) {
                    LOG("onUEvent() : pppoe stopped");
//                    setEthernetEnabled(false);
                }
           }
        }
    }
/**

以下为JNI调用,在后面,会将这部分实现的步骤附上.

**/
    public native static int setupPppoeNative(String user, String iface,String dns1, String dns2, String password);
    public native static int startPppoeNative();
    public native static int stopPppoeNative();
    public native static int isPppoeUpNative();
}

 涉及JNI部分:

frameworks/base/core/jni/Android.mk
同样,先增加源码文件,
LOCAL_SRC_FILES:= \
	AndroidRuntime.cpp \
    android_animation_PropertyValuesHolder.cpp \
    android_net_pppoe_PppoeNative.cpp

 

添加CPP源文件:

frameworks/base/core/jni/android_net_pppoe_PppoeNative.cpp

//$_rbox_$_modify_$_chenzhi_20120309: add for pppoe

#define LOG_TAG "android_pppoe_PppoeNative.cpp"

#include "jni.h"
#include <utils/misc.h>
#include <android_runtime/AndroidRuntime.h>
#include <utils/Log.h>
#include <cutils/properties.h>

namespace android {
static jint setupPppoeNative(JNIEnv* env, 
                                    jobject clazz, 
                                    jstring user, 
                                    jstring iface, 
                                    jstring dns1, 
                                    jstring dns2, 
                                    jstring password)
{
    int attempt;
    int err = 0;
    char* cmd = (char*)malloc(128);
    char* prop = (char*)malloc(PROPERTY_VALUE_MAX);
    
   ///LOGD("%s", __FUNCTION__);
    
    char *c_user = (char *)env->GetStringUTFChars(user, NULL);
    char *c_iface = (char *)env->GetStringUTFChars(iface, NULL);
    char *c_dns1 = (char *)env->GetStringUTFChars(dns1, NULL);
    char *c_dns2 = (char *)env->GetStringUTFChars(dns2, NULL);
    char *c_password = (char *)env->GetStringUTFChars(password, NULL);

    if (!strcmp(c_dns1, "")) {
        strcpy(c_dns1, "server");
    }
    
    sprintf(cmd, "pppoe_setup:%s %s no %s %s %s NONE", 
            c_user, c_iface, c_dns1, c_dns2, c_password);

    //LOGD("setprop ctl.start %s", cmd);

    if (property_set("ctl.start", cmd) < 0) {
        //LOGE("Failed to start pppoe_setup");
        err = -1;
        goto end;
    }

    for (attempt = 50; attempt > 0;  attempt--) {
        property_get("net.pppoe.status", prop, "");
        if (!strcmp(prop, "setuped")) {
            break;
        }
        usleep(100000);  // 100 ms retry delay
    }
    
    if (attempt == 0) {
        //LOGE("%s: Timeout waiting for pppoe-setup", __FUNCTION__);
        err = -1;
        goto end;
    }
    err = 0;
end:
    free(cmd);
    free (prop);
    return err;
}

static jint startPppoeNative(JNIEnv* env, jobject clazz)
{
        int attempt;
        int err = 0;
        char* prop = (char *)malloc(PROPERTY_VALUE_MAX);
        
        //LOGD("%s", __FUNCTION__);
    
        if (property_set("ctl.start", "pppoe_start") < 0) {
            //LOGE("Failed to start pppoe_start");
            err = -1;
            goto end;
        }
        
        for (attempt = 300; attempt > 0;  attempt--) {
            property_get("net.pppoe.status", prop, "");
            if (!strcmp(prop, "connected")) {
                break;
            }
            usleep(100000);  // 100 ms retry delay
        }
        if (attempt == 0) {
            //LOGE("%s: Timeout waiting for pppoe-start", __FUNCTION__);
            err = -1;
            goto end;
        }
        err = 0;
end:
    free(prop);
    return err;
}

static jint stopPppoeNative(JNIEnv* env, jobject clazz)
{
    int attempt;
    int err = 0;
    char* prop = (char *)malloc(PROPERTY_VALUE_MAX);
    
    //LOGD("%s", __FUNCTION__);
    
    if (property_set("ctl.start", "pppoe_stop") < 0) {
        //LOGE("Failed to start pppoe_stop");
        err = -1;
        goto end;
    }
    
    for (attempt = 100; attempt > 0;  attempt--) {
        property_get("net.pppoe.status", prop, "");
        if (!strcmp(prop, "disconnected")) {
            property_set("ctl.stop", "pppoe_stop");
            err = 0;
            goto end;
        }
        usleep(100000);  // 100 ms retry delay
    }
    property_set("ctl.stop", "pppoe_stop");
    err = -1;
end:
    free(prop);
    return err;
}

static jint isPppoeUpNative(JNIEnv* env, jobject clazz)
{
    //LOGD("%s", __FUNCTION__);
    return 0;
}
    
/*---------------------------------------------------------------------------*/

/*
 * JNI registration.
 */
static JNINativeMethod gPppoeMethods[] = {
    /* name,                    method descriptor,                              funcPtr */
    { "setupPppoeNative",       "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I",    (void *)setupPppoeNative },
    { "startPppoeNative",       "()I",                                          (void *)startPppoeNative },
    { "stopPppoeNative",        "()I",                                          (void *)stopPppoeNative },
    { "isPppoeUpNative",        "()I",                                          (void *)isPppoeUpNative },
};

int register_android_pppoe_PppoeNative(JNIEnv* env)
{
    return AndroidRuntime::registerNativeMethods(env, "com/android/server/PppoeService", gPppoeMethods, NELEM(gPppoeMethods) );
}
	
}

 

同时,需要加载进库中(上面的CPP文件并不是单独编译出一个SO, 一个放在AndroidRuntime库中)

frameworks/base/core/jni/AndroidRuntime.cpp

extern int register_android_net_LocalSocketImpl(JNIEnv* env);
extern int register_android_net_NetworkUtils(JNIEnv* env);
extern int register_android_net_TrafficStats(JNIEnv* env);
extern int register_android_net_wifi_WifiManager(JNIEnv* env);
//$_rbox_$_modify_$_chenzhi_20120309: add register_android_pppoe_PppoeNative
extern int register_android_pppoe_PppoeNative(JNIEnv* env);//引入
extern int register_android_text_AndroidCharacter(JNIEnv *env);
extern int register_android_text_AndroidBidi(JNIEnv *env);

同时,需要加入到:
static const RegJNIRec gRegJNI[] = {
    REG_JNI(register_android_debug_JNITest),
    REG_JNI(register_com_android_internal_os_RuntimeInit),
    REG_JNI(register_android_os_SystemClock),
    REG_JNI(register_android_util_EventLog),
    REG_JNI(register_android_util_Log),
    REG_JNI(register_android_util_FloatMath),
    REG_JNI(register_android_text_format_Time),
    REG_JNI(register_android_content_AssetManager),
    REG_JNI(register_android_content_StringBlock),
    REG_JNI(register_android_content_XmlBlock),
    REG_JNI(register_android_emoji_EmojiFactory),
    REG_JNI(register_android_text_AndroidCharacter),
    REG_JNI(register_android_text_AndroidBidi),
    REG_JNI(register_android_view_InputDevice),
    REG_JNI(register_android_view_KeyCharacterMap),
    REG_JNI(register_android_os_Process),
    REG_JNI(register_android_os_SystemProperties),
    REG_JNI(register_android_os_Binder),
    REG_JNI(register_android_os_Parcel),
    REG_JNI(register_android_view_Display),
    REG_JNI(register_android_view_DisplayEventReceiver),
    REG_JNI(register_android_nio_utils),
    REG_JNI(register_android_graphics_PixelFormat),
    REG_JNI(register_android_graphics_Graphics),
    REG_JNI(register_android_view_GLES20DisplayList),
    REG_JNI(register_android_view_GLES20Canvas),
    REG_JNI(register_android_view_HardwareRenderer),
    REG_JNI(register_android_view_Surface),
    REG_JNI(register_android_view_TextureView),
    REG_JNI(register_com_google_android_gles_jni_EGLImpl),
    REG_JNI(register_com_google_android_gles_jni_GLImpl),
    REG_JNI(register_android_opengl_jni_GLES10),
    REG_JNI(register_android_opengl_jni_GLES10Ext),
    REG_JNI(register_android_opengl_jni_GLES11),
    REG_JNI(register_android_opengl_jni_GLES11Ext),
	REG_JNI(register_android_pppoe_PppoeNative),//有时会忘记
	...
中

 

2. 系统启动后,添加服务:

frameworks/base/services/java/com/android/server/SystemServer.java
@Override
    public void run() {
	...
	//添加服务
			try {
				  Slog.i(TAG, "Pppoe Service");
				  pppoe = new PppoeService(context);
				  ServiceManager.addService(Context.PPPOE_SERVICE, pppoe);
			  } catch (Throwable e) {
				  reportWtf("starting Pppoe Service", e);
			  }
//$_rbox_$_modify_$_end
            try {
                Slog.i(TAG, "Throttle Service");
                throttle = new ThrottleService(context);
                ServiceManager.addService(
                        Context.THROTTLE_SERVICE, throttle);
            } catch (Throwable e) {
                reportWtf("starting ThrottleService", e);
            }

            try {
                Slog.i(TAG, "UpdateLock Service");
                ServiceManager.addService(Context.UPDATE_LOCK_SERVICE,
                        new UpdateLockService(context));
            } catch (Throwable e) {
                reportWtf("starting UpdateLockService", e);
            }

 

添加Manager

frameworks/base/core/java/android/app/ContextImpl.java
    static {
        registerService(ACCESSIBILITY_SERVICE, new ServiceFetcher() {
                public Object getService(ContextImpl ctx) {
                    return AccessibilityManager.getInstance(ctx);
                }});

        registerService(ACCOUNT_SERVICE, new ServiceFetcher() {
                public Object createService(ContextImpl ctx) {
                    IBinder b = ServiceManager.getService(ACCOUNT_SERVICE);
                    IAccountManager service = IAccountManager.Stub.asInterface(b);
                    return new AccountManager(ctx, service);
                }});
				
		registerService(PPPOE_SERVICE, new ServiceFetcher() {
				public Object createService(ContextImpl ctx) {
					IBinder b = ServiceManager.getService(PPPOE_SERVICE);
					IPppoeManager service = IPppoeManager.Stub.asInterface(b);
					return new PppoeManager(service, ctx.mMainThread.getHandler());
				}});		
			...

 

3. 如何使用?

 

XManager mgr = (XManager)context.getSystemService(name);

 

 

ansondroider
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android添加系统service
02-25 6006
当我们的应用程序需要使用或修改android系统提供的功能时，通常的做法是自己封装接口，接口的实现放在某一个service里，这个service要么是已经存在的，要么是自定义的。然后将这个service添加到SystemServer的ServiceManager， 再在ContextImpl注册该service，并返回我们封装类的对象。
Android 系统服务一览表
张兴华的技术博客
05-01 9593
在《Zygote进程【3】——SystemServer的诞生》一文中介绍了SystemServer的诞生，本文来看一下SystemServer中初始化的系统服务。 AccountManagerServiceAccessibilityManagerService ActivityManagerService AlarmManagerService AppWidgetService
Android 11新增系统服务
a546036242的博客
03-21 2502
存放位置：frameworks\base\services\core\java\com\android\server\SystemVoiceService.java。编译后的class.jar目录\out\target\common\obj\JAVA_LIBRARIES\framework_intermediates。修改位置： frameworks\base\services\java\com\android\server。2.将.aidl文件添加到frameworks/base/Android.bp。
Android 8.1 系统多网口实现方法
08-31
修改 framework 代码，实现多个以太网连接
Android 添加系统服务的完整流程SystemService(史上最全)
最新发布
似霰的博客
05-10 2492
Android 添加系统服务的完整流程SystemService(史上最全)
Android5.0网络策略导致PPPOE无法正常上网
程序改变生活
03-21 1万+
===========================
Android实现pppoe拨号上网（一）概述
热门推荐
Hi~ xiaokeweng
04-10 1万+
最近在做Android上实现pppoe拨号上网的功能。一般情况下不大可能会用到，但在大陆某些地区，可能会有AP并不支持DHCP功能，或者在某些平台上面装载Android系统的时候，可能会需要移植拓展该功能。什么是pppoe就不再介绍了，下面对于我的实验环境搭建和操作进行简述： 个人邮箱：xiaokeweng@gmail.com （一）实验环境搭建 描述：本例是在支持wifi的
安卓4.4pppoe拨号间隔及轮次修改
weixin_43866431的博客
09-23 473
安卓4.4pppoe拨号间隔及轮次修改 最近在修改pppoe，需要调整pppoe的时间间隔，需求是第一次拨号3s无响应后，等待8s，8s后无反应再次等待8s，8s还是没有反应，进行下一轮拨号，一共拨号5轮，5轮拨号结束后返回拨号失败的提示；具体修改的文件如下（修改处为后面加注释的地方）； 1，拨号间隔的修改 externel/ppp/pppd/plugins/rp-pppoe/discovery.c ------------------------------------------------------
android 联网管理,android网络管理
weixin_36290895的博客
05-25 406
在Android系统中，不同类型的网络同时开启时，系统根据网络类型的优先级自动进行选择。1.网络优先级配置文件frameworks/base/core/res/res/values/config.xml与类NetworkConfig的成员变量一一对应，其中，第4个元素就是优先级设置值。"ethernet,9,9,0,-1,true""wifi,1,1,1,-1,true""mobile,0,0,0...
Android 添加系统服务的方法详解
08-25
Android 添加系统服务的方法详解 Android 系统服务是 Android 中非常重要的一部分，像 ActivityManagerService、PackageManagerService、WindowManagerService，这些系统服务都是 Framework 层的关键服务。本文主要...
android native实现系统服务
01-16
当需要使用C语言（Native代码）来实现系统服务时，这通常涉及到Android的JNI（Java Native Interface）技术。JNI允许Java代码与本地（非Java）代码进行交互，从而使我们能够在Android系统服务中利用C或C++的性能优势...
android系统添加系统服务
03-22
android系统添加系统服务
往Android系统中添加服务的方法教程
01-20
【Android系统服务添加教程】 在Android开发中，系统服务是应用程序与操作系统进行深度交互的关键途径。当需要在Android系统中添加新的服务时，开发者需要理解系统服务的工作原理和注册过程。以下是一个详细的教程...
Android 2.3 拨号上网流程分析--java层
09-19 7503
这篇文章是分析使用SIM卡上网功能的简单分析，并没有涉及到WIFI上网，请大家知悉. 通常，如果我们想使用SIM卡拨号上网功能，我们要在设置中进行简单的配置，步骤如下： 设置 -》无线和网络 -》移动网络 -》（已启用数据/数据漫游/接入点名称/仅使用2G网络/网络运
android开发 有线网络,Android TV开发中有线网络模块
weixin_35400275的博客
05-29 650
现在一直在做机顶盒开发，之前做过机顶盒的系统设置APK，现在特地把设置中的有线网络模块的开发思路分享下文章中介绍的API等是基于Android4.4版本的，向Android5.0以上的版本就不同了，包名有些许变化，貌似变得更简单了和有线网络相关的内容在包android.net.ethernet.EthernetManager还有拨号上网的包android.net.pppoe.PppoeManage...
Android10 Framework层添加系统服务
以后会多把工作中总结的知识、问题处理思路和方法通过博客分享出来,欢迎大家关注和共同探讨!
06-06 1674
2、在文件system/sepolicy/prebuilts/api/29.0/private/service_contexts添加如下内容。4、在文件system/sepolicy/prebuilts/api/29.0/public/service.te添加如下内容。1、在文件system/sepolicy/private/service_contexts添加如下内容。3、在文件system/sepolicy/public/service.te添加如下内容。高通865 Android10。
【android12】 添加自定义系统服务，AIDL实现HAL Service层
我不是程序员的博客
06-15 1667
系统路径：frameworks/base/core/java/android/app/IHelloWorldManager.aidl 2.添加AIDL接口实现类 系统路径：frameworks/base/core/java/android/app/HelloWorldManagerService.java 3.添加接口管理类HelloWorldManager.java 系统路径：frameworks/base/core/java/android/app/HelloWorldManager.java 4.在C
Android音频系统详解：AudioFlinger与服务架构
AudioFlinger通过`defaultServiceManager()`添加自身到系统服务列表，使其可以被其他应用程序访问。当创建AudioFlinger对象时，它会被注册为"media.audio_flinger"服务。 4. **音频硬件接口**: 在AudioFlinger的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值