Android 实现c+的本机绑定代码+；

我有以下用于本机绑定器实现的代码

#define LOG_TAG "binder_demo"
#include <stdlib.h>
#include <utils/RefBase.h>
#include <utils/Log.h>
#include <binder/TextOutput.h>
#include <binder/IInterface.h>
#include <binder/IBinder.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/IPCThreadState.h>

using namespace android;
#define INFO(...) \
    do { \
        printf(__VA_ARGS__); \
        printf("\n"); \
        ALOGD(__VA_ARGS__); \
    } while(0)

void assert_fail(const char *file, int line, const char *func, const char *expr) {
    INFO("assertion failed at file %s, line %d, function %s:",
            file, line, func);
    INFO("%s", expr);
    abort();
}
#define ASSERT(e) \
    do { \
        if (!(e)) \
            assert_fail(__FILE__, __LINE__, __func__, #e); \
    } while(0)

#define PLOG aout

class IDemo : public IInterface {
    public:
        enum {
            ALERT = IBinder::FIRST_CALL_TRANSACTION,
            PUSH,
            ADD
        };
        // Sends a user-provided value to the service
        virtual void push(int32_t data) = 0;

        // Sends a fixed alert string to the service
        virtual void alert() = 0;

        // Requests the service to perform an addition and return the result
        virtual int32_t add(int32_t v1, int32_t v2) = 0;

        DECLARE_META_INTERFACE(Demo); // Expands to 5 lines below:

};

// Client
class BpDemo : public BpInterface<IDemo> {
    public:
        BpDemo(const sp<IBinder>& impl) : BpInterface<IDemo>(impl) {
            ALOGD("BpDemo::BpDemo()");
        }

        virtual void push(int32_t push_data) {
            Parcel data, reply;
            data.writeInterfaceToken(IDemo::getInterfaceDescriptor());
            data.writeInt32(push_data);
            aout << "BpDemo::push parcel to be sent:\n";
            data.print(PLOG); endl(PLOG);
            remote()->transact(PUSH, data, &reply);
            aout << "BpDemo::push parcel reply:\n";
            reply.print(PLOG); endl(PLOG);
            ALOGD("BpDemo::push(%i)", push_data);
        }
        virtual void alert() {
            Parcel data, reply;
            data.writeInterfaceToken(IDemo::getInterfaceDescriptor());
            data.writeString16(String16("The alert string"));
            remote()->transact(ALERT, data, &reply, IBinder::FLAG_ONEWAY); // asynchronous call
            ALOGD("BpDemo::alert()");
        }
        virtual int32_t add(int32_t v1, int32_t v2) {
            Parcel data, reply;
            data.writeInterfaceToken(IDemo::getInterfaceDescriptor());
            data.writeInt32(v1);
            data.writeInt32(v2);
            aout << "BpDemo::add parcel to be sent:\n";
            data.print(PLOG); endl(PLOG);
            remote()->transact(ADD, data, &reply);
            ALOGD("BpDemo::add transact reply");
            reply.print(PLOG); endl(PLOG);
            int32_t res;
            status_t status = reply.readInt32(&res);
            ALOGD("BpDemo::add(%i, %i) = %i (status: %i)", v1, v2, res, status);
            return res;
        }
};

 DECLARE_META_INTERFACE(Demo,"Demo"); // Expands to 5 lines below:
// Server
class BnDemo : public BnInterface<IDemo> {

    virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0);
};
status_t BnDemo::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
    ALOGD("BnDemo::onTransact(%i) %i", code, flags);
    data.checkInterface(this);
    data.print(PLOG); endl(PLOG);
    switch(code) {
        case ALERT: {
            alert(); // Ignoring the fixed alert string
            return NO_ERROR;
        } break;
        case PUSH: {
            int32_t inData = data.readInt32();
            ALOGD("BnDemo::onTransact got %i", inData);
            push(inData);
            ASSERT(reply != 0);
            reply->print(PLOG); endl(PLOG);
            return NO_ERROR;
        } break;
        case ADD: {
            int32_t inV1 = data.readInt32();
            int32_t inV2 = data.readInt32();
            int32_t sum = add(inV1, inV2);
            ALOGD("BnDemo::onTransact add(%i, %i) = %i", inV1, inV2, sum);
            ASSERT(reply != 0);
            reply->print(PLOG); endl(PLOG);
            reply->writeInt32(sum);
            return NO_ERROR;
        } break;
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}
class Demo : public BnDemo {
    virtual void push(int32_t data) {
        INFO("Demo::push(%i)", data);
    }
    virtual void alert() {
        INFO("Demo::alert()");
    }
    virtual int32_t add(int32_t v1, int32_t v2) {
        INFO("Demo::add(%i, %i)", v1, v2);
        return v1 + v2;
    }
};
// Helper function to get a hold of the "Demo" service.
sp<IDemo> getDemoServ() {
    sp<IServiceManager> sm = defaultServiceManager();
    ASSERT(sm != 0);
    sp<IBinder> binder = sm->getService(String16("Demo"));

    // TODO: If the "Demo" service is not running, getService times out and binder == 0.
    ASSERT(binder != 0);
    sp<IDemo> demo = interface_cast<IDemo>(binder);
    ASSERT(demo != 0);
    return demo;
}
int main(int argc, char **argv) {

    if (argc == 1) {
        ALOGD("We're the service");
        defaultServiceManager()->addService(String16("Demo"), new Demo());
        android::ProcessState::self()->startThreadPool();
        ALOGD("Demo service is now ready");
        IPCThreadState::self()->joinThreadPool();
        ALOGD("Demo service thread joined");
    } else if (argc == 2) {
        INFO("We're the client: %s", argv[1]);
        int v = atoi(argv[1]);
        sp<IDemo> demo = getDemoServ()
        demo->alert();
        demo->push(v);
        const int32_t adder = 5;
        int32_t sum = demo->add(v, adder);
        ALOGD("Addition result: %i + %i = %i", v, adder, sum);
    }
    return 0;
}

