第一个纯血鸿蒙应用（Napi开发-ArtTS调用C/C++）

1.行业配景

纯血鸿蒙，即鸿蒙Next版已于2014年1月正式发版，鸿蒙生态设备数量已经突破10亿台，已经有凌驾15000+个应用和元服务上架。鸿蒙生态不只是移动设备这么简单，他打造的是一个1+8+n的全场景战略，真正做到了“万物互联”。近来较火的“云端一体化”计划，开发者只必要同一种开发语言写一套代码，不用关心云端部署、不用关心负载平衡、CPU、内存等性能瓶颈，将运维工作交给华为团队，且接口调用按调用次数收费，到达了“无运维、零浪费”的效果。
2.预研配景

近期公司有预研纯血鸿蒙应用层调用C/C++代码的需求，借此时机深入了解、学习鸿蒙生态。
本文会以一个《高仿Mac计算器》应用开发为案例，解说鸿蒙应用的开发流程，重点解说c++开发模块，主要讲述开发、编译、引用流程，而不是深入c/c++语法细节。
3.目的

鸿蒙开发作为一个全新的生态、要零底子看本文可能有点吃力，不外笔者只管以通俗语言来描述，另外由于篇幅限制，本文不再从零解说鸿蒙团体开发流程、ArtTS语法细节，重点解说Napi开发流程。
学习本文后能到达的效果：
1.可以从0开发一个c/c++模块，并编译天生so包
2.借助DevEco Studio可将三方so包集成至项目里
4.Napi概述

4.1.简介

Node-API是用于封装JavaScript能力为Native插件的API，独立于底层JavaScript，并作为Node.js的一部分。
4.2.支持的能力

Node-API可以去除底层的JavaScript引擎的差异，提供一套稳固的接口。
HarmonyOS的Node-API组件对Node-API的接口进行了重新实现，底层对接了ArkJS等引擎。当前支持Node-API标准库中的部分接口。
4.3.交互及场景分析

交互方式	适用场景	本文是否包罗
ArtTS直接调用C/C++	native和ArtTS源码在一块，均从零混合开发	是
C/C++调用ArtTS	通常用于防逆向、加大逆向难度	否
ArtTS调用so包间接调用C/C++	将C/C++编译为so包作为类似STL，可供甲方调用	是
C/C++Native层调用so包	用户C/C++有二次开发封装的场景，比方基于so包二次封装	否

4.4.当前支持的Node-API标准库接口


5.开发环境

5.1.开发工具

5.1.1.DevEco Studio版本

Build Version: 5.0.3.900, built on October 8, 2024
5.1.2.SDK版本

HarmonyOS NEXT Beta1 SDK, based on OpenHarmony SDK Ohos_sdk_public 5.0.0.71 (API Version 12 Release)
5.1.3.项目模子

选择stage模子
拓展：
HarmonyOS先后提供了两种应用模子

• FA（Feature Ability）模子：HarmonyOS早期版本开始支持的模子，已经不再主推。
  
• Stage模子：HarmonyOS 3.1版本开始新增的模子，是目前主推且会长期演进的模子。
  

5.1.4.技能栈

5.1.4.1.界面搭建

基于声明式UI-ArtUI
演变过程：JavaScript =>TypeScript => ArtTs =>ArtUI
感爱好的小伙伴可以基于演变汗青补充下营养
5.1.4.2.算法逻辑

四则运算基于c/c++语法
5.1.4.3.NDK胶水语言

NAPI作为ArtTs相互调用C/C++的粘合剂，本质上也是C/C++实现的，必要深入学习了解其api
5.1.4.4.编译工具链

CMake编译工具，C/C++代码通过CMake编译工具编译成动态链接库so文件，使用index.d.ts文件对外提供接口，ArkTS引入so文件后调用此中的接口。
6.效果图

6.1.MacOS原版计算器效果

6.2.高仿MacOS计算器效果图

6.3.Gif动图展示

7.项目结构

