OpenHarmony轻量型系统服务管理部件

简介

由于平台资源有限,且硬件平台多样,因此需要屏蔽不同硬件架构和平台资源的不同、以及运行形态的不同,提供统一化的系统服务开发框架。根据RISC-V、Cortex-M、Cortex-A不同硬件平台,分为两种硬件平台,以下简称M核、A核。

  • M核:处理器架构为Cortex-M或同等处理能力的硬件平台,系统内存一般低于512KB,无文件系统或者仅提供一个可有限使用的轻量级文件系统,遵循CMSIS接口规范。
  • A核:处理器架构为Cortex-A或同等处理能力的硬件平台,内存资源大于512KB,文件系统完善,可存储大量数据,遵循POSIX接口规范。

系统服务框架基于面向服务的架构,提供了服务开发、服务的子功能开发、对外接口的开发、以及多服务共进程、进程间服务调用等开发能力。其中:

  • M核:包含服务开发、服务的子功能开发、对外接口的开发以及多服务共进程的开发框架。
  • A核:在M核能力基础之上,包含了进程间服务调用、进程间服务调用权限控制、进程间服务接口的开发等能力。

系统架构

图 1 面向服务的架构

  • Provider:服务的提供者,为系统提供能力(对外接口)。
  • Consumer:服务的消费者,调用服务提供的功能(对外接口)。
  • Samgr:作为中介者,管理Provider提供的能力,同时帮助Consumer发现Provider的能力。

图 2 系统服务开发框架主体对象:

  • SamgrLite:主要提供服务的注册与发现能力。
  • Service:开发服务时,需要实现的服务的生命周期接口。
  • Feature:开发功能时,需要实现的功能的生命周期接口。
  • IUnknown:基于IUnknown开发服务或功能的对外接口。
  • IClientProxy:IPC调用时,消费者的消息发送代理。
  • IServerProxy:IPC调用时,开发者需要实现提供者的消息处理接口。

目录

表 1 系统服务框架源代码目录结构

名称描述
interfaces/kits/samgr_lite/samgrM核和A核系统服务框架对外接口定义。
interfaces/kits/samgr_lite/registryA核进程间服务调用的对外接口定义。
interfaces/kits/samgr_lite/communication/broadcastM核和A核进程内事件广播服务的对外接口定义。
services/samgr_lite/samgr/adapterPOSIX和CMSIS接口适配层来屏蔽A核M核接口差异。
services/samgr_lite/samgr/registryM核服务注册发现的桩函数。
services/samgr_lite/samgr/sourceM核和A核系统服务开发框架基础代码。
services/samgr_lite/samgr_clientA核进程间服务调用的注册与发现。
services/samgr_lite/samgr_serverA核进程间服务调用的IPC地址管理和访问控制。
services/samgr_lite/samgr_endpointA核IPC通信消息收发包管理。
services/samgr_lite/communication/broadcastM核和A核进程内事件广播服务。

约束

  • 系统服务开发框架统一使用C开发。
  • 同进程内服务间调用统一使用IUnknown接口对外象,消息接口统一由IUnknown接口传递给本服务。
  • 服务名和功能名必需使用常量字符串且长度小于16个字节。
  • M核:系统依赖上bootstrap服务,在系统启动函数中调用OHOS_SystemInit()函数。
  • A核:系统依赖samgr库,在main函数中调用SAMGR_Bootstrap()函数。

开发服务

  • 继承并重新定义服务:
typedef struct ExampleService {
    INHERIT_SERVICE;
    INHERIT_IUNKNOWNENTRY(DefaultFeatureApi);
    Identity identity;
} ExampleService;
  • 实现服务的生命周期函数:
static const char *GetName(Service *service)
{
    return EXAMPLE_SERVICE;
}

