Binder机制5--- Binder实现进程管理服务示例

最新推荐文章于 2024-11-14 21:05:44 发布
最新推荐文章于 2024-11-14 21:05:44 发布
阅读量321 收藏
点赞数
分类专栏： 2.Android ----进程间通信 文章标签： android 通信

来源 http://blog.csdn.net/bathinbreeze/article/details/8994825

6. 用eclipse实现PMService

PMservice是一个通过Service服务，来实现任务管理的程序。分为客户端PMClient和服务端PMService。

PMService提供一些操作方法：

  • 服务开始的提示方法：getVal();

  • 任务管理器的查询方法：getProcessID() 获取进程号，和getProcessName()获取进程名；

  • 以及终止进程的方法：killProc(String ID)，来提供服务给客户端。

PMClient使用PMService所提供的服务，来调用这些方法实现业务逻辑，并提供显示界面。


对于PMService的实现

  1. 通过ActivityManager activityManager = (ActivityManager) getSystemService("activity"); 获得activityService

  2. 编写aidl文件，eclipse会自动生成相应的Stub和Proxy的接口实现

对于PMClient的实现

  1. 复制PMService的aidl文件，eclipse会为PMClient生成相应的接口实现

  2. 通 过在ServiceConnection:: onServiceConnected()中，PMService = IPMService.Stub.asInterface(service); 获得PMService创建的 PMServiceProxy(new BinderProxy());  并把这个proxy对象保存在PMService中

  3. 在onCreate()方法中，调用bindService(new Intent(IPMService.class.getName()),serConn, Context.BIND_AUTO_CREATE);

其中， serConn 是ServiceConnection类的实例化，传递的是PMService对象，这里是把当前类的PMService与PMService那边的PMService绑定在一起，这样就实现了两个进程的通信了