项目结构交复杂，本文只简明扼要的列举用到的地方，所谓“用”有两方面的意思，要么基于之前的设置进行修改，一样平常为设置文件；要么创建新文件，一样平常为开发代码文件。
7.1.so包module

1. |─CDemo                                // 项目根目录
2. ├──app/src/main                        // 代码区  
3. │  │
4. │  ├──cpp                              // C/C++代码区
5. │  │  ├──CMakeLists.txt                // CMake编译配置文件
6. │  │  ├──napi_init.cpp                 // napi代码
7. │  │  ├──utils
8. │  │  │  └──calculator.h               // C++头文件，用于函数、变量定义
9. │  │  │  └──calculator.cpp             // C++文件，用户逻辑实现
10. │  │  └──types                         // ArtTS层
11. │  │     └──libapp                     // ArtTS层识别的接口存放文件夹
12. │  │        ├──index.d.ts              // ArtTS层识别的接口文件
13. │  │        └──oh-package.json5        // 接口注册配置文件
14. │  ├──ets                              // ArtTS代码区
15. │  │  ├──entryability                  // 能力包
16. │  │  ├──EntryAbility.ets              // 程序入口类
17. │  │  ├──pages                         // 界面包
18. │  │  └──Index.ets                     // 主界面
19. │  ├──resources                        // 资源文件目录
20. │  └──module.json5                     // 模块级配置文件
21. └──app/build-profile.json5             // 项目构建文件

复制代码

7.2.宿主module

1. |─Calculator                           // 项目根目录
2. ├app                                   // 代码区
3. ├──libs                                // 本地三方库
4. │  └──arm64-v8a                        // arm64-v8a包
5. │  └──────libapp.so                    // arm64-v8a架构so能力包
6. │  └──x86_64                           // x86_64包
7. │  └──────libapp.so                    // x86_64架构so能力包
8. ├──src/main                            // 代码区  
9. │  └──ets                              // ArtTS代码区
10. │     ├──entryability                  // 能力包
11. │     │  └──EntryAbility.ets           // 程序入口类
12. │     └──pages                         // 界面包
13. │        └──Index.ets                  // 主界面
14. └──────────────────resources           // 资源文件目录
15. └──────────────────module.json5        // 模块级配置文件

复制代码

8.so包module开发步调

8.1.C/C++代码算法逻辑编写

文件放到app/src/main/cpp目录下：

1. /**
2. * 加法运算
3. */
4. double add(double param1, double param2);
5. /**
6. * 减法运算
7. */
8. double sub(double param1, double param2);
9. /**
10. * 乘法运算
11. */
12. double mul(double param1, double param2);
13. /**
14. * 除法运算
15. */
16. double div(double param1, double param2);
17. /**
18. * 取反运算
19. */
20. double oppo(double param);

复制代码

1. #include "calculator.h"
2. double add(double param1, double param2) {
3.     return param1 + param2;
4. }
6. double sub(double param1, double param2) {
7.     return param1 - param2;
8. }
10. double mul(double param1, double param2) {
11.     return param1 * param2;
12. }
14. double div(double param1, double param2) {
15.     if (param2 == 0) {
16.         return 0;
17.     }
18.     return param1 / param2;
19. }
21. double oppo(double param) {
22.     return -param;
23. }

复制代码

8.2.CMake文件编写

这个文件是创建Native项目的时间主动天生的，我们一样平常环境下仅仅必要改动两个地方：
#add_library
#target_link_libraries

1. # CMAKE 的最小版本号
2. cmake_minimum_required(VERSION 3.5.0)
3. # 项目名
4. project(Calculator)
5. # 设置编译参数
6. set(NATIVERENDER_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})
8. if(DEFINED PACKAGE_FIND_FILE)
9.     include(${PACKAGE_FIND_FILE})
10. endif()
11. # 指定目标include目录路径
12. include_directories(${NATIVERENDER_ROOT_PATH}
13.                     ${NATIVERENDER_ROOT_PATH}/include)
14.                     
15. # 指定C/C++源码目录路径，此路径是相对于CmakeLists.txt的路径，同时注意有多个源文件要用空格或换行符隔开
16. add_library(app SHARED
17.             napi_init.cpp
18.             utils/calculator.h
19.             utils/calculator.cpp)
20. # 指定C/C++生成的动态链接的库名字
21. target_link_libraries(app PUBLIC libace_napi.z.so)

