2. 程式人生 > >Android利用Binder進行通訊

Android利用Binder進行通訊

阿新 • • 發佈：2018-11-03

Android利用Binder進行通訊

Binder作為Android使用最廣泛的IPC通訊機制之一，其重要性不言而喻。Binder的實現思想與原理各路大神已經分析的十分透徹了，個人覺得最好以及最詳細的是老羅的Android之旅系列裡面關於Binder的講解：

[ Android程序間通訊（IPC）機制Binder簡要介紹和學習計劃]

Binder作為一種高效的IPC通訊手段，其使用也十分的簡單，本文參考Android MediaPlay的架構實現了一個簡單的server與client通訊Demo，具體程式碼結構如下：
這裡寫圖片描述

程式碼結構：

├── AndroidClient
│   ├── AndroidManifest.xml
│   ├── Android.mk
│   ├── jni
│   │   ├── Android.mk
│   │   ├── com_test_androidclient_MainActivity.cpp
│   │   └── com_test_androidclient_MainActivity.h
│   ├── proguard-project.txt
│   ├── project.properties
│   ├── res
│   │   ├── drawable-hdpi
│   │   │   └── ic_launcher.png
│   │   ├── drawable-ldpi
│   │   ├── drawable-mdpi
│   │   │   └── ic_launcher.png
│   │   ├── drawable-xhdpi
│   │   │   └── ic_launcher.png
│   │   ├── layout
│   │   │   └── activity_main.xml
│   │   ├── menu
│   │   │   └── main.xml
│   │   ├── values
│   │   │   ├── dimens.xml
│   │   │   ├── strings.xml
│   │   │   └── styles.xml
│   │   ├── values-v11
│   │   │   └── styles.xml
│   │   ├── values-v14
│   │   │   └── styles.xml
│   │   └── values-w820dp
│   │       └── dimens.xml
│   └── src
│       └── com
│           └── test
│               └── androidclient
│                   └── MainActivity.java
├── Android.mk
├── client
│   ├── MyClient.cpp
│   └── test.cpp
├── include
│   ├── IMyService.h
│   ├── MyClient.h
│   └── MyService.h
└── server
    ├── IMyService.cpp
    ├── main_myserver.cpp
    └── MyService.cpp

IMyService.h中宣告Service端BnMyService與Client端代理BpMyService以及三個函式

#ifndef ANDROID_IMYSERVICE_H
#define ANDROID_IMYSERVICE_H
#include <utils/Errors.h>
#include <binder/IInterface.h>
#include <binder/Parcel.h>
#include <stdint.h>
#include <utils/String8.h>

namespace android {

class
 
 IMyService: public IInterface
{
public:
    DECLARE_META_INTERFACE (MyService);

    virtual String8 getStr() = 0;
    virtual void setStr(String8 str) = 0;
    virtual int32_t doAdd(int32_t a, int32_t b) = 0;
};  //class IMyService

class BpMyService: public BpInterface<IMyService>
{
public:
    BpMyService(const
 
 sp<IBinder>& impl): BpInterface<IMyService>(impl) {}

    virtual String8 getStr();
    virtual void setStr(String8 status);
    virtual int32_t doAdd(int32_t a, int32_t b);
};  //class BpMyService

class BnMyService: public BnInterface<IMyService>
{
public:
    virtual status_t onTransact( uint32_t code,
                                 const Parcel& data,
                                 Parcel* reply,
                                 uint32_t flags = 0);
};  //class BnMyService

};   //namespace android
#endif

MyService.h，MyService繼承自BnMyService

#ifndef ANDROID_MyService_H
#define ANDROID_MyService_H
#include <utils/Errors.h>  // for status_t
#include "IMyService.h"
namespace android {

class MyService: public BnMyService {
public:
    static void instantiate();
    virtual String8 getStr();
    virtual void setStr(String8 status);
    virtual int32_t doAdd(int32_t a, int32_t b);
private:
        static String8 mStr;
    MyService();
    virtual ~MyService();

};  //class MyService

};  //namespace android

#endif

MyClient.h中包含一個MyService端代理gMyService，由binder經過interface_cast轉化而成，實際是一個BpMyService的remote物件