static BOOL Initialize(Service *service, Identity identity)
{
    ExampleService *example = (ExampleService *)service;
    // 保存服务的唯一身份标识,用来自己的IUnknown接口对服务发消息时使用。
    example->identity = identity;
    return TRUE;
}
static BOOL MessageHandle(Service *service, Request *msg)
{
    ExampleService *example = (ExampleService *)service;
    switch (msg->msgId) {
        case MSG_SYNC:
            // 业务处理
            break;
        default:break;
    }
    return FALSE;
}
static TaskConfig GetTaskConfig(Service *service)
{
    TaskConfig config = {LEVEL_HIGH, PRI_BELOW_NORMAL,
                         0x800, 20, SHARED_TASK};
    return config;
}
  • 创建服务对象:
static ExampleService g_example = {
    .GetName = GetName,
    .Initialize = Initialize,
    .MessageHandle = MessageHandle,
    .GetTaskConfig = GetTaskConfig,
    SERVER_IPROXY_IMPL_BEGIN,
        .Invoke = NULL,
        .SyncCall = SyncCall,
    IPROXY_END,
};
  • 向SAMGR注册服务及接口:
static void Init(void)
{
    SAMGR_GetInstance()->RegisterService((Service *)&g_example);
    SAMGR_GetInstance()->RegisterDefaultFeatureApi(EXAMPLE_SERVICE, GET_IUNKNOWN(g_example));
}
  • 定义服务的初始化入口:
SYSEX_SERVICE_INIT(Init);

开发服务的子功能

  • 继承并重新定义功能:
typedef struct DemoFeature {
    INHERIT_FEATURE;
    INHERIT_IUNKNOWNENTRY(DemoApi);
    Identity identity;
    Service *parent;
} DemoFeature;
  • 实现功能的生命周期函数:
static const char *FEATURE_GetName(Feature *feature)
{
    return EXAMPLE_FEATURE;
}

static void FEATURE_OnInitialize(Feature *feature, Service *parent, Identity identity)
{
    DemoFeature *demoFeature = (DemoFeature *)feature;
    demoFeature->identity = identity;
    demoFeature->parent = parent;
}

static void FEATURE_OnStop(Feature *feature, Identity identity)
{
    g_example.identity.queueId = NULL;
    g_example.identity.featureId = -1;
    g_example.identity.serviceId = -1;
}

static BOOL FEATURE_OnMessage(Feature *feature, Request *request)
{
    if (request->msgId == MSG_PROC) {
        Response response = {.data = "Yes, you did!", .len = 0};
        SAMGR_SendResponse(request, &response);
        return TRUE;
    } else {
        if (request->msgId == MSG_TIME_PROC) {
            LOS_Msleep(WAIT_FEATURE_PROC * 10);
            if (request->msgValue) {
                SAMGR_PrintServices();
            } else {
                SAMGR_PrintOperations();
            }
            AsyncTimeCall(GET_IUNKNOWN(g_example));
            return FALSE;
        }
    }
    return FALSE;
}
  • 创建功能对象:
static DemoFeature g_example = {
   .GetName = FEATURE_GetName,
   .OnInitialize = FEATURE_OnInitialize,
   .OnStop = FEATURE_OnStop,
   .OnMessage = FEATURE_OnMessage,
   DEFAULT_IUNKNOWN_ENTRY_BEGIN,
       .AsyncCall = AsyncCall,
       .AsyncTimeCall = AsyncTimeCall,
       .SyncCall = SyncCall,
       .AsyncCallBack = AsyncCallBack,
   DEFAULT_IUNKNOWN_ENTRY_END,
   .identity = {-1, -1, NULL},
};
  • 向SAMGR注册功能及接口:
static void Init(void){
    SAMGR_GetInstance()->RegisterFeature(EXAMPLE_SERVICE, (Feature *)&g_example);
    SAMGR_GetInstance()->RegisterFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE, GET_IUNKNOWN(g_example));
}
  • 定义功能的初始化入口:
SYSEX_FEATURE_INIT(Init);

开发进程内对外接口

  • 定义IUnknown接口:
