Android Binder機制的Native應用—雙向通訊

阿新 • • 發佈：2019-01-27

mkdir testbinder //建立testbinder目錄

Android.mk

include $(call all-subdir-makefiles)

一、介面類

1.正向呼叫—Itestbinder

Itestbinder.h

#ifndef Itestbinder_H  
#define Itestbinder_H 
#include <binder/IInterface.h>
#include "Icallback.h"
namespace android{
  class Itestbinder : public IInterface{
    public:
      DECLARE_META_INTERFACE(testbinder);
      virtual int testinterface(int a) = 0;
      virtual int setcallback(const sp<Icallback>& callback) = 0;
  };
  class Bntestbinder : public BnInterface<Itestbinder>{
  public:
    virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
  };
}
#endif

Itestbinder.cpp

#include "Itestbinder.h"
#include <binder/Parcel.h>
#include <binder/IInterface.h>
#include "Icallback.h"
namespace android{
  enum {
    TEST_INTERFACE,
    SET_CALLBACK
  };
//////////////////客戶端
  class Bptestbinder : public BpInterface<Itestbinder>{
    public:
      Bptestbinder(const sp<IBinder>& impl) : BpInterface<Itestbinder>(impl){
      }
      virtual int testinterface(int a){
        LOGD("==========================================================\n");
        LOGD("TK---->>>>>>Itestbinder.cpp>>>>Bptestbinder::testinterface\n");
        Parcel data,reply;
        data.writeInt32(a);
        remote()->transact(TEST_INTERFACE,data,&reply);
        return reply.readInt32();
      }
      virtual int setcallback(const sp<Icallback>& callback){
        LOGD("==========================================================\n");
        LOGD("TK---->>>>>>Itestbinder.cpp>>>>Bptestbinder::setcallback\n");
        Parcel data, reply;
        data.writeStrongBinder(callback->asBinder());
        remote()->transact(SET_CALLBACK, data, &reply);
        return reply.readInt32();
      }
  };

  IMPLEMENT_META_INTERFACE(testbinder, "android.test.Itestbinder");
/////////////////服務端
  status_t Bntestbinder::onTransact(
      uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){
    LOGD("TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact\n");
    switch (code) {
      case TEST_INTERFACE:{
        //CHECK_INTERFACE(Itestbinder, data, reply);
        LOGD("TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact>>TEST_INTERFACE\n");
        reply->writeInt32(testinterface((int) data.readInt32()) );
        return NO_ERROR;
      } break;
      case SET_CALLBACK:{
        LOGD("TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact>>SET_CALLBACK\n");
        sp<Icallback> callback = interface_cast<Icallback>(data.readStrongBinder());
        //int a = connect(Client);
        reply->writeInt32(setcallback(callback));    
        return NO_ERROR;    
      }
      default:{
        LOGD("TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact>>333\n");
        return BBinder::onTransact(code, data, reply, flags);
      }
    }
  }
}

2.反向呼叫—Icallback

Icallback.h

#ifndef Icallback_H  
#define Icallback_H 
#include <binder/IInterface.h>
namespace android{
  class Icallback : public IInterface{
    public:
      DECLARE_META_INTERFACE(callback);
      virtual int notifyCallback(int a) = 0;
  };
  class Bncallback : public BnInterface<Icallback>{
  public:
    virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
  };
}
#endif

Icallback.cpp

#include "Itestbinder.h"
#include <binder/Parcel.h>
#include <binder/IInterface.h>
namespace android{
  enum {
    NOTIFY_CALLBACK,
  };
//////////////////客戶端
  class Bpcallback : public BpInterface<Icallback>{
    public:
      Bpcallback(const sp<IBinder>& impl) : BpInterface<Icallback>(impl){
      }
      virtual int notifyCallback(int a){
        LOGD("==========================================================\n");
        LOGD("TK---->>>>>>Icallback.cpp>>>>Bpcallback::notifyCallback\n");
        Parcel data,reply;
        data.writeInt32(a);
        remote()->transact(NOTIFY_CALLBACK,data,&reply);
        return reply.readInt32();
      }
  };

  IMPLEMENT_META_INTERFACE(callback, "android.test.Icallback");
/////////////////服務端
  status_t Bncallback::onTransact(
      uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){
    LOGD("TK---->>>>>>Icallback.cpp>>>>Bncallback::onTransact\n");
    switch (code) {
      case NOTIFY_CALLBACK:{
        //CHECK_INTERFACE(Itestbinder, data, reply);
        LOGD("TK---->>>>>>Icallback.cpp>>>>Bncallback::onTransact>>NOTIFY_CALLBACK\n");
        reply->writeInt32(notifyCallback((int) data.readInt32()) );
        return NO_ERROR;
      } break;
      default:{
        LOGD("TK---->>>>>>Icallback.cpp>>>>Bncallback::onTransact>>222\n");
        return BBinder::onTransact(code, data, reply, flags);
      }
    }
  }
}