#ifndef ANDROID_MYCLIENT_H_
#define ANDROID_MYCLIENT_H_
#include <utils/threads.h>
#include "IMyService.h"
namespace android {
class MyClient : public RefBase
{
public:
    static String8 getStr();
    static void setStr(String8 str);
    static int32_t doAdd(int32_t a, int32_t b);
private:
    class DeathNotifier: public IBinder::DeathRecipient {
        public:
            DeathNotifier() {}
            virtual ~DeathNotifier();
            virtual void binderDied(const wp<IBinder>& who);
    };
private:
    static Mutex gMutex;
    static sp<DeathNotifier> gDeathNotifier;
    static sp<IMyService> gMyService;
    static const sp<IMyService>& getMyService();
};

};  //namespace android
#endif

服務端與客戶端通訊，實際上是BnMyService與BpMyService經由binder進行通訊。
IMyService.cpp 

#define LOG_TAG "IMyService"
#include <utils/Log.h>
#include <string.h>
#include "IMyService.h"

namespace android {

enum {
    GET_STR = IBinder::FIRST_CALL_TRANSACTION,
    SET_STR,
    DO_ADD,
};

String8 BpMyService::getStr()
{
    Parcel data, reply;
    data.writeInterfaceToken(IMyService::getInterfaceDescriptor());
    status_t status = remote()->transact(GET_STR, data, &reply);
    String8 str;
    if (status == NO_ERROR) {
        str = reply.readString8();
    }
    return str;
}

void BpMyService::setStr(String8 str)
{
    Parcel data, reply;
    data.writeInterfaceToken(IMyService::getInterfaceDescriptor());
    data.writeString8(str);
    status_t status = remote()->transact(SET_STR, data, &reply);
}

int32_t BpMyService::doAdd(int32_t a, int32_t b)
{
    Parcel data, reply;
    data.writeInterfaceToken(IMyService::getInterfaceDescriptor());

    data.writeInt32(a);
    data.writeInt32(b);
    status_t status = remote()->transact(DO_ADD, data, &reply);
    int32_t c;
    if (status == NO_ERROR) {
        c = reply.readInt32();
    }
    return c;
}

IMPLEMENT_META_INTERFACE(MyService, "IMyService");

//-----------------------------------------------------------------------------

status_t BnMyService::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    switch(code) {
        case GET_STR:
        {
            CHECK_INTERFACE(IMyService, data, reply);
            String8 str = getStr();
            reply->writeString8(str);
            return NO_ERROR;
        } break;

        case SET_STR:
        {
            CHECK_INTERFACE(IMyService, data, reply);
            String8 str = data.readString8();
            setStr(str);
            return NO_ERROR;
        } break;

        case DO_ADD:
        {
            CHECK_INTERFACE(IMyService, data, reply);
            int32_t a = data.readInt32();
            int32_t b = data.readInt32();
            int32_t c = doAdd(a, b);
            reply->writeInt32(c);
            return NO_ERROR;
        } break;

        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}

};   //namespace android

MyService.cpp很簡單，最關鍵的是instantiate函式，把MyService加入到ServiceManager中，控制代碼是一個String16型別的字串“my.service”,除此之外，具體業務是在這裡面實現的

#define LOG_TAG "MyService"
#include <stdio.h>
#include <string.h>
#include <utils/Log.h>
#include <utils/Errors.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include "MyService.h"

namespace android {
String8 MyService::mStr;

void MyService::instantiate() {
    defaultServiceManager()->addService(String16("my.service"), new MyService());
}

MyService::MyService() {
    ALOGD("MyService bind Construct");
}

MyService::~MyService() {
    ALOGD("MyService bind deConstruct");
}

String8 MyService::getStr() {
    return mStr;
}

void MyService::setStr(String8 str) {
    mStr = str;
}

int32_t MyService::doAdd(int32_t a, int32_t b) {
    return a+b;
}

};

main_myserver.cpp，server端main函式，通過MyService::instantiate()把MyService加入到安卓服務總管ServiceManager的管控中