typedef struct DemoApi {
    INHERIT_IUNKNOWN;
    BOOL (*AsyncCall)(IUnknown *iUnknown, const char *buff);
    BOOL (*AsyncTimeCall)(IUnknown *iUnknown);
    BOOL (*SyncCall)(IUnknown *iUnknown, struct Payload *payload);
    BOOL (*AsyncCallBack)(IUnknown *iUnknown, const char *buff, Handler handler);
} DemoApi;
  • 定义IUnknown的引用对象:
typedef struct DemoRefApi {
    INHERIT_IUNKNOWNENTRY(DemoApi);
} DemoRefApi;
  • 初始化接口对象:
static DemoRefApi api = {
    DEFAULT_IUNKNOWN_ENTRY_BEGIN,
        .AsyncCall = AsyncCall,
        .AsyncTimeCall = AsyncTimeCall,
        .SyncCall = SyncCall,
        .AsyncCallBack = AsyncCallBack,
    DEFAULT_IUNKNOWN_ENTRY_END,
};
  • 注册服务接口:
SAMGR_GetInstance()->RegisterFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE, GET_IUNKNOWN(api));

调用进程内服务

  • 获取服务的对外接口:
DemoApi *demoApi = NULL;
IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE);
if (iUnknown == NULL) {
    return NULL;
}
int result = iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&demoApi);
if (result != 0 || demoApi == NULL) {
    return NULL;
}
  • 接口调用:
if (demoApi->AsyncCallBack == NULL) {
    return NULL;
}
demoApi->AsyncCallBack((IUnknown *)demoApi, "I wanna async call callback good result!", AsyncHandler);
  • 释放接口:
int32 ref = demoApi->Release((IUnknown *)demoApi);

开发跨进程间对外接口

  • 继承IServerProxy替代继承IUnknown:INHERIT_SERVER_IPROXY
typedef struct DemoFeatureApi {
    INHERIT_SERVER_IPROXY;
    BOOL (*AsyncCall)(IUnknown *iUnknown, const char *buff);
    BOOL (*AsyncTimeCall)(IUnknown *iUnknown);
    BOOL (*SyncCall)(IUnknown *iUnknown, struct Payload *payload);
    BOOL (*AsyncCallBack)(IUnknown *iUnknown, const char *buff, IOwner notify, INotifyFunc handler);
} DemoFeatureApi;
  • 初始化IServerProxy对象:
static DemoFeature g_example = {
    SERVER_IPROXY_IMPL_BEGIN,
    .Invoke = Invoke,
    .AsyncCall = AsyncCall,
    .AsyncTimeCall = AsyncTimeCall,
    .SyncCall = SyncCall,
    .AsyncCallBack = AsyncCallBack,
    IPROXY_END,
};
  • 实现Invoke函数来处理Ipc消息:
static int32 Invoke(IServerProxy *iProxy, int funcId, void *origin, IpcIo *req, IpcIo *reply)
{
    DemoFeatureApi *api = (DemoFeatureApi *)iProxy;
    BOOL ret;
    size_t len = 0;
    switch (funcId) {
        case ID_ASYNCALL:
            ret = api->AsyncCall((IUnknown *)iProxy, (char *)IpcIoPopString(req, &len));
            IpcIoPushBool(reply, ret);
            break;
        case ID_ASYNTIMECALL:
            ret = api->AsyncTimeCall((IUnknown *)iProxy);
            IpcIoPushBool(reply, ret);
            break;
        case ID_SYNCCALL: {
            struct Payload payload;
            payload.id = IpcIoPopInt32(req);
            payload.value = IpcIoPopInt32(req);
            payload.name = (char *)IpcIoPopString(req, &len);
            ret = api->SyncCall((IUnknown *)iProxy, &payload);
            IpcIoPushString(reply, ret ? "TRUE" : "FALSE");
        }
            break;
        case ID_ASYNCCALLBACK: { // convert to sync proxy
            IpcIoPushString(reply, "Yes, you did!");
            IpcIoPushBool(reply, TRUE);
        }
            break;
        default:
            IpcIoPushBool(reply, FALSE);
            break;
    }
    return EC_SUCCESS;
}
  • 注册接口:与进程内接口注册一致