复制代码

8.3.Napi代码编写

1. // 引入Napi模块
2. #include "napi/native_api.h"
3. // 引入自定义头文件
4. #include "./utils/calculator.h"
5. /**
6. * 获取 ArtTs层 function(double a,double b)签名函数的参数
7. * @param env ArtTS层环境
8. * @param info ArtTS层方法信息
9. * @param param0 参数1地址
10. * @param param1 参数2地址
11. */
12. static void getTwoDoubleParams(napi_env env, napi_callback_info info, double *param0, double *param1) {
13.     size_t argc = 2;
14.     napi_value args[2] = {nullptr};
16.     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
18.     napi_valuetype valuetype0;
19.     napi_typeof(env, args[0], &valuetype0);
21.     napi_valuetype valuetype1;
22.     napi_typeof(env, args[1], &valuetype1);
24.     double value0;
25.     napi_get_value_double(env, args[0], &value0);
26.     *param0 = value0;
27.     double value1;
28.     napi_get_value_double(env, args[1], &value1);
29.     *param1 = value1;
30. }
31. /**
32. * 加法运算翻译
33. *
34. * @param env
35. * @param info
36. * @return
37. */
38. static napi_value Add(napi_env env, napi_callback_info info) {
39.     double value0 = 0, value1 = 0;
40.     getTwoDoubleParams(env, info, &value0, &value1);
41.     napi_value sum;
42.     napi_create_double(env, add(value0, value1), &sum);
43.     return sum;
44. }
46. /**
47. * 减法运算翻译
48. *
49. * @param env
50. * @param info
51. * @return
52. */
53. static napi_value NAPI_Global_sub(napi_env env, napi_callback_info info) {
54.     double value0 = 0, value1 = 0;
55.     getTwoDoubleParams(env, info, &value0, &value1);
56.     napi_value sum;
57.     napi_create_double(env, sub(value0, value1), &sum);
58.     return sum;
59. }
60. /**
61. * 乘法运算翻译
62. *
63. * @param env
64. * @param info
65. * @return
66. */
67. static napi_value NAPI_Global_mul(napi_env env, napi_callback_info info) {
68.     double value0 = 0, value1 = 0;
69.     getTwoDoubleParams(env, info, &value0, &value1);
70.     napi_value sum;
71.     napi_create_double(env, mul(value0, value1), &sum);
72.     return sum;
73. }
74. /**
75. * 除法运算翻译
76. *
77. * @param env
78. * @param info
79. * @return
80. */
81. static napi_value NAPI_Global_div(napi_env env, napi_callback_info info) {
82.     double value0 = 0, value1 = 0;
83.     getTwoDoubleParams(env, info, &value0, &value1);
84.     napi_value sum;
85.     napi_create_double(env, div(value0, value1), &sum);
86.     return sum;
87. }
88. /**
89. * 取反运算翻译
90. *
91. * @param env
92. * @param info
93. * @return
94. */
95. static napi_value NAPI_Global_oppo(napi_env env, napi_callback_info info) {
97.     size_t argc = 1;
98.     napi_value args[1] = {nullptr};
100.     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
102.     napi_valuetype valuetype0;
103.     napi_typeof(env, args[0], &valuetype0);
105.     double value0;
106.     napi_get_value_double(env, args[0], &value0);
108.     napi_value sum;
109.     napi_create_double(env, oppo(value0), &sum);
111.     return sum;
112. }
114. /**
115. * 初始化函数，用于设置模块导出的内容
116. *
117. * @param env
118. * @param exports
119. * @return
120. */
121. EXTERN_C_START // 宏定义，用于在 C++ 代码中标记需要以 C 语言方式编译的代码块。比extern "C"更灵活
122. static napi_value Init(napi_env env, napi_value exports) {
123.     // 定义要导出的属性/方法
124.     napi_property_descriptor desc[] = {
125.         {"add", nullptr, Add, nullptr, nullptr, nullptr, napi_default, nullptr},
126.         {"sub", nullptr, NAPI_Global_sub, nullptr, nullptr, nullptr, napi_default, nullptr},
127.         {"mul", nullptr, NAPI_Global_mul, nullptr, nullptr, nullptr, napi_default, nullptr},
128.         {"div", nullptr, NAPI_Global_div, nullptr, nullptr, nullptr, napi_default, nullptr},
129.         {"oppo", nullptr, NAPI_Global_oppo, nullptr, nullptr, nullptr, napi_default, nullptr}};
130.     // 将属性添加到导出对象中
131.     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
132.     return exports;
133. }
134. EXTERN_C_END
136. /**
137. * 定义模块结构体
138. */
139. static napi_module demoModule = {
140.     .nm_version = 1,        // 模块版本号
141.     .nm_flags = 0,         // 模块标志，默认为0
142.     .nm_filename = nullptr, // 模块文件名，通常不需要
143.     .nm_register_func = Init, // 注册函数，指向上面的Init函数
144.     .nm_modname = "app",   // 模块名称，这将是JS中引入模块时使用的名称
145.     .nm_priv = ((void *)0), // 私有数据，这里未使用
146.     .reserved = { 0 }       // 保留字段，用于未来扩展
147. };
148. // 告诉编译器："这部分代码要用 C 的方式来处理，不要用 C++ 的方式"
149. extern "C" __attribute__((constructor)) void RegisterAppModule(void) { napi_module_register(&demoModule); }

