Android5.1 FrameWork添加自己的SystemService提供API给APP

FrameWork从纵向来看主要就是添加Service并且利用JNI调用HAL层C/C++的代码来实现提供API给APP操作硬件的目的

本文就是描述在Android5.1如何实现添加自己的System Service来实现跟HAL进行Socket通信

一:首先先描述如何注册自己的SystemService并且实现自己的AIDL，我们这部分要实现的目标是在APP通过调用 (InfraredManager)context.getSystemService(Context.XXX) 提供API,实现InfraredManager步骤如下

1:将Binder的"客户端"部分实现在\frameworks\base\core\java\com\android\infrared\InfraredManager.java 同时创建 \frameworks\base\core\java\com\yuekong\infrared\InfraredReceptionManager.aidl

AIDL就是Binder调用的接口

package com.android.infrared;
import com.android.infrared.IOnInfraredReceivedListener;
import java.lang.String;
/**
 * Binder interface that clients running in application context
 * can use to interface with remote service
 */
interface InfraredReceptionManager {
    void sendStartLearnMsg();
 void sendLearnMsg();
 void sendStopLearnMsg();
 void sendInfo(in String info);
 void addInfraredReceivedListener(in IOnInfraredReceivedListener listener);
        void removeInfraredReceivedListener(in IOnInfraredReceivedListener listener);
}

2：binder接口创建好后，实现"服务端"的service 在\frameworks\base\services\core\java\com\yuekong\infrared\InfraredManagerService

package com.android.infrared;

import android.content.Context;
import android.widget.Toast;
import android.os.IBinder;
import com.android.server.SystemService;
import com.android.infrared.IOnInfraredReceivedListener;
import android.os.RemoteCallbackList;
import android.os.Binder;
import com.android.infrared.InfraredSocketClient.OnReceivedInfraredListener;
import android.os.RemoteException;

public class InfraredManagerService extends SystemService implements OnReceivedInfraredListener {
 
 private static final String TAG = "InfraredManagerService";
 
 private final Context mContext;
 private InfraredSocketClient mClient = null;
 private RemoteCallbackList<IOnInfraredReceivedListener> mListenersList = new  RemoteCallbackList<IOnInfraredReceivedListener>();
 
 public InfraredManagerService(Context context){
  super(context);
  mContext = context;
  publishBinderService(context.INFRARED_SERVICE, mService);
 }
 
 /**
     * Implementation of AIDL service interface
     */
    private final IBinder mService = new InfraredReceptionManager.Stub() {
  @Override
        public void sendStartLearnMsg() {
   getSocketInstance().sendSocket(CommandConstant.Command_Learn_Start);
        }
  @Override
        public void sendLearnMsg() {
   getSocketInstance().sendSocket(CommandConstant.Command_Learn_Key);
        }
  @Override
        public void sendStopLearnMsg() {
   getSocketInstance().sendSocket(CommandConstant.Command_Learn_Stop);
        }
  @Override
        public void sendInfo(String info) {
   getSocketInstance().sendSocket(info);
   Xlog.w(TAG, "stop learn mode");
        }
  
  @Override
  public void addInfraredReceivedListener(IOnInfraredReceivedListener listener){
   if(listener == null){
    return;
   }
   synchronized(mListenersList){
                mListenersList.register(listener, Binder.getCallingUserHandle());
   }
  }
  @Override
        public void removeInfraredReceivedListener(IOnInfraredReceivedListener listener){
   if(listener == null){
    return;
   }
   synchronized(mListenersList){
    mListenersList.unregister(listener);
   }  
  }
  
    };

  /**
     * Called when service is started by the main system service
     */
    @Override
    public void onStart() {
       Xlog.d(TAG, "Service start");
    getSocketInstance().startConnection();
    getSocketInstance().setInfraredReceivedListener(InfraredManagerService.this);
 
    }
 
 @Override
 public void onReceivedInfraredInfo(int mode,boolean success, int[] info){
  final int size = mListenersList.beginBroadcast();
        for (int i = 0; i < size; i++) {
            IOnInfraredReceivedListener listener = mListenersList.getBroadcastItem(i);
            try {
    Xlog.d(TAG, "binder listener call back" + listener.toString());
                listener.onInfraredReceived(mode,success, info);
            } catch (RemoteException re) {
                Xlog.d(TAG, "Callback failed ");
            }
     }
  mListenersList.finishBroadcast();
 }

    private InfraredSocketClient getSocketInstance(){
  if(mClient == null){
   mClient = new InfraredSocketClient();
  }
  return mClient;
    }
 
}

3：我们在调用SystemService的时候都会用context.getSystemService实现调用，然后我们实现自己的Manager给App调用

package com.android.infrared;

import com.android.infrared.InfraredReceptionManager;
import android.content.Context;
import android.os.RemoteException;
import java.util.ArrayList;
import java.util.List;