SAMGR_GetInstance()->RegisterFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE, GET_IUNKNOWN(g_example));

调用跨进程间服务

  • 获取跨进程服务的对外接口:
IClientProxy *demoApi = NULL;
IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE);
if (iUnknown == NULL) {
    return NULL;
}
int result = iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, (void **)&demoApi);
if (result != 0 || demoApi == NULL) {
    return NULL;
}
  • 调用Ipc消息接口:
IpcIo request;char data[250];
IpcIoInit(&request, data, sizeof(data), 0);
demoApi->Invoke(demoApi, 0, &request, NULL, NULL);
  • 释放接口:
int32 ref = demoApi->Release((IUnknown *)demoApi);

开发跨进程间服务调用客户端代理

  • 定义IPC接口客户端代理:
typedef struct DemoClientProxy {
    INHERIT_CLIENT_IPROXY;
    BOOL (*AsyncCall)(IUnknown *iUnknown, const char *buff);
    BOOL (*AsyncTimeCall)(IUnknown *iUnknown);
    BOOL (*SyncCall)(IUnknown *iUnknown, struct Payload *payload);
    BOOL (*AsyncCallBack)(IUnknown *iUnknown, const char *buff, IOwner notify, INotifyFunc handler);
} DemoClientProxy;
typedef struct DemoClientEntry {
    INHERIT_IUNKNOWNENTRY(DemoClientProxy);
} DemoClientEntry;
  • 实现客户端代理封装Ipc消息接口:
static BOOL AsyncCall(IUnknown *iUnknown, const char *buff)
{
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    IpcIoPushString(&request, buff);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_ASYNCALL, &request, NULL, NULL);
    return ret == EC_SUCCESS;
}

static BOOL AsyncTimeCall(IUnknown *iUnknown)
{
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_ASYNTIMECALL, &request, NULL, NULL);
    return ret == EC_SUCCESS;
}

static int Callback(IOwner owner, int code, IpcIo *reply)
{
    size_t len = 0;
    return strcpy_s(owner, MAX_DATA_LEN, (char *)IpcIoPopString(reply, &len));
}

static BOOL SyncCall(IUnknown *iUnknown, struct Payload *payload)
{
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    IpcIoPushInt32(&request, payload->id);
    IpcIoPushInt32(&request, payload->value);
    IpcIoPushString(&request, payload->name);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_SYNCCALL, &request, data, Callback);
    data[MAX_DATA_LEN - 1] = 0;
    HILOG_INFO(HILOG_MODULE_APP, "[TID:0x%lx]Remote response is %s!", pthread_self(), data);
    return ret == EC_SUCCESS;
}

struct CurrentNotify {
    IOwner notify;
    INotifyFunc handler;
};

static int CurrentCallback(IOwner owner, int code, IpcIo *reply)
{
    struct CurrentNotify *notify = (struct CurrentNotify *)owner;
    size_t len = 0;
    char *response = (char *)IpcIoPopString(reply, &len);
    HILOG_INFO(HILOG_MODULE_APP, "[TID:0x%lx]Notify Remote response is %s!", pthread_self(), response);
    notify->handler(notify->notify, response);
    return EC_SUCCESS;
}

static BOOL AsyncCallBack(IUnknown *iUnknown, const char *buff, IOwner notify, INotifyFunc handler)
{
    struct CurrentNotify owner = {notify, handler};
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    IpcIoPushString(&request, buff);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_ASYNCCALLBACK, &request, &owner, CurrentCallback);
    return ret == EC_SUCCESS;
}
  • 实现客户端代理的工厂方法:
