c印记（十）： parcel(数据集，数据容器)实现

最新推荐文章于 2023-09-18 16:58:40 发布
最新推荐文章于 2023-09-18 16:58:40 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： c/c++ 工具库或API 文章标签： parcel android 数据集 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuanwolanxue/article/details/66970814
版权

一、写在前面的话

parcel是Android中的Framework层的一个数据结构，以c++实现，可以理解为数据集或者数据容器，在android将其作为函数的参数以及binder通信等，这里是仿照Android的parcel写的一个c语言版本的parcel，当然并不是完全将Android的parcel翻译成c语言，还会对其进行精简，将一些复杂的东西统统丢掉，只留下，数据容器操作相关的部分。以便以后在各种通信（网络，线程间，硬件接口如SPI之间），数据封装等等情况下，可以快速使用。

二、接口定义

也就是一个header file。

#ifndef __TINY_PARCEL_H__
#define __TINY_PARCEL_H__

#include "general_type.h"
#include "general_error.h"

/***************************************************************************
 *
 * macro declaration
 *
 ***************************************************************************/

/***************************************************************************
 *
 * data structure declaration
 *
 ***************************************************************************/

/** @brief parcel data and interface */
typedef struct tiny_parcel_s
{
    GU08* data; /**< pointer to data buffer */
    GU32 pos;   /**< offset position of parcel operation */
    GU32 size;  /**< the size of data buffer */

    /**
    *@brief  write data to parcel
    *
    *@param  parcel [in] pointer to parcel data structure.
    *@param  data   [in] pointer to data buffer.
    *@param  len    [in] the length of data
    *
    *@retuen success: G_OK, fail: error code.
    *@see
    */
    GS32(*write)(struct tiny_parcel_s* parcel, const void* data, GU32 len);

    /**
    *@brief  write a 32 bits integer value to parcel
    *
    *@param  parcel [in] pointer to parcel data structure.
    *@param  value  [in] the value of integer
    *
    *@retuen success: G_OK, fail: error code.
    *@see
    */
    GS32 (*writeInt32)(struct tiny_parcel_s* parcel, GS32 value);


    /**
    *@brief  write a 64 bits integer value to parcel
    *
    *@param  parcel [in] pointer to parcel data structure.
    *@param  value  [in] the value of integer
    *
    *@retuen success: G_OK, fail: error code.
    *@see
    */
    GS32(*writeInt64)(struct tiny_parcel_s* parcel, GS64 value);

    /**
    *@brief  write a float value to parcel
    *
    *@param  parcel [in] pointer to parcel data structure.
    *@param  value  [in] the value of float
    *
    *@retuen success: G_OK, fail: error code.
    *@see
    */
    GS32(*writeFloat)(struct tiny_parcel_s* parcel, GFLT value);

    /**
    *@brief  write a string to parcel
    *
    *@param  parcel [in] pointer to parcel data structure.
    *@param  value  [in] pointer to string
    *
    *@retuen success: G_OK, fail: error code.
    *@see
    *
    *@note the string must end with '\0'.
    *
    */
    GS32(*writeString)(struct tiny_parcel_s* parcel, const char* value);

    /**
    *@brief  read data from parcel
    *
    *@param  parcel    [in]  pointer to parcel data structure.
    *@param  out_data  [out] pointer to out data buffer.
    *@param  len       [in]  the length of out data(request read)
    *
    *@retuen success: G_OK, fail: error code.
    *@see
    */
    GS32(*read)(struct tiny_parcel_s* parcel, void* out_data, GU32 len);

    /**
    *@brief  read a 32 bits integer from parcel
    *
    *@param  parcel [in]  pointer to parcel data structure.
    *
    *@retuen the value of integer
    *@see
    */
    GS32(*readInt32)(struct tiny_parcel_s* parcel);

    /**
    *@brief  read a 64 bits integer from parcel
    *
    *@param  parcel [in]  pointer to parcel data structure.
    *
    *@retuen the value of integer
    *@see
    */
    GS64(*readInt64)(struct tiny_parcel_s* parcel);

    /**
    *@brief  read a float from parcel
    *
    *@param  parcel [in]  pointer to parcel data structure.
    *
    *@retuen the value of float
    *@see
    */
    GFLT(*readFloat)(struct tiny_parcel_s* parcel);

    /**
    *@brief  read a string from parcel
    *
    *@param  parcel [in]  pointer to parcel data structure.
    *
    *@retuen success: the pointer to string, fail: NULL
    *@see
    */
    GSTR(*readString)(struct tiny_parcel_s* parcel);

}tiny_parcel_t;
/***************************************************************************
 *
 * API declaration
 *
 ***************************************************************************/

 /**
 *@brief  initialize parcel data structure
 *
 *@param  parcel [io] pointer to parcel data structure.
 *@param  data   [in] pointer to data buffer.
 *@param  len    [in] the length of out data()
 *
 *@retuen success: G_OK, fail: error code.
 *@see
 *
 *@note this interface set does not thread safe
 *
 */
 GS32 TinyParcelInitialize(tiny_parcel_t* parcel, void* data, GU32 len);

