add harmony support

Author: Louis-C7

packages/default-storage/harmony/async_storage.har

@@ -0,0 +1,6 @@
+/node_modules
+/oh_modules
+/.preview
+/build
+/.cxx
+/.test

packages/default-storage/harmony/async_storage/.gitignore

@@ -0,0 +1,8 @@
+{
+  "apiType": "stageMode",
+  "targets": [
+    {
+      "name": "default"
+    }
+  ]
+}

packages/default-storage/harmony/async_storage/build-profile.json5

@@ -0,0 +1,2 @@
+// Script for compiling build behavior. It is built in the build plug-in and cannot be modified currently.
+export { harTasks } from '@ohos/hvigor-ohos-plugin';

packages/default-storage/harmony/async_storage/hvigorfile.ts

@@ -0,0 +1 @@
+export * from "./ts"

packages/default-storage/harmony/async_storage/index.ets

@@ -0,0 +1,18 @@
+# Define project specific obfuscation rules here.
+# You can include the obfuscation configuration files in the current module's build-profile.json5.
+#
+# For more details, see
+#   https://gitee.com/openharmony/arkcompiler_ets_frontend/blob/master/arkguard/README.md
+
+# Obfuscation options:
+# -disable-obfuscation: disable all obfuscations
+# -enable-property-obfuscation: obfuscate the property names
+# -enable-toplevel-obfuscation: obfuscate the names in the global scope
+# -compact: remove unnecessary blank spaces and all line feeds
+# -remove-log: remove all console.* statements
+# -print-namecache: print the name cache that contains the mapping from the old names to new names
+# -apply-namecache: reuse the given cache file
+
+# Keep options:
+# -keep-property-name: specifies property names that you want to keep
+# -keep-global-name: specifies names that you want to keep in the global scope

packages/default-storage/harmony/async_storage/obfuscation-rules.txt

@@ -0,0 +1,12 @@
+{
+  "license": "",
+  "devDependencies": {
+    "rnoh": "file:../rnoh"
+  },
+  "author": "",
+  "name": "rnoh-async-storage",
+  "description": "",
+  "main": "",
+  "version": "2.5.1",
+  "dependencies": {}
+}

packages/default-storage/harmony/async_storage/oh-package.json5

@@ -0,0 +1,48 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "RNOH/Package.h"
+#include "RNAsyncStorageTurboModule.h"
+
+using namespace rnoh;
+using namespace facebook;
+class NativeRNAsyncStorageFactoryDelegate : public TurboModuleFactoryDelegate {
+  public:
+    SharedTurboModule createTurboModule(Context ctx,const std::string &name) const override {
+      if (name == "RNCAsyncStorage") {
+          return std::make_shared<RNAsyncStorageTurboModule>(ctx, name);
+      }
+      return nullptr;
+    };
+};
+
+namespace rnoh {
+class AsyncStoragePackage : public Package {
+  public:
+    AsyncStoragePackage(Package::Context ctx) : Package(ctx) {}
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
+        return std::make_unique<NativeRNAsyncStorageFactoryDelegate>();
+    }
+};
+} // namespace rnoh

packages/default-storage/harmony/async_storage/src/main/cpp/AsyncStoragePackage.h