#define LOG_TAG "main_myserver"
#include <utils/Log.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include "MyService.h"
using namespace android;
int main(int argc, char** argv)
{
    signal(SIGPIPE, SIG_IGN);
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();
    MyService::instantiate();
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

MyClient.cpp，實現了Client獲取服務端代理的過程，通過向安卓服務總管ServiceManager查詢“my.service”控制代碼然後再加以轉換得到一個遠端物件gMyService，然後通過gMyService與服務端通訊，實現Client的業務函式

#define LOG_TAG "MyClient"
#include <utils/Log.h>
#include <binder/IServiceManager.h>
#include "MyClient.h"
namespace android {

Mutex MyClient::gMutex;
sp<IMyService> MyClient::gMyService;
sp<MyClient::DeathNotifier> MyClient::gDeathNotifier;

const sp<IMyService>& MyClient::getMyService()
{
    Mutex::Autolock _l(gMutex);
    if (NULL == gMyService.get())
    {
        sp<IServiceManager> sm = defaultServiceManager();
        sp<IBinder> binder;
        do {
            binder = sm->getService(String16("my.service"));
            if (binder != 0)
                break;
            ALOGW("my.service not published, waiting...");
            usleep(500000); // 0.5 s
        } while (true);
        if (NULL == gDeathNotifier.get())
        {
            gDeathNotifier = new DeathNotifier();
        }

        binder->linkToDeath(gDeathNotifier);
        gMyService = interface_cast<IMyService>(binder);
    }

    return gMyService;
}

MyClient::DeathNotifier::~DeathNotifier() {
    Mutex::Autolock lock(gMutex);
    if (NULL != gMyService.get()) {
#if PLATFORM_SDK_VERSION < 23
        gMyService->asBinder()->unlinkToDeath(this);
#else
        gMyService->asBinder(gMyService)->unlinkToDeath(this);
#endif
    }
}

void MyClient::DeathNotifier::binderDied(const wp<IBinder>& who) {
    Mutex::Autolock lock(gMutex);
    MyClient::gMyService.clear();
    ALOGW("MyClient binder server died!");
}

//--------------------------------------------------------------------------------------
String8 MyClient::getStr()
{
    return getMyService()->getStr();
}

void MyClient::setStr(String8 str)
{
    return getMyService()->setStr(str);
}

int32_t MyClient::doAdd(int32_t a, int32_t b)
{
    return getMyService()->doAdd(a, b);
}

};  //namespace android

Android使用Binder通訊的實現到此已經差不多完成了，接下來是測試過程：

—-C應用測試
test.cpp ， C++應用程式，簡單的呼叫，可以通過logcat檢視結果，測試的時候記得先把Server端跑起來

#define LOG_TAG "test"
#include <stdio.h>
#include <utils/Log.h>
#include "MyClient.h"

using namespace android;

int main(){
    MyClient m;
    m.setStr(String8("hello world"));
    String8 result;
    result = m.getStr();
    ALOGW("getStr , result = %s", result.string()); 
    int32_t sum = m.doAdd(10, 20);  
    ALOGW("doAdd, sum = %d", sum);  
    return 0;
}

結果：
這裡寫圖片描述

—- Android應用測試
要想在Android應用層呼叫C層的客戶端，必須通過JNI介面函式才能實現。
Java中宣告JNI方法，然後通過javah生成jni標頭檔案，呼叫上面Client端的業務函式實現jni標頭檔案宣告的方法，就打通了Java與C++的橋樑。

com_test_androidclient_MainActivity.h檔案，通過javah靜態生成的

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_test_androidclient_MainActivity */

#ifndef _Included_com_test_androidclient_MainActivity
#define _Included_com_test_androidclient_MainActivity
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_test_androidclient_MainActivity
 * Method:    setStr
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_com_test_androidclient_MainActivity_setStr
  (JNIEnv *, jobject, jstring);

/*
 * Class:     com_test_androidclient_MainActivity
 * Method:    getStr
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_test_androidclient_MainActivity_getStr
  (JNIEnv *, jobject);

/*
 * Class:     com_test_androidclient_MainActivity
 * Method:    doAdd
 * Signature: (II)I
 */
JNIEXPORT jint JNICALL Java_com_test_androidclient_MainActivity_doAdd
  (JNIEnv *, jobject, jint, jint);

#ifdef __cplusplus
}
#endif
#endif

