通过binder传递结构体数组信息

1.首先binder是用来进程之间通信使用的，我要从一个进程将将一个结构体数组传递给另一个进程，封装api，从一个接口调用---client端----service端-----另一个进程使用

2、进程a调用接口传递一个结构体数组

typedef struct {
    int left; int top;
    int width; int height;
} ipc_video_area_t;

       

        int i = 0;
        ipc_video_area_t video_area[2] = {{758,25,266,205},{9,25,740,555}};
        xVector video_vector = {0};
        x_vector_init(&video_vector, 2, sizeof(ipc_video_area_t));
        for(i = 0; i< 2; i++){
          x_vector_set(&video_vector, i, (void *)&video_area[i]);
        }
        binder_set_video_display_area_new(call_info->chan, video_vector);
        x_vector_free(&video_vector);

（1）接口 binder_set_video_display_area_new   传递结构体为 video_area

（2）先定义一个binder传递过程中的数组块video_vector（这好像是c++的，暂时叫数组块吧）

   给它init空间，并循环填充到数组块里，然后给接口做参数，传入

2、client端处理并传递给service

void binder_set_video_display_area_new(int chan, xVector video_vector)
{
    sp<ICallService> service = get_call_service();
    if (service == NULL) return;

    int32_t i = 0;
    vector<CommonParcelable> cpp_vector;

    for (int i = 0; i < video_vector.size; i++){
        cpp_vector.push_back(CommonParcelable((const char *)x_vector_get(&video_vector, i), sizeof(ipc_video_area_t)));
    }
    service->setVideoLocalAreaNew(chan, cpp_vector);
}

（1）vector<CommonParcelable> 要创建一个这个类型的cpp_vector，应为传递给service 需要包上一层CommonParcelable（我也不知道为啥）

（2）然后把传过来的 video_vector 通过push_back填充到cpp_vector，这时候就把它做参数传递给service端

3、service端处理，并传递给另一个进程

virtual binder::Status setVideoLocalAreaNew(int32_t chan, const ::std::vector<com::fv::CommonParcelable>& video_vector) {

    int32_t i = 0;
    xVector cpp_vector = {0};
    x_vector_init(&cpp_vector, 2, sizeof(ipc_video_area_t));
    for (vector<CommonParcelable>::const_iterator iter = video_vector.begin(); iter != video_vector.end(); iter++) {
      if (iter->getLength() == sizeof(ipc_video_area_t)) {
          x_vector_set(&cpp_vector, i, (void *)iter->getData());
          i++;
      }
    }
    pfm_video_set_display_area_new(chan, cpp_vector);

    x_vector_free(&cpp_vector);
    return binder::Status::ok();
}*

（1）传递过来的值上加了const （注意，和不加的是两种不同的转换方式），又定义一次cpp_vector，将传过来的数组在通过x_vector_set设置到cpp_vector中，做参数传递给另一个进程的函数pfm_video_set_display_area_new做参数，不要忘记释放掉cpp_vector

（2）service端定义在aidl文件中

4、b进程函数使用这个结构体数组

ipc_video_area_t g_area_video[4] = {0};
void pfm_video_set_display_area_new(int chan, xVector vector) {
     static int change_video_area = 0;

     if(change_video_area == 0){
         int i;
         for(i = 0; i< 2; i++){
             memcpy(&g_area_video[i], (ipc_video_area_t*)x_vector_get(&vector, i), sizeof(ipc_video_area_t));
         }
         setVideoSurface(chan, &g_area_video[0], &g_area_video[1]);
         change_video_area = 1;
         printf("new_remote_area(%d %d %d %d %d)\n",g_area_video[1].area_x,g_area_video[1].area_y,g_area_video[1].area_w,g_area_video[1].area_h ,chan);
         printf("new_local_area(%d %d %d %d %d)\n",g_area_video[0].area_x,g_area_video[0].area_y,g_area_video[0].area_w,g_area_video[0].area_h ,chan);
     }else if(change_video_area == 1){
         int j;
         for(j = 2; j < 4; j++){
             memcpy(&g_area_video[j], (ipc_video_area_t*)x_vector_get(&vector, j-2), sizeof(ipc_video_area_t));
         }
         setVideoSurface(chan, &g_area_video[2], &g_area_video[3]);
         change_video_area = 0;
         printf("new_remote_area(%d %d %d %d %d)\n",g_area_video[3].area_x,g_area_video[3].area_y,g_area_video[3].area_w,g_area_video[3].area_h ,chan);
         printf("new_local_area(%d %d %d %d %d)\n",g_area_video[2].area_x,g_area_video[2].area_y,g_area_video[2].area_w,g_area_video[2].area_h ,chan);
     }
}

（1）进程使用，定义一开始我们传递的结构体类型g_area_video，然后循环从传过来的数组块空间拷贝给结构体数组

     for(i = 0; i< 2; i++){
             memcpy(&g_area_video[i], (ipc_video_area_t*)x_vector_get(&vector, i), sizeof(ipc_video_area_t));
         }

然后就可以使用这个数组中的数据了（将指针空间赋值给数组地址用memcpy）