二、服務端

mkdir server //建立server目錄，這個是服務端實現

1.Bntestbinder實現

testbinder.h

#include "../interface/Itestbinder.h"
#include "../interface/Icallback.h"
#include <binder/BinderService.h>
namespace android{
  class testbinder: 
      public BinderService<testbinder>,
      public Bntestbinder{
    friend class BinderService<testbinder>;
    public:
      static const char* getServiceName() { return "test.Itestbinder"; }
      virtual int testinterface(int a);
      virtual int setcallback(const sp<Icallback>& callback);
      virtual     status_t    onTransact(
                                uint32_t code,
                                const Parcel& data,
                                Parcel* reply,
                                uint32_t flags);
    protected:
      sp<Icallback> mcallback;
  };
}

testbinder.cpp

#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <utils/Log.h>
//#include <utils/Trace.h>
#include <binder/Parcel.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
#include <utils/threads.h>
#include <utils/Atomic.h>

//#include <cutils/bitops.h>
#include <cutils/properties.h>
#include <cutils/compiler.h>
#include "testbinder.h"

namespace android{
  int testbinder::testinterface(int a){
    LOGD("TK---->>>>>>testbinder.cpp>>>>testbinder::testinterface\n");
    sp<Icallback> c = mcallback;
    c->notifyCallback(2);
    return a+2;
  }
  int testbinder::setcallback(const sp<Icallback>& callback){
    LOGD("TK---->>>>>>testbinder.cpp>>>>testbinder::setcallback\n");
    mcallback = callback;
    return 1;
  }
  status_t testbinder::onTransact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){
    LOGD("TK---->>>>>>testbinder.cpp>>>>testbinder::onTransact\n");
    return Bntestbinder::onTransact(code, data, reply, flags);
  }
}

2.向ServiceManager註冊testbinder服務

main.cpp

#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <utils/Log.h>

#include "testbinder.h"


using namespace android;

int main(int argc, char** argv)
{
  sp<ProcessState> proc(ProcessState::self());
  sp<IServiceManager> sm = defaultServiceManager();
  LOGI("ServiceManager: %p", sm.get());
  testbinder::instantiate();
  ProcessState::self()->startThreadPool();
  IPCThreadState::self()->joinThreadPool();
  return 0;
}

Android.mk

LOCAL_PATH:= $(call my-dir)
#LOCAL_CFLAGS_ALL :=-I. -I$(LOCAL_PATH)/..

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \
	main.cpp \
	testbinder.cpp \
	../interface/Itestbinder.cpp \
	../interface/Icallback.cpp

LOCAL_SHARED_LIBRARIES := \
        libui libcutils libutils libbinder libsonivox libicuuc libexpat \
	libdl


LOCAL_MODULE:= server
LOCAL_MODULE_TAGS := optional

三、客戶端

1.通過ServiceManager獲得Itestbinder遠端介面

mkdir client //建立client目錄，這個是client的實現

client.h

#include "../interface/Itestbinder.h"

namespace android{
  class client{
    public:
      static const sp<Itestbinder>& get_test_binder();
      static sp<Itestbinder> gtestbinder;
  };
}

client.cpp

#include "client.h"
#include <binder/IServiceManager.h>
#include <utils/Log.h>
#include <stdio.h>
namespace android{
  sp<Itestbinder> client::gtestbinder;
  const sp<Itestbinder>& client::get_test_binder(){
    if (gtestbinder == 0) {
        sp<IServiceManager> sm = defaultServiceManager();
        sp<IBinder> binder;
        do {
            binder = sm->getService(String16("test.Itestbinder"));
            if (binder != 0)
                break;
            printf("testbinder not published, waiting...");
            usleep(500000); // 0.5 s
        } while (true);
        gtestbinder = interface_cast<Itestbinder>(binder);
    }
    if(gtestbinder==0) printf("no testbinder!?");
    return gtestbinder;
  }
}

2.Bncallback的實現，反向呼叫

callback.h

#include "../interface/Itestbinder.h"
#include "../interface/Icallback.h"
#include <binder/BinderService.h>
namespace android{
  class callback: public Bncallback{
    friend class BinderService<callback>;
    public:
      virtual int notifyCallback(int a);
      virtual     status_t    onTransact(
                                uint32_t code,
                                const Parcel& data,
                                Parcel* reply,
                                uint32_t flags);
  };
}