com_test_androidclient_MainActivity.cpp， jni橋樑的實現

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
#include "MyClient.h"
/* Header for class com_test_androidclient_MainActivity */
#ifdef __cplusplus     
extern "C"    
{     
#endif  
using namespace android;
/*
 * Class:     com_test_androidclient_MainActivity
 * Method:    setStr
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_com_test_androidclient_MainActivity_setStr
  (JNIEnv *env, jobject thiz, jstring jstr){
    MyClient *m = new MyClient();
    sp<MyClient> client(m);
    const char *str = env->GetStringUTFChars(jstr, NULL);
    client->setStr(String8(str));
}

/*
 * Class:     com_test_androidclient_MainActivity
 * Method:    getStr
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_test_androidclient_MainActivity_getStr
  (JNIEnv *env, jobject thiz){
    MyClient *m = new MyClient();
    sp<MyClient> client(m);
    String8 str = client->getStr();
    return env->NewStringUTF(str.string());
}

/*
 * Class:     com_test_androidclient_MainActivity
 * Method:    doAdd
 * Signature: (II)I
 */
JNIEXPORT jint JNICALL Java_com_test_androidclient_MainActivity_doAdd
  (JNIEnv *env, jobject thiz, jint a, jint b){
    MyClient *m = new MyClient();
    sp<MyClient> client(m);
    return client->doAdd(a, b);
}

#ifdef __cplusplus     
}    
#endif

結果：
這裡寫圖片描述

可以看到，c或者Android的客戶端都能正確與server端進行互動。

以上就是在Android中使用Binder的簡單步驟，本例中Server端在native世界中，而Client端在native世界與Java世界都有實現，其實也可以把Server端放在Java世界中，native世界的Client也可以通過Binder與其進行通訊。如果Server端和Client端都在Java世界中，那就可以用著名的AIDL來實現了。

本文程式碼地址：
http://download.csdn.net/download/email_jade/9962184
原始碼直接mm編譯即可生成所有的檔案

相關推薦

Android利用Binder進行通訊

