北向应用集成三方库——NAPI 导出类对象

class NapiTest {
public:
  NapiTest() : mEnv(nullptr), mRef(nullptr) {
  }
  ~NapiTest();
  
  static napi_value Create(napi_env env, napi_callback_info info);  // 创建NapiTest类的实体，并将实体返回到应用端，该方法为js创建一个类实体，因此需要将该接口对外导出
  static napi_value Init(napi_env env, napi_value exports);         // 初始化js类并设置对应属性并将其导出。

private:
	static napi_value SetMsg(napi_env env, napi_callback_info info);            // 设置数据，此方法给到js直接调用，因此需要将该接口对外导出
    static napi_value GetMsg(napi_env env, napi_callback_info info);          // 获取数据，此方法给到js直接调用，因此需要将该接口对外导出
    static napi_value Constructor(napi_env env, napi_callback_info info);     // 定义js结构体时实际的构建函数
    static void Destructor(napi_env env, void *nativeObject, void *finalize); // 释放资源的函数(类似类的析构函数)
    
    static napi_ref sConstructor_;  // 生命周期变量
    static std::string _msg;        // 设置和获取数据的变量
    napi_env mEnv = nullptr;        // 记录环境变量
    napi_ref mRef = nullptr;        // 记录生命周期变量
};

  napi_property_descriptor desc[] = {
      { "getMsg", nullptr, NapiTest::GetMsg, nullptr, nullptr, nullptr,
          napi_default, nullptr },
      { "setMsg", nullptr, NapiTest::SetMsg, nullptr, nullptr, nullptr, 
        napi_default, nullptr },
  }

  napi_value mConstructor = nullptr;
  if (napi_define_class(env, NAPI_CLASS_NAME, NAPI_AUTO_LENGTH, Constructor, nullptr,
      sizeof(desc) / sizeof(desc[0]), desc, &mConstructor) != napi_ok) {
      return nullptr;
  }

  napi_status napi_define_class(napi_env env,
                            const char* utf8name,
                            size_t length,
                            napi_callback constructor,
                            void* data,
                            size_t property_count,
                            const napi_property_descriptor* properties,
                            napi_value* resu

  napi_value NapiTest::Constructor(napi_env env, napi_callback_info info)
  {
    napi_value undefineVar = nullptr, thisVar = nullptr;
      napi_get_undefined(env, &undefineVar);
      
      if (napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr) ==
          napi_ok && thisVar != nullptr) {
          // 创建NapiTest 实例
          NapiTest *reference = new NapiTest(env);
          // 绑定实例类创建NapiTest到导出的对象result
          if (napi_wrap(env, thisVar, reinterpret_cast<void *>(reference),
              NapiTest::Destructor, nullptr, &(reference->mRef)) == napi_ok) {
              return thisVar;
          }
  
          return thisVar;
      }
      
      return undefineVar;
  }

  void NapiTest::Destructor(napi_env env, void *nativeObject, void *finalize)
  {
      NapiTest *test = reinterpret_cast<NapiTest*>(nativeObject);
      test->~NapiTest();
  }

  napi_status napi_wrap(napi_env env,
                    napi_value js_object,
                    void* native_object,
                    napi_finalize finalize_cb,
                    void* finalize_hint,
                    napi_ref* result);

  if (napi_create_reference(env, mConstructor , 1, &sConstructor_) != napi_ok) {
      return nullptr;
  }

  if (napi_set_named_property(env, exports, NAPI_CLASS_NAME, constructor) !=  napi_ok) {
      return nullptr;
  }

napi_value NapiTest::Create(napi_env env, napi_callback_info info) {
    napi_status status;
    napi_value constructor = nullptr, result = nullptr;
    // 获取生命周期变量
    status = napi_get_reference_value(env, sConstructor_, &constructor);

    // 创建生命周期内的实例对象并将其返回
    status = napi_new_instance(env, constructor, 0, nullptr, &result);
    auto napiTest = new NapiTest();
    // 绑定实例类创建NapiTest到导出的对象result
    if (napi_wrap(env, result, reinterpret_cast<void *>(napiTest), Destructor,
    	nullptr, &(napiTest->mRef)) == napi_ok) {
        return result;
    }
    
    return nullptr;
}

  static napi_module demoModule = {
      .nm_version =1,
      .nm_flags = 0,
      .nm_filename = nullptr,
      .nm_register_func = Init,
      .nm_modname = "hello",
      .nm_priv = ((void*)0),
      .reserved = { 0 },
  };

  EXTERN_C_START
  static napi_value Init(napi_env env, napi_value exports)
  {
    napi_property_descriptor desc[] = {
        { "create", nullptr, NapiTest::Create, nullptr, nullptr, nullptr, napi_default, nullptr }   // 单独导出 create 方法，js应用可以直接调用Create方法获取类实例
    };
    
    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);

    return NapiTest::Init(env, exports);    // 导出类以及类的方法
  }
  EXTERN_C_END

  // 注册 hello模块
  extern "C" __attribute__((constructor)) void RegisterHelloModule(void)
  {
      napi_module_register(&demoModule);
  }

export const create : () => NapiTest;
export class  NapiTest {
    setMsg(msg: string): void;
    getMsg(): string;
}

  import testNapi from "libentry.so";

  struct Index {
    @State message: string = 'Hello World'
    @State flag:number = 0
    tt = testNapi.create();
  
    build() {
      Row() {
        Column() {
          Text(this.message)
            .fontSize(50)
            .fontWeight(FontWeight.Bold)
            .onClick(() => {
            })
        }
        .width('100%')
      }
      .height('100%')
    }

  if (this.falg == 0) {
      this.flag = 2
      this.tt.setMsg("1+1")
  } else {
      this.flag = 0
      this.tt.setMsg("1-1")
  }
  console.info("[NapiTest]:" + this.tt.getMsg() + " = " + this.flag);

  02200/JsApp: [NapiTest]： 1+1 = 2
  02200/JsApp: [NapiTest]： 1-1 = 0