#endif //end of __TINY_PARCEL_H__

其中general_xxx.h 就是前一章说的一些通用的头文件，其中定义基本数据类型，以及 功能 宏，通用错误号等等。 当然，这里也可以自己在这个parcel的header file中定义，但是因为c印记 这一系列的文章，绝大多数都会使用到这些基本数据类型以及通用错误号等东西，所以就特意将这些聚拢成几个公用的header file。

三、pracel功能的具体实现

#include <stdio.h>
#include <string.h> /** 标准c相关头文件 */

#include "tiny_parcel.h" /** parcel 接口声明头文件 */


/***************************************************************************
*
* macro define
*
***************************************************************************/

/** 宏定义一些log输出接口， 移植的时候只需要修改这个宏就可以改变log的输出方式 */
#define LOGE printf
#define LOGD printf
/***************************************************************************
*
* data structure define
*
***************************************************************************/


/***************************************************************************
*
* inner API define
*
***************************************************************************/
static inline GS32 TinyPracelWriteCommon(char* dst, GU32 dst_size, GU32* pos,  const void* data, GU32 len)
{
    GS32 ret = G_ErrorBadParameter;

    if (data && (len > 0))
    {
        if ((*pos + len) <= dst_size)
        {
            memcpy(dst + *pos, data, len);
            *pos += len;
            ret = G_OK;
        }
        else
        {
            LOGE("doesn't enough data or space(pos+len(%d) < size(%d)) \n", (*pos + len), dst_size);
            ret = G_ErrorOverflow;
        }
    }

    return ret;
}

static inline GS32 TinyPracelWrite(tiny_parcel_t* parcel, const void* data, GU32 len)
{
    return TinyPracelWriteCommon(parcel->data, parcel->size, &(parcel->pos), data, len);
}

static GS32 TinyPracelWriteInt32(tiny_parcel_t* parcel, GS32 value)
{
    return TinyPracelWrite(parcel, (const void*)&value, sizeof(value));
}

static GS32 TinyPracelWriteInt64(tiny_parcel_t* parcel, GS64 value)
{
    return TinyPracelWrite(parcel, (const void*)&value, sizeof(value));
}

static GS32 TinyPracelWriteFloat(tiny_parcel_t* parcel, GFLT value)
{
    return TinyPracelWrite(parcel, (const void*)&value, sizeof(value));
}

static GS32 TinyPracelWriteString(tiny_parcel_t* parcel, const char* value)
{
    return TinyPracelWrite(parcel, (const void*)value, value ? (strlen(value) + 1) : 0);
}

static inline GS32 TinyPracelRead(tiny_parcel_t* parcel, void* out_data, GU32 len)
{
    return TinyPracelWriteCommon(out_data, parcel->size, &(parcel->pos), parcel->data, len);
}

static GS32 TinyPracelReadInt32(tiny_parcel_t* parcel)
{
    GS32 value = 0;
    TinyPracelRead(parcel, (void*)&value, sizeof(value));

    return value;
}

static GS64 TinyPracelReadInt64(tiny_parcel_t* parcel)
{
    GS64 value = 0;
    TinyPracelRead(parcel, (void*)&value, sizeof(value));

    return value;
}

static GFLT TinyPracelReadFloat(tiny_parcel_t* parcel)
{
    GFLT value = 0;
    TinyPracelRead(parcel, (void*)&value, sizeof(value));

    return value;
}

static GSTR TinyPracelReadString(tiny_parcel_t* parcel)
{
    GSTR value = NULL;
    GU32 avail = parcel->size - parcel->pos;

    if (avail > 0)
    {
        GSTR str = (GSTR)(parcel->data + parcel->pos);
        // is the string's trailing NUL within the parcel's valid bounds?
        GSTR eos = memchr(str, '\0', avail);

        if (eos)
        {
            GU32 len = eos - str;
            value = str;
            parcel->pos += (len + 1); /** + 1, indicate skip '\0' */
        }
    }

    return value;
}
/***************************************************************************
*
* API define
*
***************************************************************************/