实现流程分析

  1. 调用的时候，客户端首先调用bindService(new Intent (IPMService.class.getName(), serConn,Context.BIND_AUTO_CREATE);激活serviceConnection的onServiceConnected 方法，在此方法中获取到一个binder,这个binder是系统给我们的一个与远程进行通信的binder，此binder能够查找系统中注册的 service，如果没有查找到该Service,那么可认定该service是从其他apk获得的，就创建一个此service的静态代理类 Proxy，否则，就把这个service返回，供客户端调用。

  2. 服务端收到这个Intent后，激活PMServiceImpl extends IPMService.Stub的onBind方法，创建一个Binder返回 （return new PMServiceImpl()）。之后，这个Binder负责与客户端的Proxy通信。

源码流程：

PMService的源码

在eclipse新建PMServer工程，我用的是android 4.2.2

先列出PMServer工程的文件清单，其中IPMService.java是通过IPMService.aidl自动创建的


下面是各个文件的源码：

IPMService.aidle

 
 
  1. package com.example.pmserver;
  2.  
  3.  
  4.  
  5.  
  6. interface IPMService
  7. {
  8.     double getVal(String val);
  9.     List<String> getProcessName();
  10.     List<String> getProcessID();
  11.     String killProc(String PID);
  12. }

把这个文件放入到我们工程的com.example.pmserver包中，系统会自动生成IPMService.java


为了实现进程信息的查询，我们需要CommandHelper.java这个类，通过API执行shell语言的方式来收集我们需要的进程信息。

CommandHelper.java

 
 
  1. package com.example.pmserver;
  2.  
  3. import com.example.pmserver.CommandResult;
  4.  
  5. import java.io.BufferedReader;
  6. import java.io.IOException;
  7. import java.io.InputStreamReader;
  8.  
  9. /**
  10.  *
  11.  * 
  12.  */
  13. public class CommandHelper {
  14.  
  15.     //default time out, in millseconds
  16.     public static int DEFAULT_TIMEOUT;
  17.     public static final int DEFAULT_INTERVAL = 1000;
  18.     public static long START;
  19.  
  20.  
  21.     public static CommandResult exec(String command) throws IOException, InterruptedException {
  22.         Process process = Runtime.getRuntime().exec(command);
  23.         CommandResult commandResult = wait(process);
  24.         if (process != null) {
  25.             process.destroy();
  26.         }
  27.         return commandResult;
  28.     }
  29.  
  30.     private static boolean isOverTime() {
  31.         return System.currentTimeMillis() - START >= DEFAULT_TIMEOUT;
  32.     }
  33.  
  34.     private static CommandResult wait(Process process) throws InterruptedException, IOException {
  35.         BufferedReader errorStreamReader = null;
  36.         BufferedReader inputStreamReader = null;
  37.         try {
  38.             errorStreamReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
  39.             inputStreamReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  40.  
  41.             //timeout control
  42.             START = System.currentTimeMillis();
  43.             boolean isFinished = false;
  44.  
  45.             for (;;) {
  46.                 if (isOverTime()) {
  47.                     CommandResult result = new CommandResult();
  48.                     result.setExitValue(CommandResult.EXIT_VALUE_TIMEOUT);
  49.                     result.setOutput("Command process timeout");
  50.                     return result;
  51.                 }
  52.  
  53.                 if (isFinished) {
  54.                     CommandResult result = new CommandResult();
  55.                     result.setExitValue(process.waitFor());
  56.                     
  57.                     //parse error info
  58.                     if (errorStreamReader.ready()) {
  59.                         StringBuilder buffer = new StringBuilder();
  60.                         String line;
  61.                         while ((line = errorStreamReader.readLine()) != null) {
  62.                             buffer.append(line);
  63.                         }
  64.                         result.setError(buffer.toString());
  65.                     }
  66.  
  67.                     //parse info
  68.                     if (inputStreamReader.ready()) {
  69.                         StringBuilder buffer = new StringBuilder();
  70.                         String line;
  71.                         while ((line = inputStreamReader.readLine()) != null) {
  72.                             buffer.append(line);
  73.                         }
  74.                         result.setOutput(buffer.toString());
  75.                     }
  76.                     return result;
  77.                 }
  78.  
  79.                 try {
  80.                     isFinished = true;
  81.                     process.exitValue();
  82.                 } catch (IllegalThreadStateException e) {
  83.                     // process hasn't finished yet
  84.                     isFinished = false;
  85.                     Thread.sleep(DEFAULT_INTERVAL);
  86.                 }
  87.             }
  88.  
  89.         } finally {
  90.             if (errorStreamReader != null) {
  91.                 try {
  92.                     errorStreamReader.close();
  93.                 } catch (IOException e) {
  94.                 }
  95.             }
  96.  
  97.             if (inputStreamReader != null) {
  98.                 try {
  99.                     inputStreamReader.close();
  100.                 } catch (IOException e) {
  101.                 }
  102.             }
  103.         }
  104.     }
  105. }


下面，需要提供一些操作的接口，以便调用 CommandResult.java

 
 
  1. package com.example.pmserver;
  2.  
  3. public class CommandResult {
  4.     public static final int EXIT_VALUE_TIMEOUT=-1;
  5.     
  6.     private String output;
  7.  
  8.     void setOutput(String error) {
  9.         output=error;
  10.     }
  11.  
  12.     String getOutput(){
  13.         return output;
  14.     }
  15.  
  16.     int exitValue;
  17.  
  18.     void setExitValue(int value) {
  19.         exitValue=value;
  20.     }
  21.  
  22.     int getExitValue(){
  23.         return exitValue;
  24.     }
  25.  
  26.     private String error;
  27.  
  28.     /**
  29.      * @return the error
  30.      */
  31.     public String getError() {
  32.         return error;
  33.     }
  34.  
  35.     /**
  36.      * @param error the error to set
  37.      */
  38.     public void setError(String error) {
  39.         this.error = error;
  40.     }
  41. }


接下来，就是我们Service的核心文件了，实现了业务逻辑。
PMService.java

 
 
  1. package com.example.pmserver;
  2.  
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import com.example.pmserver.CommandHelper;
  8. import com.example.pmserver.CommandResult;
  9. import android.os.IBinder;
  10. import android.os.RemoteException;
  11. import android.app.ActivityManager;
  12. import android.app.ActivityManager.RunningAppProcessInfo;
  13. import android.app.Service;
  14. import android.content.Intent;
  15. import android.util.Log;
  16.  
  17. public class PMService extends Service {
  18.  
  19.      private static final String TAG = "PMService"; 
  20.      
  21.      List<String> ProcName = new ArrayList<String>();
  22.      List<String> ProcID = new ArrayList<String>();
  23.  
  24.         public class PMServiceImpl extends IPMService.Stub {  
  25.  
  26.             @Override  
  27.             public double getVal(String val) throws RemoteException {            
  28.                 Log.v(TAG, "getVal() called for " + val);  
  29.                 return 1.0;  //test the binder transaction is ok between c/s
  30.             }        
  31.                         
  32.             public List<String> getProcessName() {
  33.                 
  34.                 List<RunningAppProcessInfo> procList = this.getProcessInfo();    //get process info
  35.                 int j = 0;
  36.                 Iterator<RunningAppProcessInfo> iterator = procList.iterator();
  37.                 
  38.                 if(iterator.hasNext()) {
  39.                     do {
  40.                         RunningAppProcessInfo procInfo = iterator.next(); 
  41.               
  42.                         Log.v("ProcInfo", "ProcName = " + procInfo.processName);
  43.                         
  44.                         ProcName.add(procInfo.processName);                        
  45.                         //ProcID.add(Integer.toString(procInfo.pid));
  46.                         
  47.                         Log.v("ProcName", "ProcName = " + ProcName.get(j++));
  48.                         
  49.                     }while(iterator.hasNext());
  50.                 }
  51.  
  52.                 return ProcName;
  53.             }
  54.             
  55.             public List<String> getProcessID() {
  56.                 
  57.                 List<RunningAppProcessInfo> procList = this.getProcessInfo();
  58.                 int i = 0;                
  59.                    Iterator<RunningAppProcessInfo> iterator = procList.iterator();
  60.             
  61.                 if(iterator.hasNext()) {
  62.                     do {
  63.                         RunningAppProcessInfo procInfo = iterator.next(); 
  64.  
  65.                         Log.v("ProcInfo","ProcID = " + procInfo.pid);
  66.  
  67.                         ProcID.add(String.valueOf(procInfo.pid));
  68.                         //ProcID.add(Integer.toString(procInfo.pid));
  69.                         
  70.                         Log.v("ProcName", "ProcID = " + ProcID.get(i++));
  71.                         
  72.                     }while(iterator.hasNext());
  73.                 }
  74.        
  75.                 return ProcID;
  76.             }
  77.             
  78.             @Override
  79.             public String killProc(String PID) throws RemoteException {
  80.                 // TODO Auto-generated method stub
  81.                 String cmd = "kill -9 "+PID;
  82.                 String reply = "";
  83.                 
  84.                 Log.v("cmd",cmd);
  85.                 try {
  86.                     
  87.                     CommandHelper.DEFAULT_TIMEOUT = 5000;
  88.                     CommandResult result = CommandHelper.exec(cmd);
  89.                     if (result != null) {
  90.                         if(result.getError()!=null)
  91.                         {
  92.                             Log.v("Output","Error:" + result.getError());
  93.                             reply = result.getError();
  94.                         }
  95.                         if(result.getOutput()!=null)
  96.                         {
  97.                             Log.v("Output","Output:" + result.getOutput());        
  98.                             reply = result.getOutput();
  99.                         }
  100.                     }
  101.                     
  102.                 } catch (IOException ex) {
  103.                     Log.v("Output","IOException:" + ex.getLocalizedMessage());
  104.                 } catch (InterruptedException ex) {
  105.                     Log.v("Output","InterruptedException:" + ex.getLocalizedMessage());
  106.                 }
  107.                 return reply;
  108.                 
  109.                 
  110.             }
  111.             
  112.             public  void exec(String command) throws IOException, InterruptedException {
  113.                 // Process process = Runtime.getRuntime().exec(command);
  114.                  Runtime.getRuntime().exec(command);             
  115.                  return ;
  116.              }
  117.         
  118.             public List<RunningAppProcessInfo> getProcessInfo() {
  119.                 List<RunningAppProcessInfo> procList = new ArrayList<RunningAppProcessInfo>();
  120.                 
  121.                // ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
  122.                 ActivityManager activityManager = (ActivityManager) getSystemService("activity");
  123.                 procList = activityManager.getRunningAppProcesses();
  124.            
  125.                 return procList;
  126.             }
  127.         }  
  128.         
  129.         @Override  
  130.         public void onCreate() {  
  131.             super.onCreate();  
  132.             Log.v(TAG, "onCreate called");  
  133.         }  
  134.       
  135.         @Override  
  136.         public void onDestroy() {  
  137.             super.onDestroy();  
  138.             Log.v(TAG, "onDestory() called");  
  139.         }  
  140.       
  141.         @Override  
  142.         public void onStart(Intent intent, int startId) {  
  143.             super.onStart(intent, startId);  
  144.             Log.v(TAG, "onStart() called");  
  145.         }  
  146.       
  147.         @Override  
  148.         public IBinder onBind(Intent intent) {  
  149.             Log.v(TAG, "onBind() called");  
  150.             return new PMServiceImpl();  
  151.         }  
  152.  
  153. }

AndroidManifest.xml配置文件

 
 
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="com.example.pmserver"
  4.     android:versionCode="1"
  5.     android:versionName="1.0" >
  6.  
  7.     <uses-sdk
  8.         android:minSdkVersion="8"
  9.         android:targetSdkVersion="17" />
  10.  
  11.     <application
  12.         android:allowBackup="true"
  13.         android:icon="@drawable/ic_launcher"
  14.         android:label="@string/app_name"
  15.         android:theme="@style/AppTheme" >
  16.         <service
  17.             android:name="com.example.pmserver.PMService"
  18.             android:label="@string/app_name" >
  19.             <intent-filter>
  20.                 <action android:name="com.example.pmserver.IPMService" />
  21.             </intent-filter>
  22.         </service>
  23.     </application>
  24.  
  25. </manifest>

Service这边不需要显示操作，界面的配置就不需要了。这样，Service这边就OK了。


PMClient的源码

这个是PMClient工程的文件清单，


IPMService.aidl直接从PMService中拷贝过来就好，这里就不列出了。同样，会自动生成IPMService.java

CommandHelper.java和CommandResult.java这里不需要（这里，我只是做测试之用），不需要添加，在com.example.pmclient中，只需添加PMClientActivity.java即可。

PMClientActivity.java

 
 
  1. package com.example.pmclient;
  2.  
  3. import com.example.pmserver.IPMService;
  4. import com.example.pmclient.CommandHelper;
  5. import com.example.pmclient.CommandResult;
  6.  
  7. import java.io.IOException;
  8. import java.util.ArrayList;
  9. import java.util.HashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12. import android.os.Bundle;
  13. import android.os.IBinder; 
  14. import android.app.Activity;
  15. import android.view.View;
  16. import android.widget.AdapterView;
  17. import android.widget.ListView;
  18. import android.widget.SimpleAdapter;
  19. import android.content.ComponentName;  
  20. import android.content.Context;  
  21. import android.content.Intent;  
  22. import android.content.ServiceConnection;  
  23. import android.os.RemoteException;  
  24. import android.util.Log;  
  25. import android.widget.Toast;
  26. import android.widget.AdapterView.OnItemClickListener;
  27.  
  28. public class PMClientActivity extends Activity {
  29.  
  30.          protected static final String TAG = "TestaidlClient";  
  31.         private IPMService PMService = null;  
  32.  
  33.         @Override  
  34.         public void onCreate(Bundle savedInstanceState) {  
  35.             super.onCreate(savedInstanceState);  
  36.           
  37.             setContentView(R.layout.list_main);   
  38.             bindService(new Intent(IPMService.class.getName()),serConn, Context.BIND_AUTO_CREATE);          
  39.         }  
  40.         
  41.         public void onDestroy(){
  42.             super.onDestroy();  
  43.             Log.v(TAG, "onDestory() called");  
  44.             unbindService(serConn);  
  45.         }
  46.       
  47.         private void callService() {  
  48.             try {  
  49.                 double val = PMService.getVal("Liang");  
  50.                 if(val == 1.0)    {
  51.                     Toast.makeText(this, "Service is ready!",  
  52.                         Toast.LENGTH_LONG).show();  
  53.                 }
  54.                 setNameID(PMService.getProcessID(), PMService.getProcessName());
  55.                 
  56.             } catch (RemoteException e) {  
  57.                 Log.e("MainActivity", e.getMessage(), e);  
  58.             }  
  59.         }  
  60.       
  61.         private ServiceConnection serConn = new ServiceConnection() {  
  62.             // 此方法在系统建立服务连接时调用  
  63.             @Override  
  64.             public void onServiceConnected(ComponentName name, IBinder service) {  
  65.                 Log.v(TAG, "onServiceConnected() called");  
  66.                 PMService = IPMService.Stub.asInterface(service);  
  67.                 callService();  
  68.             }  
  69.       
  70.             // 此方法在销毁服务连接时调用  
  71.             @Override  
  72.             public void onServiceDisconnected(ComponentName name) {  
  73.                 Log.v(TAG, "onServiceDisconnected()");  
  74.                 PMService = null;  
  75.             }  
  76.         };  
  77.         
  78.         
  79.         public void setNameID(final List<String> ProcID, final List<String> ProcName) {            
  80.             //绑定Layout里面的ListView  
  81.             ListView list = (ListView) findViewById(R.id.ListView01); 
  82.             
  83.             //每个list里面放的都是MAP，map里面放的是键值对
  84.             ArrayList<Map<String, String>> Items = new ArrayList<Map<String, String>>();
  85.             
  86.             //把该显示的内容放到list中
  87.             for (int i = 0; i < ProcID.size(); i++)
  88.             {
  89.                 Map<String, String> item = new HashMap<String, String>();
  90.                 String PIDbuf = "PID: "+ProcID.get(i);
  91.                 item.put("ProcID", PIDbuf);
  92.                 String PNamebuf = "PName: "+ProcName.get(i);
  93.                 item.put("ProcName", PNamebuf);
  94.                 Items.add(item);
  95.             }
  96.             
  97.             //构建适配器Adapter,将数据与显示数据的布局页面绑定
  98.             final SimpleAdapter simpleAdapter = new SimpleAdapter(this, Items,
  99.             R.layout.list_proc_info, new String[]{ "ProcID", "ProcName" },
  100.             new int[]{ R.id.ProcID,  R.id.ProcName});
  101.             
  102.             //通过setAdapter()方法把适配器设置给ListView
  103.             list.setAdapter(simpleAdapter);
  104.             
  105.             list.setOnItemClickListener(new OnItemClickListener() {                    
  106.                 @Override
  107.                 public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,
  108.                         long arg3) {
  109.                     // TODO Auto-generated method stub    
  110.                     String result = "";
  111.                     
  112.                     Log.v("ClickInfo", "arg0 = " + arg0 + "arg1 = " + arg1 + " arg2 = " + arg2 +" arg3 = " + arg3);
  113.                     
  114.                     //arg2 放的是process的name        
  115.                     try {
  116.                         result = PMService.killProc(ProcID.get(arg2));
  117.                     } catch (RemoteException e) {
  118.                         // TODO Auto-generated catch block
  119.                         e.printStackTrace();
  120.                     }
  121.                     if(result == null)
  122.                     {
  123.                         result = "success!";
  124.                     }
  125.                     
  126.                     ToastMSG(result);
  127.                     
  128.                     //刷新页面
  129.                     simpleAdapter.notifyDataSetChanged();    
  130.                 }  
  131.             });  
  132.             
  133.                 
  134.         }
  135.         
  136.         public void ToastMSG(String info)
  137.         {
  138.             Toast.makeText(this, "Info: " + info,  
  139.                     Toast.LENGTH_LONG).show();            
  140.         }
  141.                      
  142. }