void *DEMO_CreatClient(const char *service, const char *feature, uint32 size)
{
    (void)service;
    (void)feature;
    uint32 len = size + sizeof(DemoClientEntry);
    uint8 *client = malloc(len);
    (void)memset_s(client, len, 0, len);
    DemoClientEntry *entry = (DemoClientEntry *)&client[size];
    entry->ver = ((uint16)CLIENT_PROXY_VER | (uint16)DEFAULT_VERSION);
    entry->ref = 1;
    entry->iUnknown.QueryInterface = IUNKNOWN_QueryInterface;
    entry->iUnknown.AddRef = IUNKNOWN_AddRef;
    entry->iUnknown.Release = IUNKNOWN_Release;
    entry->iUnknown.Invoke = NULL;
    entry->iUnknown.AsyncCall = AsyncCall;
    entry->iUnknown.AsyncTimeCall = AsyncTimeCall;
    entry->iUnknown.SyncCall = SyncCall;
    entry->iUnknown.AsyncCallBack = AsyncCallBack;
    return client;
}
void DEMO_DestroyClient(const char *service, const char *feature, void *iproxy)
{
    free(iproxy);
}
  • 将客户端代理的工厂方法注册到SAMGR:
SAMGR_RegisterFactory(EXAMPLE_SERVICE, EXAMPLE_FEATURE, DEMO_CreatClient, DEMO_DestroyClient);
  • 获取跨进程服务的对外接口:
DemoClientProxy *demoApi = NULL;
IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE);
if (iUnknown == NULL) {
   return NULL;
}
int result = iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&demoApi);
if (result != 0 || demoApi == NULL) {
   return NULL;
}
  • 调用跨进程服务的客户端代理接口:
if (demoApi->AsyncCallBack == NULL) {
    return NULL;
}
demoApi->AsyncCallBack((IUnknown *)demoApi,
                       "I wanna async call callback good result!", NULL, AsyncHandler);
  • 释放接口:
int32 ref = demoApi->Release((IUnknown *)demoApi);

为了能让大家更好的学习鸿蒙(HarmonyOS NEXT)开发技术,这边特意整理了《鸿蒙开发学习手册》(共计890页),希望对大家有所帮助:https://qr21.cn/FV7h05

《鸿蒙开发学习手册》:

如何快速入门:https://qr21.cn/FV7h05

  1. 基本概念
  2. 构建第一个ArkTS应用
  3. ……

开发基础知识:https://qr21.cn/FV7h05

  1. 应用基础知识
  2. 配置文件
  3. 应用数据管理
  4. 应用安全管理
  5. 应用隐私保护
  6. 三方应用调用管控机制
  7. 资源分类与访问
  8. 学习ArkTS语言
  9. ……

基于ArkTS 开发:https://qr21.cn/FV7h05

  1. Ability开发
  2. UI开发
  3. 公共事件与通知
  4. 窗口管理
  5. 媒体
  6. 安全
  7. 网络与链接
  8. 电话服务
  9. 数据管理
  10. 后台任务(Background Task)管理
  11. 设备管理
  12. 设备使用信息统计
  13. DFX
  14. 国际化开发
  15. 折叠屏系列
  16. ……

鸿蒙开发面试真题(含参考答案):https://qr18.cn/F781PH

鸿蒙开发面试大盘集篇(共计319页):https://qr18.cn/F781PH

1.项目开发必备面试题
2.性能优化方向
3.架构方向
4.鸿蒙开发系统底层方向
5.鸿蒙音视频开发方向
6.鸿蒙车载开发方向
7.鸿蒙南向开发方向