GS32 TinyPracelInitialize(tiny_parcel_t* parcel, void* data, GU32 len)
{
    GS32 ret = G_ErrorBadParameter;

    if (parcel && data && (len > 0))
    {
        parcel->data = data;
        parcel->size = len;
        parcel->pos = 0;

        /** register inteface */
        parcel->read = TinyPracelRead;
        parcel->readFloat = TinyPracelReadFloat;
        parcel->readInt32 = TinyPracelReadInt32;
        parcel->readInt64 = TinyPracelReadInt64;
        parcel->readString = TinyPracelReadString;

        parcel->write = TinyPracelWrite;
        parcel->writeFloat = TinyPracelWriteFloat;
        parcel->writeInt32 = TinyPracelWriteInt32;
        parcel->writeInt64 = TinyPracelWriteInt64;
        parcel->writeString = TinyPracelWriteString;

        ret = G_OK;
    }

    return ret;
}

四、使用例子

1、 用途

  • parcel可以用作函数的参数，以支持各种参数组合以及后续扩展，就比如Android中AwesomePlayer中的invoke接口(其原型为：status_t invoke(const Parcel &request, Parcel *reply);)

  • parcel可以用来实现协议通信，比如模组与模组之间，线程与线程之间，进程与进程之间，甚至是系统与系统之间也可以使用parcel将需要传输的数据或信息按照自定义的格式（就相当于约定好的协议）组合写到一个buffer之中，然后通过网络，SPI，uart，I2C等方式传输到目标系统，再使用parcel的read接口，按照自定义的格式一一读取出来

2、例子

#include <stdio.h>
#include <string.h>

#include "tiny_parcel.h"
/***************************************************************************
*
* macro define
*
***************************************************************************/
#define LOGE printf
#define LOGD printf