@@ -0,0 +1,8 @@
+# the minimum version of CMake.
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB rnoh_async_storage_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(rnoh_async_storage SHARED ${rnoh_async_storage_SRC})
+target_include_directories(rnoh_async_storage PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(rnoh_async_storage PUBLIC rnoh)

packages/default-storage/harmony/async_storage/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,63 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "RNAsyncStorageTurboModule.h"
+#include "RNOH/ArkTSTurboModule.h"
+
+using namespace rnoh;
+using namespace facebook;
+
+static jsi::Value __hostFunction_RNAsyncStorageTurboModule_multiGet(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+    return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "multiGet", args, count);
+}
+
+static jsi::Value __hostFunction_RNAsyncStorageTurboModule_multiSet(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+    return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "multiSet", args, count);
+}
+
+static jsi::Value __hostFunction_RNAsyncStorageTurboModule_multiRemove(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+    return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "multiRemove", args, count);
+}
+
+static jsi::Value __hostFunction_RNAsyncStorageTurboModule_multiMerge(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+    return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "multiMerge", args, count);
+}
+
+static jsi::Value __hostFunction_RNAsyncStorageTurboModule_getAllKeys(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+    return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "getAllKeys", args, count);
+}
+
+static jsi::Value __hostFunction_RNAsyncStorageTurboModule_clear(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+    return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "clear", args, count);
+}
+
+RNAsyncStorageTurboModule::RNAsyncStorageTurboModule(const ArkTSTurboModule::Context ctx, const std::string name)
+    : ArkTSTurboModule(ctx, name) {
+    methodMap_["multiGet"] = MethodMetadata{2, __hostFunction_RNAsyncStorageTurboModule_multiGet};
+    methodMap_["multiSet"] = MethodMetadata{2, __hostFunction_RNAsyncStorageTurboModule_multiSet};
+    methodMap_["multiRemove"] = MethodMetadata{2, __hostFunction_RNAsyncStorageTurboModule_multiRemove};
+    methodMap_["multiMerge"] = MethodMetadata{2, __hostFunction_RNAsyncStorageTurboModule_multiMerge};
+    methodMap_["getAllKeys"] = MethodMetadata{2, __hostFunction_RNAsyncStorageTurboModule_getAllKeys};
+    methodMap_["clear"] = MethodMetadata{1, __hostFunction_RNAsyncStorageTurboModule_clear};
+}

packages/default-storage/harmony/async_storage/src/main/cpp/RNAsyncStorageTurboModule.cpp

@@ -0,0 +1,36 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+
+class JSI_EXPORT RNAsyncStorageTurboModule : public ArkTSTurboModule {
+  public:
+    RNAsyncStorageTurboModule(const ArkTSTurboModule::Context ctx, const std::string name);
+};
+
+} // namespace rnoh

packages/default-storage/harmony/async_storage/src/main/cpp/RNAsyncStorageTurboModule.h