再来看布局的设置,一共有2个布局文件，在res/layout/中： list_main.xml

 
 
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout   
  3.     android:id="@+id/LinearLayout01"   
  4.     android:layout_width="fill_parent"   
  5.     android:layout_height="fill_parent"   
  6.     xmlns:android="http://schemas.android.com/apk/res/android">  
  7. <ListView android:layout_width="wrap_content"   
  8.           android:layout_height="wrap_content"   
  9.           android:id="@+id/ListView01"  
  10.           android:background="#A9A9A9"/>
  11. </LinearLayout>

list_proc_info.xml

 
 
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!--   <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.          android:orientation="horizontal"
  4.          android:layout_width="fill_parent"
  5.          android:layout_height="wrap_content">
  6.           <TextView android:id="@+id/ProcID"
  7.              android:layout_width="wrap_content"
  8.              android:layout_height="fill_parent"
  9.              android:textSize="16dp"
  10.              android:gravity="center_vertical"
  11.              android:paddingLeft="10dp" />
  12.       
  13.          <TextView android:id="@+id/ProcName"
  14.              android:layout_width="wrap_content"
  15.              android:layout_height="fill_parent"
  16.              android:textSize="16dp"
  17.              android:gravity="center_vertical"
  18.              android:paddingLeft="10dp" />
  19.       
  20.      </LinearLayout>
  21. -->         
  22.     <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  23.         android:orientation="horizontal"
  24.         android:layout_width="fill_parent"
  25.         android:layout_height="fill_parent"
  26.         >
  27.  
  28.  
  29.     <ImageView android:id="@+id/Procimg"
  30.         android:layout_width="wrap_content"
  31.         android:layout_height="wrap_content"
  32.         android:layout_margin="5px"
  33.         android:src="@drawable/ic_launcher"/>
  34.  
  35.     <LinearLayout android:orientation="vertical"
  36.         android:layout_width="wrap_content"
  37.         android:layout_height="wrap_content">
  38.  
  39.         <TextView android:id="@+id/ProcID"
  40.             android:layout_width="wrap_content"
  41.             android:layout_height="wrap_content"
  42.             android:textColor="#FFFFFFFF"
  43.             android:textSize="40px" />
  44.         <TextView android:id="@+id/ProcName"
  45.             android:layout_width="wrap_content"
  46.             android:layout_height="wrap_content"
  47.             android:textColor="#FFFFFFFF"
  48.             android:textSize="30px" />
  49.  
  50.     </LinearLayout>
  51.  
  52.  
  53. </LinearLayout>