/***************************************************************************
*
* API define
*
***************************************************************************/
int main(int argc, char* argv[])
{
#define PARCEL_BUF_SIZE 1024

    char temp_buf[PARCEL_BUF_SIZE];

    char* pbuf1 = temp_buf;

    char* pbuf2 = NULL; 
    tiny_parcel_t write_parcel;
    GS32 dataInt32 = 123;
    GS64 dataInt64 = 456;
    GFLT dataFloat = 789.123;
    GSTR dataString = "this is string";
    GSTR dataData = "this is data"; /** fake pure data */
    GU32 dataLen = strlen(dataData);


    GS32 ret = TinyParcelInitialize(&write_parcel, pbuf1, PARCEL_BUF_SIZE);

    if (ret == G_OK)
    {
        LOGD("write data:\n");
        LOGD("int32: %d\n", dataInt32);
        LOGD("int64: %lld\n", dataInt64);
        LOGD("float: %f\n", dataFloat);
        LOGD("string: %s\n", dataString);
        LOGD("pure data: %s\n", dataData);

        /** write data to parcel */
        write_parcel.writeInt32(&write_parcel, dataInt32);
        write_parcel.writeInt64(&write_parcel, dataInt64);
        write_parcel.writeFloat(&write_parcel, dataFloat);
        write_parcel.writeString(&write_parcel, dataString);
        ret = write_parcel.write(&write_parcel,dataData, dataLen);

        if (ret == G_OK)
        {       
            /** fake data transform */
            pbuf2 = pbuf1;
            LOGD("\n=======================================\n");
            /** read data from parcel */
            {/** fake other thread/porcessor/system */
                GS32 readInt32 = 0;
                GS64 readInt64 = 0;
                GFLT readFloat = 0.0;
                GSTR readString = NULL;         
                GU32 readDataLen = dataLen;
                char readPureData[PARCEL_BUF_SIZE] = {0};
                tiny_parcel_t read_parcel;

                ret = TinyParcelInitialize(&read_parcel, pbuf2, PARCEL_BUF_SIZE);

                if (ret == G_OK)
                {
                    readInt32 = read_parcel.readInt32(&read_parcel);
                    readInt64 = read_parcel.readInt64(&read_parcel);
                    readFloat = read_parcel.readFloat(&read_parcel);
                    readString = read_parcel.readString(&read_parcel);

                    ret = read_parcel.read(&read_parcel, readPureData, readDataLen);

                    if (ret == G_OK)
                    {
                        LOGD("read data:\n");
                        LOGD("int32: %d\n", readInt32);
                        LOGD("int64: %lld\n", readInt64);
                        LOGD("float: %f\n", readFloat);
                        LOGD("string: %s\n", readString);
                        LOGD("pure data: %s\n", readPureData);

                        LOGD("\n=========================================\n");
                        if ((dataInt32 == readInt32) &&
                            (dataInt64 == readInt64) &&
                            (dataFloat == readFloat) &&
                            (!strcmp(dataString, readString)) &&
                            (!memcmp(dataData, readPureData, dataLen)))
                        {
                            LOGD("data check OK ...\n");
                        }
                        else
                        {
                            LOGD("data check failed ...\n");
                        }
                    }
                    else
                    {
                        LOGE("read pure data from parcel failed(0x%08x)\n", ret);
                    }
                }
                else
                {
                    LOGE("initialize read parcel failed(0x%08x)\n", ret);
                }

            }       
        }
        else
        {
            LOGE("read pure data to parcel failed(0x%08x)\n", ret);
        }

    }
    else
    {
        LOGE("initialize write parcel failed(0x%08x)\n", ret);
    }



    return 0;
}
玄道公子
关注
专栏目录
Android C++ Parcel
q1165328963的博客
02-24 2760
成员变量mData是存储数据的内存，mDataSize是数据的大小，mDataCapacity是存储内存的容量，mDataPos是数据的位置。 mObjects是为了保存Binder类对象使用的，mObjectsSize数据里面保存的Binder类对象的数量，mObjectsCapacity是内存中可以保存Binder类对象的大小容量。 成员变量mOwner是释放内存的方法，可能设置，也可能不设置。 ServiceManager IBinder b = ServiceManager.getServiceOr
C++ Parcel
sunshine_8的专栏
03-13 4481
Android中的Parcel类困惑了我好一段时间（当然现在也没把Parcel完全弄明白），查了一些资料也不知道它里面是以一种什么格式存储数据的。因为它对外提供的读写函数都没有提到具体一个读写函数到底是读写Parcel中的哪一块地址里的数据。比如网上有这么两段代码：     public void writeToParcel(Parcel out) { //当前数据写入到Parcel中
android 进程间通信数据（二）------parcel的实现
weixin_30379911的博客
08-25 112
Serialize是java原生就自带的东西，我们可以看到android的源码 所以看看android是如何实现parcel的，这对我们自己代码设计有什么启发。 Parcel： 在android中，parcel的源码如下： Frameworks/base/core/java/android/os/Parcel.java /** * Write an integer...
Android中Parcel的分析以及使用
u010855084的专栏
10-10 640
简单点来说：Parcel就是一个存放读取数据的容器， Android系统中的binder进程间通信(IPC)就使用了Parcel类来进行客户端与服务端数据的交互，而且AIDL的数据也是通过Parcel来交互的。在Java空间和C++都实现了Parcel，由于它在C/C++中，直接使用了内存来读取数据，因此，它更有效率。 分析Binder机制中的客户端与服务器端进行实际操作ontransact
Parcel 实现代码分割 -- 初识 Parcel
YuqiRealm.com
01-25 760
代码分割 使用 JavaScript 进行前端开发，如果不进行代码分割，最后会打包成一个很大的 JS 文件。大文件的下载时间就会比较长，而用户有可能并不需要一次性加载所有的功能，完全没有必要下载这么大的文件。 所以，很有必要将较大的 JS 包拆分成多个更小的包，也就是代码分割。这些小包可以按需或一步加载。之前我们使用 webpack 就能做到，parcel 使用起来则更加简单。 Parcel
Android中使用C++程序读写Parcel的简单例子
奋斗的程序猿的博客
09-18 334
后来看了一些源码，包括Parcel.h和Parcel.cpp。/********************** 以下是 Parcel_test.cpp 程序 ****************************//********************** 以上是 Parcel_test.cpp 程序 ****************************//********************** 以下是Android.mk文件 ****************************/
parcel:Parcel 是 Go 中的 JMAP 服务器实现
07-04
Parcel是一款用Go语言编写的服务器软件，它实现了JMAP（JSON Meta Application Protocol）标准，旨在提供高效、安全的邮件和其他在线数据的同步和访问服务。JMAP是一种现代的、RESTful的协议，用于在客户端与服务器...
前端构建工具：Parcel.zip
最新发布
08-18
史上最全web前端技术全套教程，包括： 前端API集成 前端基础知识 前端开发最佳实践 前端性能优化 前端构建工具 前端框架和库 前端测试工具 前端状态管理 等流行技术的系列教程
using android::Parcel Parcel原型
06-14
`using android::Parcel` 是 Android 操作系统中的一段 C++ 代码，用于声明当前文件...在 Android 操作系统中，`android::Parcel` 类型通常用于在进程间传输数据，它包含了一些属性和方法，用于序列化和反序列化数据。
parcel-plugin-change-file:parcel 的文件处理插件 \ Jump parcel bundler in html & Replace html string & Copy files at parcel builded
05-07
$ yarn add -D parcel-plugin-change-file :bookmark: Feature1：释经index.html 添加<!--[ your-code ]--> < body > <!--[ [removed][removed] ]--> lodash.min.js跳至包裹捆绑器，此构建...
parcel-plugin-sw-cache::package::construction_worker:Parcel插件，用于使用Service Worker进行缓存
05-06
yarn add -D parcel-plugin-sw-cache # or npm install -D parcel-plugin-sw-cache 该插件是使用项目的package.json中的cache对象配置的。 （）。 插件使用的配置密钥（首先是默认选项）： { "dependencies" : { ...
Parcel
chenglansky的专栏
08-25 745
Parcel，翻译过来是“打包”的意思。打包干什么呢？是为了序列化。     如果要在进程之间传递一个整数，很简单，直接传就是行了；如果要传一个字符串，就稍微复杂了点：需先分配一块可以容纳字符串的内存，然后将字符串复制到内存中，再传递（新手可能问：为啥不直接把字符串的引用传过去呢？学过C/C++的地球人都知道：进程有自己的内存地址空间，一个进程中的1000地址可能在另一个进程中是100000
parcel 初探
sansan的专栏
12-26 331
日期：2017-12-20 作者：sansanparcel一个号称零配置的新的前端构建工具。 官方介绍: Parcel 是一个网络应用打包工具, 适用于经验不同的开发者. 它利用多核处理提供了极快的速度, 并且不需要任何配置. 大坑坑一：node版本的要求官方文档没有告诉你（也可能是我没有看到）的是：parcel对node版本的最低要求，笔者刚开始使用的是node -v v6.11.3，
Parcel学习
u010035154的专栏
06-06 520
今天接触中间层的时候发现parcel，一直不太清楚他的用法，今天仔细的查了查，总结一下，以供以后学习： Parcel就是一个存放读取数据的容器， Android系统中的binder进程间通信(IPC)就使用了Parcel类来进行客户端与服务端数据的交互，而且AIDL的数据也是通过Parcel来交互的。在Java空间和C++都实现了Parcel，由于它在C/C++中，直接使用了内存来读取数据，因此
Parcel用法
在云端的专栏
08-25 3999
android提供了一种新的类型：Parcel。本类被用作封装数据的容器，封装后的数据可以通过Intent或IPC传递。 除了基本类型以外，只有实现了Parcelable接口的类才能被放入Parcel中。 Parcelable实现要点：需要实现三个东西: 1）writ
序列化机制之-Parcel
koozxcv的博客
06-22 960
一．先从Serialize说起          我们都知道Java中的Serialize机制，译成串行化、序列化……，其作用是能将数据对象存入字节流当中，在需要时重新生成对象。主要应用是利用外部存储设备保存对象状态，以及通过网络传输对象等。   二．Android中的新的序列化机制          在Android系统中，定位为针对内存受限的设备，因此对性能要求更高，另外系统中采用了新
Android 中parcelable 和 parcel
私房菜
07-29 4154
之前一直在用这两个类，但是没有细细的研究，偶尔在网上看到了相关的解释，感觉不是很详细，这里小结一下，如果还有什么遗漏希望有朋友能提出来。1. parcel首先说一下parcel，因为 parcelable 核心也是依赖 parcel 的。java中serialize机制，是能将数据对象存入字节流中，在需要的时候重新生成对象，主要应用是利用外部存储设备保存对象状态，以及通过网络传输对象等。
浅析Android中Parcel类
欢迎关注微信公众号：DroidMind
09-11 3911
在浅析绑定远程服务bindService基本原理与AIDL分析中，我们在使用服务调用远程服务的函数时，到底可以传递哪些类型的参数类，在AIDL进程间传递复杂数据类型中，我们详细解析了它可以传递的数据类型，那么到底为什么它只能传递这些数据类型。其实我们在调用远程服务的时候，会将参数进行统一的打包到Parcel中，然后在服务端会对Parcel进行统一的读取，并且打包过程和读取过程参数的顺序要保持一致，为
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值