callback.cpp

#include <binder/Parcel.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
#include <utils/threads.h>
#include <utils/Atomic.h>

//#include <cutils/bitops.h>
#include <cutils/properties.h>
#include <cutils/compiler.h>
#include "callback.h"

namespace android{
  int callback::notifyCallback(int a){
    LOGD("TK---->>>>>>callback.cpp>>>>callback::notifyCallback\n");
    return 1;
  }
  status_t callback::onTransact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){
    LOGD("TK---->>>>>>callback.cpp>>>>callback::onTransact\n");
    return Bncallback::onTransact(code, data, reply, flags);
  }
}

3.主函式

main.cpp

#include <stdio.h>
#include "client.h"
#include "callback.h"

using namespace android;

int main(int argc, char* argv[]){
  client* myclient = new client();
  if(myclient == NULL) return 0;
  const sp<Itestbinder>& tb = myclient->get_test_binder();
  if(tb == NULL) return 0;
  sp<callback> c = new callback();
  ProcessState::self()->startThreadPool();  //add by tank
  int a = tb->setcallback(c);
  a = tb->testinterface(3);
  LOGD("TK-------->>>result is %d\n",a);
  delete myclient;
  return 0;
}

Android.mk

LOCAL_PATH:= $(call my-dir)
#LOCAL_CFLAGS_ALL :=-I. -I$(LOCAL_PATH)/..

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \
	client.cpp \
	main.cpp \
	../interface/Itestbinder.cpp \
	callback.cpp \
	../interface/Icallback.cpp \

LOCAL_SHARED_LIBRARIES := \
        libui libcutils libutils libbinder libsonivox libicuuc libexpat \
	libdl


LOCAL_MODULE:= client
LOCAL_MODULE_TAGS := optional

include $(BUILD_EXECUTABLE)

四、執行

./server

./client

結果：

result:

I/        (  563): ServiceManager: 0xd750
D/        (  565): ==========================================================
D/        (  565): TK---->>>>>>Itestbinder.cpp>>>>Bptestbinder::setcallback
D/        (  563): TK---->>>>>>testbinder.cpp>>>>testbinder::onTransact
D/        (  563): TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact
D/        (  563): TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact>>SET_CALLBACK
D/        (  563): TK---->>>>>>testbinder.cpp>>>>testbinder::setcallback
D/        (  565): ==========================================================
D/        (  565): TK---->>>>>>Itestbinder.cpp>>>>Bptestbinder::testinterface
D/        (  563): TK---->>>>>>testbinder.cpp>>>>testbinder::onTransact
D/        (  563): TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact
D/        (  563): TK---->>>>>>Itestbinder.cpp>>>>Bntestbinder::onTransact>>TEST_INTERFACE
D/        (  563): TK---->>>>>>testbinder.cpp>>>>testbinder::testinterface
D/        (  563): ==========================================================
D/        (  563): TK---->>>>>>Icallback.cpp>>>>Bpcallback::notifyCallback
D/        (  565): TK---->>>>>>callback.cpp>>>>callback::onTransact
D/        (  565): TK---->>>>>>Icallback.cpp>>>>Bncallback::onTransact
D/        (  565): TK---->>>>>>Icallback.cpp>>>>Bncallback::onTransact>>NOTIFY_CALLBACK
D/        (  565): TK---->>>>>>callback.cpp>>>>callback::notifyCallback
D/        (  565): TK-------->>>result is 5

Android Binder機制的Native應用—雙向通訊

mkdir testbinder //建立testbinder目錄 Android.mk include $(call all-subdir-makefiles) 一、介面類 1.正向呼叫—Itestbinder Itestbinder.h #ifndef Itestb

Android Binder機制詳解：手寫IPC通訊

想要掌握一樣東西，最好的方式就是閱讀理解它的原始碼。想要掌握Android Binder，最好的方式就是寫一個AIDL檔案，然後檢視其生成的程式碼。本文的思路也是來自於此。簡介 Binder是Android常用的一種程序間通訊方式。當然，不使用Binder，你還可以使用Socket甚至檔案來進行通訊。

Android中Binder機制實現程序間通訊

基本上不管是何種開發都會涉及到程序間通訊的問題，即IPC,而安卓系統的IPC方式主要是Binder，先列舉幾種IPC的方式，對比Binder看看。 Linux裡

Linux與android程序間的通訊及android Binder機制詳解

關於程序之間的通訊又很多種方式，不同的方式適用於不同的場景。五種不同形式的IPC形式 1.訊息傳遞（管道，FIFO和訊息佇列） 2.同步（互斥量，條件變數，讀寫鎖，檔案和記錄鎖，訊號量） 3.共享記憶體（匿名的和具名的） 4.遠端過程呼叫（Solaris門和Sun R