复制代码

备注napi_property_descriptor结构体说明：

1. typedef struct napi_property_descriptor {
2.     const char* utf8name;         // 属性名称（UTF8字符串）
3.     napi_value name;             // 属性名称（napi_value类型）
4.     napi_callback method;        // 方法回调
5.     napi_callback getter;        // getter回调
6.     napi_callback setter;        // setter回调
7.     napi_value value;           // 静态属性值
8.     napi_property_attributes attributes; // 属性特性
9.     void* data;                 // 用户数据
10. } napi_property_descriptor;

复制代码

代码层面流程是这样的：

• 冷启动时系统首先会主动执行#RegisterModule函数
  
• #RegisterModule函数将结构体demoModule注册到 Node-API系统
  
• 结构体demoModule初始化时会调用 Init函数
  
• Init 函数设置模块的导出内容
  
• 这样以后ArtTS就可以调用Native方法了
  

8.4.暴露给ArtTS接口编写

1. export const add: (a: number, b: number) => number;
3. export const sub: (a: number, b: number) => number;
5. export const mul: (a: number, b: number) => number;
7. export const div: (a: number, b: number) => number;
9. export const oppo: (a: number) => number

复制代码

8.5.设置oh-package.json5

1. {
2.   // so包名称
3.   "name": "libapp.so",
4.   //Index.d.ts文件路径
5.   "types": "./Index.d.ts",
6.   "version": "1.0.0",
7.   "description": "Please describe the basic information."
8. }

复制代码

8.6.设置build-profile.json5

默认产出的so包仅为arm64-v8a架构，如果要支持其他架构必要设置build-profile.json5文件