Android利用Binder進行通訊 Binder作為Android使用最廣泛的IPC通訊機制之一，其重要性不言而喻。Binder的實現思想與原理各路大神已經分析的十分透徹了，個人覺得最好以及最詳細的是老羅的Android之旅系列裡面關於Binder的講解： [ Andro

Android利用mediacodec進行視訊H264編碼解碼播放

H264是目前最常用的視訊壓縮格式之一，可以將視訊、圖片、音訊等轉換為字串流形式，以此可以進行再次編輯、傳輸等。詳情參考http://blog.csdn.net/lcalqf/article/det

java netty socket庫和自定義C#socket庫利用protobuf進行通訊完整例項

之前的文章講述了socket通訊的一些基本知識，已經本人自定義的C#版本的socket、和java netty 庫的二次封裝，但是沒有真正的發表測試用例。 本文只是為了講解利用protobuf 進行C# 和 java的通訊。以及完整的例項程式碼 java 程式碼 svn 地址，本人開發工具是NetBean

Android利用Fiddler進行網路資料抓包

主要介紹Android及IPhone手機上如何利用Fiddler進行網路資料抓包，比如我們想抓某個應用(微博、微信、墨跡天氣)的網路通訊請求就可以利用這個方法。 Mac 下請使用 Charles 代替 Fiddler，Charles 免費啟用碼為Registered

Android利用ADB進行螢幕錄製

前言 在寫部落格時，為了方便大家理解，我們經常需要把一些操作或動畫錄製成Gif，一般需要下載一個螢幕錄製App將手機螢幕錄製成視訊（可能需要Root許可權），然後匯出到電腦，再轉為Gif。今天就來教大家一鍵錄製手機螢幕並匯出到電腦。 功能與限制 不需要

Android使用Socket進行通訊

Java能接受其他通訊實體連線請求的類是ServerSocket，ServerSocket物件用於監聽客戶端的Socket連線，如果沒有連線，它將一直處於等待狀態。 public class Si

vue 父子元件通訊，利用物件進行通訊

大家都知道vue父子元件間通訊用到了props，$emit。 通過props可以實現父向子通訊，通過$emit可以實現子向父通訊，現在我要介紹另外一種方式，通過props傳物件的形式通訊。 首先寫一個簡單的例子 //父元件 <parent>

Qt學習之路十二——利用UDP進行通訊

一、UDP的特點UDP（使用者資料報協議）是一種簡單輕量級、不可靠、面向資料報，無連線的傳輸層協議。而TCP/IP協議卻是有連線的二、UDP適合應用的幾種情況1、網路資料大多為短訊息2、擁有大量客戶端3、對資料安全性無特殊要求4、網路負擔非常重，但對響應速度要求高。三、利用U

android Service Binder互動通訊例項

以下為原文貼過來的 android SDK提供了Service，用於類似*nix守護程序或者windows的服務。 Service有兩種型別： 本地服務（Local Service）：用於應用程式內部遠端服務（Remote Sercie）：用於android

父程序利用fork（）函式建立子程序並且利用shared_memory進行通訊的例項

#include<stdio.h> #include<unistd.h> #include<sys/shm.h> #include<sys/stat.h>

android與PC，C#與Java 利用protobuf 進行無障礙通訊【Socket】

轉自https://www.cnblogs.com/TerryBlog/archive/2011/04/23/2025654.html protobuf 是什麼？   Protocol buffers是一種編碼方法構造的一種有效而可擴充套件的格式的資料。 谷歌使用其內

android中利用Socket實現手機客戶端與PC端進行通訊

伺服器端： import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; impor

android中通過usb和pc進行通訊

找到的最好的部落格 https://blog.csdn.net/jakemiao/article/details/17270785?locationNum=7&fps=1 下面是demo: https://github.com/yunzheyue/usbCommunication

Android IPC程序間通訊（七） Binder連線池

Binder管家之Binder連線池 IPC程序間通訊（四）之AIDL中的AIDL由一個Service進行管理，若是建立10個AIDL業務模組是不是也要建立10個Service來進行管理，那100個呢？顯然繁瑣，怎麼辦麼，用Binder連線池呀！ 工作機制： 1.每個業務模組建立其AID

Android IPC程序間通訊（三）Binder

程序間通訊的介質Binder Binder實現了IBinder介面，是android中跨程序通訊的一種方式。是服務端和客戶端通訊的媒介。 Binder的建立： 1.建立自定義類Book.java實現Parcelable介面，以實現序列化可反序列化。 public class Book

利用WinAPI進行串列埠通訊程式設計

轉載於：https://blog.csdn.net/L_Andy/article/details/51131232 轉載只為了方便查詢，希望大家從源連線進行檢視！ 總結來看串列埠通訊原理，（也可以說大多數通訊原理也是如此）。 通訊首先要有個通訊，可以簡單的把通訊看成一個

C#實戰024:利用Socket進行雙向資訊通訊

      專案開發過程中需要通過伺服器獲取裝置的資訊狀態，這時我們就需要在裝置端開啟監聽來獲取伺服器發來的訊息並執行相應程式來獲取裝置的引數，這個過程我們需要利用Socket進行通訊，這時伺服器是傳送資料，裝置為接受資料，所以這裡我們定義伺服器為客戶端SocketCl

Android Socket連線，使用Socket進行通訊(Android)

一。伺服器程式 伺服器程式需要在PC上執行，該程式比較的簡單，因此不需要建立Android專案，直接定義一個JAVA類，並且執行該類即可。它僅僅建立ServerSocket監聽，並使用Socket獲取輸入輸出流。 SimpleServer import java.io.IOEx

利用Thrift使Java與C#進行通訊

struct UserProfile{ 1:i32 id, 2:string name, 3:string blurb } service UserStorage{ vo

Android Studio 2.2 中利用CAMKE進行OpenCV的NDK開發

我在http://www.cnblogs.com/fx-blog/p/8206737.html一文中提到了如何在Android Studio中Java層匯入OpenCV（包含opencv_contrib部分），但是這僅僅是Java層的匯入，隨著學習的深入，我們可以漸漸的發