android Binder機制

pro end abs close 概念 exp 是的一切都實例化 Binder 架構設計 Binder 被設計出來是解決 Android IPC（進程間通信）問題的。Binder 將兩個進程間交互的理解為 Client 向 Server 進行通信。如下：binde

Android Binder機制淺析

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

Android Binder機制原理

Binder是Android系統程序間通訊（IPC）方式之一。Linux已經擁有的程序間通訊IPC手段包括(Internet Process Connection)：管道（Pipe）、訊號（Signal）和跟蹤（Trace）、插口（Socket）、報文佇列（Messag

Android Binder機制原理（史上最強理解，沒有之一）（轉）

react native 之雙向通訊小tips

react natvie 與android 之間的通訊在上述沒講全一些常見需求的實現。例如 js與native 自定義事件的通訊等由於暴露給js的檢視是繼承SimpleViewManager 只提供了暴露了屬性給js 設定又比如js的檢視

Android - Binder機制 - ProcessState和IPCThreadState

以下幾篇文章是較深入分析binder機制。目錄 1. Android - Binder機制 - ServiceManager 2. Android - Binder機制 - 普通service註冊 3. Android - Binder機制 - 獲得普通service 4. A

藉助 AIDL 理解 Android Binder 機制——Binder 來龍去脈

AIDL 是 Android Interface Definition Language（Android 介面定義語言）的縮寫，它是 Android 程序間通訊的介面語言。由於 Android 系統的核心是 Linux，它採用了程序隔離機制，使得不同的應用程式執行在不同的程序當中，有時候兩個應用之間需要傳遞或

Android Binder機制之 ServiceManager的啟動

Android Binder機制的ServiceManager 對於Android 來說，Binder程序間的通訊機制幾乎無處不在，可以說是整個Android系統中各個元件之間互動的靈魂。所以，想要深入的理解Android 中程序間通訊的機制，還是需要對Binder機制

藉助 AIDL 理解 Android Binder 機制——AIDL 的使用和原理分析

在上一篇文章——藉助 AIDL 理解 Android Binder 機制——Binder 來龍去脈中我們已經分析了使用 Binder 機制的原因以及分析了 Binder 機制，本章我們將繼續從 AIDL 的使用過程體驗 Binder 在應用層的使用和原理。 AIDL 使用步驟 1.建立 UserManag

Android binder機制---概述

1.程序間通訊的原因目前作業系統都使用虛擬儲存技術，管理記憶體。假設是32位機器，0-3G是使用者空間，3-4G是系統使用。虛擬記憶體和邏輯記憶體都按4K分頁。這樣虛擬記憶體和邏輯記憶體就存在對應關係。一個程序只能操作自己的記憶體，無法直接訪問其他的程序的物理頁。系統程序可以訪問所有的物理應用

Android Binder機制完全解析

概述之前我寫過一篇文章Android Service全面解析，簡單實現瞭如何通過AIDL實現Service的跨程序通訊（IPC），其實是通過Binder機制來實現的，本文我們就重點來看看Binder機制的原理。 Binder可以提供系統中任何程式都可以訪問

Android Binder機制原理（史上最強理解，沒有之一）

Binder是Android系統程序間通訊（IPC）方式之一。Linux已經擁有的程序間通訊IPC手段包括(Internet Process Connection)：管道（Pipe）、訊號（Signal）和跟蹤（Trace）、插口（Socket）、報文佇列（Messa

走進Android Binder機制（驅動篇上）

由於篇幅限制，驅動篇文章分為上下兩章，還請大家注意，此篇是上篇。 Binder的實現是比較複雜的，想要完全弄明白是怎麼一回事，並不是一件容易的事情。這裡面牽涉到好幾個層次，每一層都

Android Binder機制——ServiceManager的啟動

基於Android 7.0原始碼，分析ServiceManager的啟動過程。 binder驅動的初始化是binder_init函式一、概述 ServiceManager是整個Binder IPC通訊過程中的守護程序，本身也是一個Bind

深入理解Android Binder機制的幾點

Android系統Binder機制中的四個元件：Client，Server，Service Manager和Binder驅動程式。 1. Client、Server和Service Manager實現在使用者空間中，Binder驅動程式實現在核心空間中 2. Binder

Android Binder機制淺析(三)

接上文... 本文根據網上現有資源進行整合，以及自己的理解，有誤之處歡迎指正～～三、MediaService的執行由2.6中的分析，可知defaultServiceManager得到了BpServiceManager，然後MediaPlayerService

Android Binder機制的Native應用—雙向通訊

相關推薦