1. {
2.   "apiType": "stageMode",
3.   "buildOption": {
4.     "externalNativeOptions": {
5.       "abiFilters": ["arm64-v8a", "x86_64"],
6.       ...

复制代码

8.7.导出so包

代码及设置文件编写完成，执行Build->Build Hap(s)/App(s)->Build Hap(s)
build完成后对应的so包会在此目录下：

1. |─CDemo                                        // 项目根目录
2. ├app/build/default/intermediates/libs/default  // 代码区                               // 本地三方库
3. │  └──arm64-v8a                                // arm64-v8a包
4. │  └──────libapp.so                            // arm64-v8a架构so能力包
5. │  └──x86_64                                   // x86_64包
6. │  └──────libapp.so                            // x86_64架构so能力包

复制代码

8.8.编写C/C++模块标准接口文档

此步是为了方便二次开发者开发。
9.宿主开发步调

相比于繁琐的so包开发，宿主即引用方开发起来较简单，它的工作主要在计算器界面搭建
9.1.引入so包

将libapp.so包导入到如下目录

1. |─Calculator                           // 项目根目录
2. ├app                                   // 代码区
3. ├──libs                                // 本地三方库
4. │  └──arm64-v8a                        // arm64-v8a包
5. │  └──────libapp.so                    // arm64-v8a架构so能力包
6. │  └──x86_64                           // x86_64包
7. │  └──────libapp.so                    // x86_64架构so能力包

复制代码

在对应的ets文件中直接导包并调用api即可

1. import napi from 'libapp.so';
2. napi.add(1,2);
3. ...

复制代码

值得注意的是：

• import napi from 'libapp.so';当前代码会飘红，编译器无法辨认so包，但是实际上不影响编译打包运行
  
• libapp.so包里的函数不会提示，如果让甲方调用发起输出标准接口文档
  

9.2.界面搭建及交互调用

基于ArtUI的声明式UI开发，这里只列举焦点代码：

1. import { hilog } from '@kit.PerformanceAnalysisKit';
2. import napi from 'libapp.so';
4. const INPUT_MAX: number = 10
5. const RESULT_MAX: number = 12
7. @Entry
8. @Component
9. struct Index {
10.   @State result: string = '0'
11.   array: string[] = []
13.   build() {
14.     Column() {
15.       Grid() {
16.         GridItem() {
17.           Text(this.result + '')
18.             .screenTextStyle()
19.         }.columnStart(0).columnEnd(3)
21.         GridItem() {
22.           Button('AC', {
23.             type: ButtonType.Normal
24.           })
25.             .buttonTextStyle()
26.             .onClick(() => {
27.               this.result = '0'
28.               this.array = []
29.             })
30.         }
32.         GridItem() {
33.           Button('+/-', {
34.             type: ButtonType.Normal
35.           })
36.             .buttonTextStyle()
37.             .onClick(() => {
38.               try {
39.                 if (this.array.length == 0) {
40.                   return
41.                 }
42.                 this.result = napi.oppo(this.getNumber(this.result)).toString()
43.                 console.info("message is" + this.getNumber(this.result))
44.                 if (this.array.length > 0 &&
45.                   (this.array[this.array.length-1].match(/^\d+$/) || this.array[this.array.length-1].match(/^-\d+$/))) {
46.                   this.array[this.array.length-1] = this.result
47.                 }
48.               } catch (e) {
49.                 console.error("类型转换错误！")
50.               }
52.             })
53.         }
55.         GridItem() {
56.           Button('%', {
57.             type: ButtonType.Normal
58.           })
59.             .buttonTextStyle()
60.             .onClick(() => {
61.               this.array.push(this.result.toString())
62.             })
63.         }
65.         GridItem() {
66.           Button('÷', {
67.             type: ButtonType.Normal
68.           })
69.             .buttonTextStyle('#ffff9f0a')
70.             .onClick(() => {
71.               if (this.array.length == 0) {
72.                 return
73.               }
74.               if (this.isSignal(this.array[this.array.length-1])) {
75.                 this.array.pop()
76.               }
77.               this.array.push('÷')
78.             })
79.         }
81.         GridItem() {
82.           Button('7', {
83.             type: ButtonType.Normal
84.           })
85.             .buttonTextStyle()
86.             .backgroundColor('#ff716768')
87.             .onClick(() => {
88.               this.processNumber(7)
89.             })
90.         }
92.         GridItem() {
93.           Button('8', {
94.             type: ButtonType.Normal
95.           })
96.             .buttonTextStyle()
97.             .onClick(() => {
98.               this.processNumber(8)
99.             })
100.         }
102.         GridItem() {
103.           Button('9', {
104.             type: ButtonType.Normal
105.           })
106.             .buttonTextStyle()
107.             .onClick(() => {
108.               this.processNumber(9)
109.             })
110.         }
112.         GridItem() {
113.           Button('×', {
114.             type: ButtonType.Normal
115.           })
116.             .buttonTextStyle('#ffff9f0a')
117.             .onClick(() => {
118.               if (this.array.length == 0) {
119.                 return
120.               }
121.               if (this.isSignal(this.array[this.array.length-1])) {
122.                 this.array.pop()
123.               }
124.               this.array.push('×')
125.             })
126.         }
128.         GridItem() {
129.           Button('4', {
130.             type: ButtonType.Normal
131.           })
132.             .buttonTextStyle()
133.             .onClick(() => {
134.               this.processNumber(4)
135.             })
136.         }
138.         GridItem() {
139.           Button('5', {
140.             type: ButtonType.Normal
141.           })
142.             .buttonTextStyle()
143.             .onClick(() => {
144.               this.processNumber(5)
145.             })
146.         }
148.         GridItem() {
149.           Button('6', {
150.             type: ButtonType.Normal
151.           })
152.             .buttonTextStyle()
153.             .onClick(() => {
154.               this.processNumber(6)
155.             })
156.         }
158.         GridItem() {
159.           Button('-', {
160.             type: ButtonType.Normal
161.           })
162.             .buttonTextStyle('#ffff9f0a')
163.             .onClick(() => {
164.               if (this.array.length == 0) {
165.                 return
166.               }
167.               if (this.isSignal(this.array[this.array.length-1])) {
168.                 this.array.pop()
169.               }
170.               this.array.push('-')
171.             })
172.         }
174.         GridItem() {
175.           Button('1', {
176.             type: ButtonType.Normal
177.           })
178.             .buttonTextStyle()
179.             .onClick(() => {
180.               this.processNumber(1)
181.             })
182.         }
184.         GridItem() {
185.           Button('2', {
186.             type: ButtonType.Normal
187.           })
188.             .buttonTextStyle()
189.             .onClick(() => {
190.               this.processNumber(2)
191.             })
192.         }
194.         GridItem() {
195.           Button('3', {
196.             type: ButtonType.Normal
197.           })
198.             .buttonTextStyle()
199.             .onClick(() => {
200.               this.processNumber(3)
201.             })
202.         }
204.         GridItem() {
205.           Button('+', {
206.             type: ButtonType.Normal
207.           }).buttonTextStyle('#ffff9f0a')
208.             .onClick(() => {
209.               if (this.array.length == 0) {
210.                 return
211.               }
212.               if (this.isSignal(this.array[this.array.length-1])) {
213.                 this.array.pop()
214.               }
215.               this.array.push('+')
216.             })
217.         }
219.         GridItem() {
220.           Button('0', {
221.             type: ButtonType.Normal
222.           }).buttonTextStyle()
223.             .onClick(() => {
224.               this.processNumber(0)
225.             })
226.         }.columnStart(0).columnEnd(1)
228.         GridItem() {
229.           Button('.', {
230.             type: ButtonType.Normal
231.           }).buttonTextStyle()
232.             .onClick(() => {
233.               if (!this.isSignal(this.array[this.array.length-1])) {
234.                 if (!this.array[this.array.length-1].endsWith('.')) {
235.                   this.result = this.result + '.'
236.                   this.array[this.array.length-1] = this.result
237.                 }
238.               }
239.             })
240.         }
242.         GridItem() {
243.           Button('=', {
244.             type: ButtonType.Normal
245.           }).buttonTextStyle('#ffff9f0a')
246.             .onClick(() => {
247.               this.processResult()
248.             })
249.         }
250.       }
251.       .gridStyle()
252.       .rowsTemplate('1fr 1fr 1fr 1fr 1fr 1fr')
253.       .columnsTemplate('1fr 1fr 1fr 1fr')
254.     }.width('100%')
255.     .height('100%')
256.     .backgroundColor('#ff988282')
257.     .justifyContent(FlexAlign.Center)
258.   }
260.   isSignal(str: string): boolean {
261.     return str == '+' || str == '-' || str == '×' || str == '÷'
262.   }
264.   processResult() {
265.     if (this.array.length != 3) {
266.       return
267.     }
268.     let value = this.array[1]
269.     if (value == '+') {
271.       this.result = napi.add(this.getNumber(this.array[0]), this.getNumber(this.array[2])).toString()
272.     }
273.     if (value == '-') {
274.       this.result = napi.sub(this.getNumber(this.array[0]), this.getNumber(this.array[2])).toString()
275.     }
276.     if (value == '×') {
277.       this.result = napi.mul(this.getNumber(this.array[0]), this.getNumber(this.array[2])).toString()
278.     }
279.     if (value == '÷') {
280.       this.result = napi.div(this.getNumber(this.array[0]), this.getNumber(this.array[2])).toString()
281.     }
282.     if (this.result.length > RESULT_MAX) {
283.       this.array = ['0']
284.       return
285.     }
286.     this.array = [this.result]
287.   }
289.   getNumber(str: string): number {
290.     if (str.endsWith('.')) {
291.       return Number(str.replace('.', ''))
292.     }
293.     return Number(str)
294.   }
296.   processNumber(n: number) {
297.     if (this.array.length > 0) {
298.       if (this.array[this.array.length-1].toString().length >= INPUT_MAX) {
299.         return
300.       }
301.       if (this.array[this.array.length-1].toString().includes('.')) {
302.         this.result = this.result + n
303.         this.array[this.array.length-1] = this.result
304.       } else if (!this.isSignal(this.array[this.array.length-1])) {
305.         this.result = (this.getNumber(this.result) * 10 + n).toString()
306.         this.array[this.array.length-1] = this.result
307.       } else {
308.         this.result = n.toString()
309.         this.array.push(this.result.toString())
310.       }
311.     } else {
312.       this.result = n.toString()
313.       this.array.push(this.result.toString())
314.     }
316.   }
317. }
320. @Extend(Text)
321. function screenTextStyle() {
322.   .backgroundColor('#ff51494a')
323.   .textAlign(TextAlign.End)
324.   .height('100%')
325.   .width('100%')
326.   .fontColor("#ffe6e6e5")
327.   .padding(10)
328.   .borderWidth(1)
329.   .fontSize(50)
330.   .fontWeight(FontWeight.Normal)
331. }
333. @Extend(Button)
334. function buttonTextStyle(color: string = '#ff6e6865') {
335.   .backgroundColor(color)
336.   .height('100%')
337.   .width('100%')
338.   .fontColor("#ffe6e6e5")
339.   .padding(10)
340.   .borderWidth(1)
341.   .fontSize(32)
342. }
344. @Extend(Grid)
345. function gridStyle() {
346.   .width('100%')
347.   .height(480)
348.   .borderWidth(1)
349.   .borderColor('#ff423e3d')
350.   .borderRadius(10)
351. }

复制代码

至此，ArtTS调用C/C++开发已完成。
10.应用架构

此图特意备注了文件路径，可联合章节7.1的目录结构看，方便明白，在架构层面梳理了C/C++模块、Napi、CMake工具链、ArtTs应用层之间的关系。

注意：

• 对C库的支持请参考《Native层支持说明》章节1
  
• 对C++库的支持请参考《Native层支持说明》章节2
  
• 对Napi标准库的支持请参考《Native层支持说明》章节3
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。