<think>好的,我现在要处理用户关于鸿蒙南向开发的资料和教程的查询。首先,我需要回顾用户提供的引用内容,看看有哪些相关的信息可以整合。用户引用了五篇资料,其中提到了鸿蒙南向开发的知识点汇总、应用开发系统开发的前景对比、嵌入式开发的适合性、岗位需求以及具体的移植指南和上传下载教程。此外,用户还提到了器件驱动移植、设备开发手册、WLAN开发指南等内容。 接下来,我需要确定用户的主要需求是什么。用户明确表示想寻找南向开发的相关资料或教程,特别是“保姆级攻略”。因此,我需要整理出系统性的学习路径,涵盖基础知识、环境搭建、驱动开发、子系统适配、实战案例和进阶资源等方面。 根据引用内容,设备开发手册(引用2)和移植指南(引用4)是核心资源,可以作为主要推荐。另外,WLAN开发(引用3)和上传下载教程(引用5)可以作为具体案例。知识点汇总(引用1)和面试经历(引用1中的一条)也能帮助用户了解整体框架和实际应用。 接下来,我需要将这些资源按照逻辑顺序组织,确保用户能够循序渐进地学习。首先应该推荐系统性的手册和指南,然后涉及环境搭建和驱动开发,接着是子系统的适配和实战案例,最后提供社区和持续学习的资源。同时,要注意引用正确的来源,比如引用2对应设备开发手册,引用4对应移植指南等。 还需要考虑用户可能的疑问,比如南向开发的学习路径、需要哪些基础知识、如何实际操作等。因此,在回答中应该分点列出学习路线,每个部分都提供相应的教程链接或文档指引,并标注引用来源。此外,相关问题部分需要涵盖用户可能进一步想知道的内容,比如前景、适合性、岗位需求等,这些在引用中都有涉及,可以引导用户深入阅读。 最后,要确保回答结构清晰,符合用户要求的格式,使用中文,正确应用LaTeX格式(虽然本问题中可能涉及较少数学公式,但需注意行内和独立公式的格式),并在引用处正确添加标识。同时,生成的相关问题要覆盖用户可能感兴趣的其他方面,帮助用户全面了解南向开发的各个方面。</think>### 鸿蒙南向开发学习路线与资料整理 #### 一、系统学习路径 1. **基础入门** - 推荐阅读《OpenHarmony设备开发学习手册》[^2],涵盖环境搭建、内核移植、驱动开发等核心内容。 - 学习设备开发框架,例如器件驱动移植方法[^1]和子系统裁剪适配指南[^4]。 2. **环境搭建** - 使用鸿蒙南向开发专用环境(如Hi3861/Hi3516开发板),参考官方文档配置编译工具链。 - 示例代码库:https://gitcode.com/HarmonyOS_MN/733GH 3. **驱动开发** - WLAN驱动开发:通过`DRIVERS_WLAN_XXX`开关控制内核功能,结合`//device/MySoCVendor/peripheral/build/standard/`中的Makefile实现[^3]。 - 其他外设驱动(GPIO、I2C等)适配方法可参考移植指南。 4. **子系统适配** - 鸿蒙系统按“系统 > 子系统 > 部件”层级设计,需根据需求裁剪非必要部件。例如文件系统、网络协议栈的适配方法。 5. **实战案例** - 上传下载功能实现:使用`@ohos.request`接口开发任务管理,结合HFS服务器完成文件传输[^5]。 - 轻量系统芯片移植完整流程示例。 --- #### 二、保姆级教程推荐 | 类型 | 资源链接/文档 | 重点内容 | |-----------|--------------------------------------------------------------------------|-------------------------------| | **系统性手册** | [OpenHarmony设备开发学习手册](https://gitcode.com/HarmonyOS_MN/733GH/overview) | 环境配置、驱动开发、内核移植 | | **移植指南** | [轻量系统芯片移植指南](引用4) | 子系统裁剪、部件适配、编译调试 | | **API实战** | [上传下载功能开发教程](引用5) | 网络任务管理、接口调用实践 | | **驱动开发** | [WLAN开发手册](引用3) | 内核配置、Makefile解析、外设驱动调试 | --- #### 三、学习建议 1. **先掌握嵌入式基础**:C语言、RTOS原理、硬件通信协议(如UART/SPI)。 2. **结合开发板实操**:通过Hi3861/Hi3516等官方开发板验证驱动和子系统功能。 3. **关注社区更新**:鸿蒙南向开发技术迭代快,需定期查阅[持续更新文档](引用1)。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值