#定义日志标签“活页夹演示”
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用android名称空间；
#定义信息（…）\
做{\
printf（_VA_ARGS__;）\
printf（“\n”）\
ALOGD（_VA_ARGS__;）\
}而（0）
无效断言失败（常量字符*文件、整型行、常量字符*函数、常量字符*表达式）{
信息（“在文件%s，第%d行，函数%s处的断言失败：”，
文件、行、函数）；
信息（“%s”，expr）；
中止（）；
}
#定义断言（e）\
做{\
如果（！（e））\
断言失败（文件、行、函数、e）\
}而（0）
#定义PLOG aout
类IDemo：公共接口{
公众：
枚举{
ALERT=IBinder:：第一次调用\u事务，
推
添加
};
//向服务发送用户提供的值
虚拟无效推送（int32_t数据）=0；
//向服务发送固定警报字符串
虚拟空警报（）=0；
//请求服务执行加法并返回结果
虚拟int32_t add（int32_t v1，int32_t v2）=0；
DECLARE_META_INTERFACE（Demo）；//扩展到下面5行：
};
//客户
类BpDemo：公共BpInterface{
公众：
BpDemo（常量sp和impl）：BpInterface（impl）{
ALOGD（“BpDemo:：BpDemo（）”；
}
虚拟无效推送（int32推送数据）{
包裹数据，回复；
writeInterfaceToken（IDemo:：getInterfacedDescriptor（））；
数据写入32（推送数据）；
aout事务（推送、数据和回复）；
aout transact（警报、数据和回复、IBinder:：FLAG_ONEWAY）；//异步调用
ALOGD（“BpDemo:：alert（）”；
}
虚拟int32_t添加（int32_t v1、int32_t v2）{
包裹数据，回复；
writeInterfaceToken（IDemo:：getInterfacedDescriptor（））；
数据写入32（v1）；
数据写入32（v2）；
aout事务处理（添加、数据和回复）；
ALOGD（“BpDemo:：添加事务回复”）；
答复.打印（PLOG）；endl（PLOG）；
int32_t res；
status\u t status=reply.readInt32（&res）；
ALOGD（“BpDemo:：添加（%i，%i）=%i（状态：%i）”，v1、v2、res、状态）；
返回res；
}
};
声明元接口（Demo，“Demo”）；//扩展到下面的5行：
//服务器
类BnDemo：公共BnDemo接口{
虚拟状态合同（uint32代码、常量包裹和数据、包裹*回复、uint32标志=0）；
};
状态演示：：onTransact（uint32代码、施工包裹和数据、包裹*回复、uint32标志）{
ALOGD（“BnDemo:：onTransact（%i）%i）”，代码，标志；
数据检查接口（本）；
数据打印（PLOG）；endl（PLOG）；
开关（代码）{
病例警报：{
alert（）；//忽略固定的警报字符串
返回无错误；
}中断；
案例推送：{
int32_t inData=data.readInt32（）；
ALOGD（“BnDemo:：onTransact获得%i”，inData）；
推（inData）；
断言（应答！=0）；
回复->打印（PLOG）；结束（PLOG）；
返回无错误；
}中断；
案例补充：{
int32_t inV1=data.readInt32（）；
int32_t inV2=data.readInt32（）；
int32\u t sum=add（inV1，inV2）；
ALOGD（“BnDemo:：onTransact add（%i，%i）=%i”，inV1，inV2，sum）；
断言（应答！=0）；
回复->打印（PLOG）；结束（PLOG）；
回复->写入32（总和）；
返回无错误；
}中断；
违约：
返回BBinder:：onTransact（代码、数据、回复、标志）；
}
}
类演示：公共演示{
虚拟无效推送（int32_t数据）{
信息（“演示：：推送（%i）”，数据）；
}
虚拟无效警报（）{
信息（“Demo:：alert（）”；
}
虚拟int32_t添加（int32_t v1、int32_t v2）{
信息（“演示：添加（%i，%i）”，v1，v2）；
返回v1+v2；
}
};
//Helper函数获取“Demo”服务。
sp getDemoServ（）{
sp sm=defaultServiceManager（）；
断言（sm！=0）；
sp binder=sm->getService（String16（“演示”）；
//TODO:如果“Demo”服务未运行，则getService超时，binder==0。
断言（绑定器！=0）；
sp demo=接口铸件（活页夹）；
断言（demo！=0）；
返回演示；
}
int main（int argc，字符**argv）{
如果（argc==1）{
ALOGD（“我们就是服务”）；
defaultServiceManager（）->addService（String16（“演示”），new Demo（）；
android:：ProcessState:：self（）->startThreadPool（）；
ALOGD（“演示服务现已就绪”）；
IPCThreadState:：self（）->joinThreadPool（）；
ALOGD（“连接的演示服务线程”）；
}else if（argc==2）{
信息（“我们是客户：%s”，argv[1]）；
intv=atoi（argv[1]）；
sp demo=getDemoServ（）
演示->警报（）；
演示->推送（v）；
常数int32_t加法器=5；
int32_t sum=demo->add（v，加法器）；
ALOGD（“加法结果：%i+%i=%i”，v，加法器，和）；
}
返回0；
}

---

问题是如何在android平台上编译和测试它。我不想构建一个新的二进制文件。我想要的是，代码应该在运行的android平台上编译，结果应该显示在像adb外壳这样的终端上。

请参阅此链接，特别是adb外壳部分。您也可以查看此幻灯片（幻灯片编号66）。他们介绍了如何通过adb shell执行cpp文件。实际上，我想捕获作为包通过活页夹传递的数据。