@@ -0,0 +1,144 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import relationalStore from '@ohos.data.relationalStore';
+
+import CommonConstants from './CommonConstants';
+import Logger from './Logger';
+import ReactDatabaseSupplier from './ReactDatabaseSupplier'
+
+export default class AsyncLocalStorageUtil {
+
+  static buildKeySelection(keys: string[], keyStart: number, keyCount: number) {
+    let selectedKeys: string[] = [];
+    for (let keyIndex = 0; keyIndex < keyCount; keyIndex++) {
+      Logger.debug(CommonConstants.TAG, `buildKeySelection(), selectedKey: ${keys[keyStart + keyIndex]}`)
+      selectedKeys.push(keys[keyStart + keyIndex]);
+    }
+    return selectedKeys;
+  }
+
+  static async getItemImpl(db: relationalStore.RdbStore, key: string): Promise<string | null> {
+    let columns: string[] = new Array(ReactDatabaseSupplier.VALUE_COLUMN);
+    let predicates = new relationalStore.RdbPredicates(ReactDatabaseSupplier.TABLE_CATALYST);
+    predicates.equalTo(ReactDatabaseSupplier.KEY_COLUMN, key);
+    let cursor = await db.query(predicates, columns);
+    Logger.debug(CommonConstants.TAG, `getItemImpl(), ResultSet isAtFirstRow: ${cursor.isAtFirstRow}, row count: ${cursor.rowCount}`);
+    try {
+      if(!cursor.goToFirstRow()){
+        return null;
+      } else{
+        return cursor.getString(cursor.getColumnIndex('VALUE'));
+      }
+    } catch (e) {
+      Logger.error(CommonConstants.TAG, `getItemImpl() error: ${e.message}`)
+      return null;
+    } finally {
+      cursor.close();
+    }
+  }
+
+  /**  
+   * Sets the value for the key given, returns true if successful, false otherwise.
+   */
+  static async setItemImpl(db: relationalStore.RdbStore, key: string, value:string): Promise<boolean> {
+    Logger.debug(CommonConstants.TAG, `setItemImpl(), key: ${key}, newValue: ${value}`)
+    let obj: relationalStore.ValuesBucket = {};
+    obj.key = key;
+    obj.value = value;
+    try {
+      db.beginTransaction();
+      let inserted = await db.insert(ReactDatabaseSupplier.TABLE_CATALYST, obj, relationalStore.ConflictResolution.ON_CONFLICT_REPLACE);
+      db.commit();
+      return (-1 !== inserted);
+    } catch (e) {
+      Logger.error(CommonConstants.TAG, `setItemImpl() error: ${e.message}`)
+    }
+    return false;
+  }
+
+  /**
+   *  Does the actual merge of the (key, value) pair with the value stored in the database.
+   *  NB: This assumes that a database lock is already in effect!
+   *  @return the errorCode of the operation
+   */
+  static async mergeImpl(db: relationalStore.RdbStore, key: string, value:string): Promise<boolean> {
+    let oldValue = await AsyncLocalStorageUtil.getItemImpl(db, key);
+    let newValue: string;
+
+    try {
+      if (oldValue == null) {
+        newValue = value;
+      } else {
+        let oldJSON: Record<string, string | Object> = JSON.parse(oldValue);
+        let newJSON: Record<string, string | Object> = JSON.parse(value);
+
+        await AsyncLocalStorageUtil.deepMergeInto(oldJSON, newJSON);
+        newValue = JSON.stringify(oldJSON);
+      }
+      let isSuccess = await AsyncLocalStorageUtil.setItemImpl(db, key, newValue);
+      return isSuccess;
+    } catch (e) {
+      Logger.error(CommonConstants.TAG, `mergeImpl() error: ${e.message}`)
+    }
+    return false;
+  }
+
+  /**
+   * Merges two {@link JSONObject}s. The newJSON object will be merged with the oldJSON object by
+   * either overriding its values, or merging them (if the values of the same key in both objects
+   * are of type {@link JSONObject}). oldJSON will contain the result of this merge.
+   */
+  private static async deepMergeInto(oldJSON: Record<string, string | Object>, newJSON: Record<string, string | Object>) {
+    let keys: string[] = Object.keys(newJSON);
+    for(let idx = 0; idx < keys.length; idx++) {
+      let key = keys[idx];
+      let newValue = JSON.stringify(newJSON[key]);
+      let oldValue = JSON.stringify(oldJSON[key]);
+
+      let newJSONObject = AsyncLocalStorageUtil.optJSONObject(newValue);
+      let oldJSONObject = AsyncLocalStorageUtil.optJSONObject(oldValue);
+      Logger.debug(CommonConstants.TAG, `deepMergeInto(), newJSONObject: ${JSON.stringify(newJSONObject)}, oldJSONObject: ${JSON.stringify(oldJSONObject)}`)
+
+      if (newJSONObject !== null && oldJSONObject !== null) {
+        await AsyncLocalStorageUtil.deepMergeInto(oldJSONObject, newJSONObject);
+        oldJSON[key] = oldJSONObject;
+      } else {
+        oldJSON[key] = newJSON[key];
+      }
+    }
+  }
+
+  private static optJSONObject(value: string) {
+    try {
+      let JSONObject: Record<string, string | Object> = JSON.parse(value);
+      if (typeof JSONObject == "object" && JSONObject && !Array.isArray(JSONObject)) {
+        return JSONObject;
+      }
+    } catch (e) {
+      Logger.error(CommonConstants.TAG, `optJSONObject() error: ${e.message}`)
+    }
+    return null;
+  }
+}