HarmonyOS 开启混淆后生成的sourceMaps.map文件在哪里可以找到呢 ?

Question

1，根据文档https://developer.huawei.com/consumer/cn/doc/harmonyos-guides...，开启编译混淆设置。
"buildOptionSet": [
{
"name": "release",
"arkOptions": {
"obfuscation": {

"ruleOptions": { 
  "enable": true, 
  "files": [ 
  "./obfuscation-rules.txt" 
  ] 
} 

}
}
},
],
2，执行：hvigor.js --mode project -p product=default -p buildMode=release assembleApp --analyze --parallel --incremental --daemon命令构建，生成加固后的hap包，在哪里可以找到混淆对应的sourceMaps.map文件呢？

Answer 1

可以借助三方库aki 实现class的导出；AKI 提供 JSBIND_CLASS 对 C++ 类/结构体进行绑定，根据aki使用修改下 CMakeLists.txt 和 napi_init.cpp 文件配置；在声明需要被绑定的类后就可以正常导出。参考下：
aki绑定 Native 对象/结构体用例：https://gitee.com/openharmony-sig/aki/tree/master/example/oho...
aki介绍：https://gitee.com/openharmony-sig/aki#3-%E4%BD%BF%E7%94%A8-aki
C++ 侧的class可以通过napi_define_class将构造函数与一个ArkTS的类绑定，这样在Arkts侧创建这个类的实例的时候就会调用c侧的构造函数在C侧也创建一个绑定的类，下面是一个示例demo，其中成员函数分为普通函数和静态成员函数，区别是普通成员函数需要创建一个JS实例与C++ 实例绑定，而静态函数不需要。在C++中定义一个类：

class AddClass { 
  public: 
    AddClass(std::string name) 
  { 
  this->instName = name; 
}; 
AddClass(){}; 
~AddClass(){}; 
std::string instName; 
double Add(double a, double b) 
{ 
  return a+b; 
}; 
static double StaticAdd(double a, double b) { return a + b; }; 
}; 
为这个类绑定构造函数： 
static napi_value JsConstructor(napi_env env, napi_callback_info info) { 
  // 创建napi对象 
  napi_value jDemo = nullptr; 
  size_t argc = 1; 
  napi_value args[1] = {0}; 
  // 获取构造函数入参 
  napi_get_cb_info(env, info, &argc, args, &jDemo, nullptr); 
  // args[0] js传入的参数 
  char name[50]; 
  size_t result = 0; 
  napi_get_value_string_utf8(env, args[0], name, sizeof(name) + 1, &result); 
  // 创建C++对象 
  AddClass *cDemo = new AddClass(name); 
  //OH_LOG_INFO(LOG_APP, "%{public}s", (cDemo->instName).c_str()); 
  // 设置js对象name属性 
  napi_set_named_property(env, jDemo, "name", args[0]); 
  // 绑定JS对象与C++对象 
  napi_wrap( 
    env, jDemo, cDemo, 
    // 定义js对象回收时回调函数，用来销毁C++对象，防止内存泄漏 
    [](napi_env env, void *finalize_data, void *finalize_hint) { 
    AddClass *cDemo = (AddClass *)finalize_data; 
    delete cDemo; 
    cDemo = nullptr; 
  }, 
  nullptr, nullptr); 
  return jDemo; 
}
这个C类将与JS侧的类绑定，在JS侧的类创建时，这个C的构建函数也将调用为类中普通函数Add（）提供js侧接口：
static napi_value JsAdd(napi_env env, napi_callback_info info) { 
  size_t argc = 2; 
  napi_value args[2] = {nullptr}; 
  napi_value jDemo = nullptr; 
  napi_get_cb_info(env, info, &argc, args, &jDemo, nullptr); 
  AddClass *cDemo = nullptr; 
  // 将js对象转为c对象 
  napi_unwrap(env, jDemo, (void **)&cDemo); 
  // 获取js传递的参数 
  int value0; 
  napi_get_value_int32(env, args[0], &value0); 
  int value1; 
  napi_get_value_int32(env, args[1], &value1); 
  int cResult = cDemo->Add(value0, value1); 
  napi_value jResult; 
  napi_create_int32(env, cResult, &jResult); 
  return jResult; 
} 
为类中静态函数StaticAdd（）提供js侧接口： 
static napi_value JsStaticAdd(napi_env env, napi_callback_info info) { 
  size_t argc = 2; 
  napi_value args[2] = {nullptr}; 
  napi_value jDemo = nullptr; 
  napi_get_cb_info(env, info, &argc, args, &jDemo, nullptr); 
  // 获取js传递的参数 
  int value0; 
  napi_get_value_int32(env, args[0], &value0); 
  int value1; 
  napi_get_value_int32(env, args[1], &value1); 
  int cResult = AddClass::StaticAdd(value0, value1); 
  napi_value jResult; 
  napi_create_int32(env, cResult, &jResult); 
  return jResult; 
}
在init函数中暴露C++ 的类，和类中的函数，并引入JS侧对应要绑定的类：
static napi_value Init(napi_env env, napi_value exports) { 
  // 定义模块需要对外暴露的方法 
  // 通过napi_define_class建立JS类与C++侧的映射关系，然后将对应的对象挂载到export上 
  napi_property_descriptor classProp[] = {{"Add", nullptr, JsAdd, nullptr, nullptr, nullptr, napi_default, nullptr}, 
  {"StaticAdd", nullptr, JsStaticAdd, nullptr, nullptr, nullptr, napi_static, nullptr}}; 
 
napi_value jDemo = nullptr; 
const char *jDemoName = "AddClass"; 
// 建立JS构造函数与C++方法的关联,指定2个prop 
napi_define_class(env, jDemoName, sizeof(jDemoName), JsConstructor, nullptr, 
  sizeof(classProp) / sizeof(classProp[0]), classProp, &jDemo); 
napi_set_named_property(env, exports, jDemoName, jDemo); 
return exports; 
}
在index.d.ts中导出AddClass：
export const add: (a: number, b: number) => number; 
declare namespace testNapi { 
  class AddClass { 
    constructor(name:string) 
    name: string 
    Add(a: number, b: number): number 
    static StaticAdd(a: number, b: number): number 
  } 
} 
export default testNapi;
在ArkTS侧调用native侧类函数：
Button('add') 
  .onClick(() => { 
    //调用构造函数，获取对象 
    let AddClass = new testNapi.AddClass("class name"); 
    hilog.info(0x0000, 'ckTest', 'Test NAPI 3 + 7 = %{public}d', AddClass.Add(3, 7)); 
  }) 
Button('static add') 
  .onClick(() => { 
    hilog.info(0x0000, 'ckTest', 'Test NAPI static 8 + 5 = %{public}d', testNapi.AddClass.StaticAdd(5,8)); 
  }) 
}