public class InfraredManager{
 private static final String TAG = "InfraredManager";
 private final Context mContext;
 
 private final InfraredReceptionManager mService;
 private List<InfraredReceiverListener> mCallBackList = new ArrayList<InfraredReceiverListener>();
 private IOnInfraredReceivedListener.Stub mInfraredReceivedListener;

 public InfraredManager(Context context,InfraredReceptionManager service ){
  this.mContext = context;
  this.mService = service;
 }
    public void sendStartLearnMsg() {
      try{
     if(mService != null){
   mService.sendStartLearnMsg();
     }      
        } catch (RemoteException ex){
        }
    }
 public void sendLearnMsg(){
  try{
     if(mService != null){
   mService.sendLearnMsg();  
     }  
        } catch (RemoteException ex){
        }
 }
 
 public void sendStopLearnMsg() {
     try{
     if(mService != null){
   mService.sendStopLearnMsg();  
     }  
        } catch (RemoteException ex){
        }
 }
 public void sendInfo(String info){
  try{
           mService.sendInfo(info);
        } catch (RemoteException ex){
        }
 }
 
 public void registerListerner(InfraredReceiverListener listener){
  synchronized(this){
   if(mCallBackList != null && listener != null && !callBackContain(mCallBackList,listener)){
    mCallBackList.add(listener);
    boolean addedFirstCallback = (mCallBackList.size() == 1);
    if(addedFirstCallback){
      try {
                      mService.addInfraredReceivedListener(getInstance());
                    } catch (RemoteException re) {                    
     
     }

    }

   }
  }
 }

 private boolean callBackContain( List<InfraredReceiverListener> callBackList,InfraredReceiverListener listener){

  if( callBackList.size() == 0 ){
           return false;
  }
  for(int i = 0 ; i < callBackList.size(); i++ ){

   Xlog.d(TAG, "register listener has this : " +listener.toString());
   if(callBackList.get(i) == listener ){

                 return true;
   }

  }

       return false;
 }
 
 
    public void unregisterListener(InfraredReceiverListener listener) {
   if(listener == null){
    return;
   }
   synchronized (this) {
          final int size = mCallBackList.size();
          for (int i = 0; i < size; ++i) {
            if (mCallBackList.get(i) == listener) {
    Xlog.d(TAG, "unregister listener :" +listener.toString());
                mCallBackList.remove(i);
    Xlog.d(TAG, "after unregieter size :" + mCallBackList.size());
               return;
            }
           }

    if(mCallBackList.size() == 0 && mInfraredReceivedListener != null){
       try{
              mService.removeInfraredReceivedListener(mInfraredReceivedListener);
       }catch(RemoteException re){

       
       }
     Xlog.d(TAG, "unregister binder listener :" +mInfraredReceivedListener.toString());
     mInfraredReceivedListener = null;
    }
    
        }
 }

 
 
 
 public static abstract class InfraredReceiverListener{
  abstract public void onInfraredReceived(int mode,boolean isSuccess,int[] info);
  
 }


   private IOnInfraredReceivedListener.Stub getInstance(){
     if(mInfraredReceivedListener == null){

   mInfraredReceivedListener =  new IOnInfraredReceivedListener.Stub() {
  @Override
  public void onInfraredReceived(int mode,boolean isSuccess,int[] info){
     synchronized (InfraredManager.this) {
                for (UCONInfraredReceiverListener listener : mCallBackList) {
      Xlog.d(TAG, "start call back listener " + listener.toString());
                  listener.onInfraredReceived(mode,isSuccess,info);
                }
     }
   }
      };
      }
     Xlog.d(TAG, "create binder listener name is " + mInfraredReceivedListener.toString());
  return mInfraredReceivedListener;
    }


 
 
 
}

4:这边Binder的客户端和服务端实现结束，还要在系统的ServiceManager注册自己的SystemService 在frameworks/base/core/java/android/app/ContextImpl.java

        //add by zhongqi.shao on 2016-08-05 start
        registerService(INFRARED_SERVICE, new ServiceFetcher() {
            public Object createService(ContextImpl ctx) {
                IBinder b = ServiceManager.getService(INFRARED_SERVICE);
                InfraredReceptionManager uconInfraredService =
                        InfraredReceptionManager.Stub.asInterface(b);
                if (InfraredService != null) {
                    return new InfraredManager(ctx,InfraredService);
                } else {
                    // not supported
                    return null;
                }
            }
        });
        //add by zhongqi.shao on 2016-08-05 end

</pre><pre code_snippet_id="1978267" snippet_file_name="blog_20161110_6_4875789" name="code" class="java">这一步就可以实现在framework添加自己的SystemService

Android5.1 FrameWork添加自己的SystemService提供API给APP

浏览过的版块