最后，是配置文件：

AndroidManifest.xml

 
 
  1. <?xml version="1.0" encoding="utf-8"?>
  2.  
  3. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  4.     
  5.     package="com.example.pmclient"
  6.     android:versionCode="1"
  7.     android:versionName="1.0" >
  8.  
  9.     <uses-sdk
  10.         android:minSdkVersion="8"
  11.         android:targetSdkVersion="17"
  12.         android:sharedUserId="android.uid.system" />
  13.  
  14.     <application
  15.         android:allowBackup="true"
  16.         android:icon="@drawable/ic_launcher"
  17.         android:label="@string/app_name"
  18.         android:theme="@style/AppTheme" >
  19.         <activity
  20.             android:name="com.example.pmclient.PMClientActivity"
  21.             android:label="@string/app_name" >
  22.             <intent-filter>
  23.                 <action android:name="android.intent.action.MAIN" />
  24.  
  25.                 <category android:name="android.intent.category.LAUNCHER" />
  26.             </intent-filter>
  27.         </activity>
  28.     </application>
  29.  
  30. </manifest>

关于布局文件的字段名（@XXX），这里没有给出对应的配置文件，因为太简单了！请大家自行设置。


大功告成了！上效果图！




界面比较简单，单击对应的进程即可杀掉进程。这里由于Service的权限不够，导致进程不能结束。另外，杀掉进程后(可以尝试杀掉PMService自己，界面会自刷新）。

gogolaile
关注
专栏目录
Binder (二) binder 机制的管理者的角色Service Manager
gbmaotai的博客
12-10 352
binder 机制的管理者的角色Service Manager Service Manager进程负责管理client server角色， 上下文管理者context_manager BINDER_SET_CONTEXT_MGR int binder_become_context_manager(struct binder_state *bs) { return ioctl(bs->...
android binder机制之——（我是binder实例）
热门推荐
ylyuanlu的专栏
07-27 2万+
Binder应用实例        前一篇文章我们从进程的C/C++层面讲解了binder机制的服务代理对象BpBinder的获取，和Binder底层处理方法。整个服务代理的获取过程也是binder机制的的核心内容，它涉及到了客户请求，请求的传递和处理，服务代理的生成和转换（封装
从示例了解 Binder 机制
BillionLeeGogogo
01-30 232
Binder 是 Android 实现跨进程通信（IPC）的一种手段，Android 中每个应用都运行个独自的进程中，每个应用想要正常工作都需要系统服务提供支持，它们之间的信息传递就是基于 Binder 实现。只是因为 Android 对 Binder 层层封装起来普通开发任务接触不到 Binder 层面的接口，所以 Binder 才显示有点神秘。本篇文章将从 Service 组件做为起点，用实例...
Android Binder 机制 实例分析
zhujiangtaotaise的专栏
09-29 802
前言 这里将讲述Binder机制的框架以及它是如何进行IPC通信的。 一、Binder架构的组成 1.1.Binder 框架 有3个方面组成： Binder服务端、Binder驱动以及客户端组成。 Binder服务端：Binder 服务端实际上就是一个Binder 对象，该对象一旦创建就会开启一个隐藏的线程，该线程用来接收 Binder 驱动发送的消息，然后执行 onTransact函数，并根据 ...
跨进程通信而已，有这么难懂吗？
郭霖
10-28 284
/ 今日科技快讯 /近日，国家对区块链技术进进行了定位，提出了“必须走在区块链发展前列”的目标，发力探索区块链+在民生领域与公共服务上的运用。受此利好，许多区块链...
android-binder-demo-with-vibrator
06-28
在Android系统中，Binder是进程间通信（IPC，Inter-Process Communication）的主要机制，它允许不同应用程序或系统服务之间安全高效地交换数据。本示例"android-binder-demo-with-vibrator"聚焦于如何通过Binder接口...
binder-c.zip
04-09
学习这个示例可以帮助开发者理解Binder机制的工作原理，从而更好地在Android系统中实现进程间的通信。对于Android系统的开发者，尤其是那些希望深入理解底层机制的开发者来说，这是非常宝贵的学习资源。通过实际编写...
aidl跨进程通信demo,亲测可用,binder机制,改完bug
07-16
其中，Android Interface Definition Language（AIDL）是一种强大的工具，它允许开发者定义服务接口，使得服务可以在不同的进程中调用，实现了基于Binder机制的跨进程通信。本示例"Aidl跨进程通信demo"就是对这一...
system process ------hw binder------ vendor process 实现的简单例子，请把实现代码写出来
05-23
这里是一个简单的例子，...其中，IVendorService.h 文件中定义了 IVendorService 接口和 BnVendorService 类，分别表示厂商进程提供的服务接口和服务实现类。这些接口和类的实现不在本示例中给出，读者可以自行实现。
Android Binder C/C++层实现示例
01-15
在Android系统中，Binder是进程间通信（IPC，Inter-Process Communication）的主要机制，它使得应用程序和服务能够跨进程共享数据和执行操作。本示例"Android Binder C/C++层实现示例"着重展示了如何在C/C++层面进行...
Binder简单实例
lansehai的专栏
05-31 6261
       Binder通信是Android用的比较多的一种通信机制，它是一种client-server的通信结构。Binder通信具有以下特点：1、用驱动程序来推进进程间的通信；2、可以通过共享内存的方式来提供性能；3、 可以为进程请求分配每个进程的线程池；4、针对系统中的对象引入了引用计数和跨进程的对象引用映射；5、可以方便的进行进程同步调用。Binder方面的资料网上非常多，单对于初学者来...
Android Binder机制完全解析
Watson的博客
10-29 1万+
概述之前我写过一篇文章Android Service全面解析，简单实现了如何通过AIDL实现Service的跨进程通信（IPC），其实是通过Binder机制来实现的，本文我们就重点来看看Binder机制的原理。Binder可以提供系统中任何程序都可以访问的全局服务。这个功能当然是任何系统都应该提供的，下面我们简单看一下Android的Binder的框架： Android Binder框架分为服务器
binder 一个简单的c++服务的实现，与callback实现
The simple, The best.
08-17 5295
研究了android binder 有两天了，感觉这是一个简单易用的东西，也许以后在非android的应用环境中也可以使用这种IPC方案，所以把一些学习记录下来，以将来备用. 今天主要是实现了一个简单的c++ service服务程序，客户端通过binder呼叫服务上的，已经注册的接口函数。并在客户端实现了一个callback接口。 关于callback的接口这个例子只是一个简单的实现。估计
【android系统】binder通信机制--记一次项目开发中用到的实例
看图的博客
08-23 794
自己把自己坑了一把，在一篇文章中说到，如果有盆友需要就分享一篇binder机制的文章。时隔好多年了似的，我都忘了这事了，今天居然真有需要的。首先感谢盆友的信任，其次正好我去年写了一个binder机制的实例，正好总结总结。 再次欢迎大家在公众号上来给我们留言，交流技术上的问题。 首先这篇文章不说binder机制的原理，如果盆友需要可以看看这一篇文章。这算一篇笔记吧，记一下项目中用到的bi...
Binder进程间通信机制（图文解析）
omyrobin的专栏
12-19 1万+
前言本来想洋洋洒洒写一篇形象生动的Binder原理的文章，再配上我这个灵魂画手的图画，但是再经过了1个多星期的学习后，我决定了，我自首，我这太年少了 我，太懵懂了，我没成想这Binder机制这么厉害！作为一名Android开发，常年使用java开发的人来说，C实在是太不友好了…..但是Binder机制对于整个Android系统来说，你难道没有感觉到，Binder是多么地重要~~所以我作为一名Andr...
Android Binder实战开发指南Native层获取Process进程名和调用者的进程名
IT先森
07-11 2102
Android Binder实战开发指南Native层获取Process进程名和调用者的进程名 在Native Binder Service开发中有时希望获取Process进程名和调用者的进程名，进而做一些权限方面的限制,譬如值允许某一个进程名使用或者调用。下面代码展示了如何做到上述的要求。 一.Native Binder Service开发中获取Pro...
binder实现例程
HZero
09-10 352
1. 前言 本文的主要示例来自 3分钟带你看懂android中的Binder机制， 要实现binder通信，基本要实现如下的工作： 1.定义接口服务 是服务端要具备的能力来提供给客户端,定义一个接口继承IInterface，代表了服务端的能力 public interface PersonManger extends IInterface { void addPerson(Person mPerson); List<Person> getPersonList(); } 2. 定
20241114给荣品PRO-RK3566开发板刷Rockchip原厂的Android13下适配RJ45以太网卡
最新发布
南岭笑笑生之家
11-14 476
很艰难地得知/根据经验/很容易知道RJ45以太网卡的DTS代码块在这里：rp-gmac1-m0-pro-rk3566.dtsi。实在没有办法，只能将荣品的SDK：rk-android13-20240713.tgz。很艰难地得知/根据经验/很容易知道是显示部分影响了RJ45以太网卡。从中析取最小的DTS，然后拿掉不用的部分，比如LCD/TP等。缘起：使用EVB2的方案，RJ45加进去怎么也不通。于是用荣品的DTS和原厂的EVB2的DTS进行比对。2、iperf3不能连接，原因待查。
深入解析Android Binder机制（C++实现）
通过分析`frameworks\base\include\media`和`frameworks\base\media`目录下的代码，可以了解到如何在C++层使用Binder实现服务和客户端的交互。例如，媒体服务可能会通过Binder接口提供播放、暂停、停止等控制功能，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值