diff --git a/bundle.json b/bundle.json
index c1f5f6dc2427cb86660433bf7aa28c4bd3b29a7f..7b55a97a5e97bb3dcb58acb73619f816c17fd8eb 100644
--- a/bundle.json
+++ b/bundle.json
@@ -24,7 +24,8 @@
     "build": {
       "sub_component": [
           "//commonlibrary/memory_utils/libdmabufheap:libdmabufheap",
-          "//commonlibrary/memory_utils/libpurgeablemem:libpurgeablemem"
+          "//commonlibrary/memory_utils/libpurgeablemem:libpurgeablemem",
+          "//commonlibrary/memory_utils/libpurgeablemem/js:memory"
       ],
       "inner_kits": [],
       "test": [
diff --git a/libpurgeablemem/README.md b/libpurgeablemem/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..95f9fdb7f5ed96acc6b53e64eea63b886c6f812c
--- /dev/null
+++ b/libpurgeablemem/README.md
@@ -0,0 +1,325 @@
+
+
+# Purgeable
+
+- [Introduction](#)
+
+- [Directory](#)
+
+- [c++  Instructions](#)
+
+  - [Create PurgeableMem]()
+
+  - [Read PuegeableMem]()
+
+  - [Write PuegeableMem](#)
+
+  - [Get PuegeableMem buffer size](#)
+
+- [js Instructions](#usage-guidelines)
+
+  - [Create PurgeableMem]()
+
+  - [Read PuegeableMem]()
+
+  - [Write PuegeableMem](#)
+
+  - [Get PuegeableMem buffer size](#)
+
+    
+
+## Introduction
+
+Purgeable is the memory that can be recycled when not in use. When we use it, if this memory is recycled, we can restore the data through reconstruction. It can ensure that this memory will not be recycled during use.
+
+
+
+## Catalogue
+
+The warehouse directory structure is as follows:
+
+/commonlibrary/memory_utils/libpurgeablemem/
+```
+libpurgeable            	 # Discardable type memory management library
+   ├── c                   	 # C interface directory for memory allocation of purgeable type
+   ├── cpp             	     # The directory of the cpp interface for memory allocation of purgeable type
+   ├── common                # Public interface directory for memory allocation of purgeable type
+   ├── js                    # Napi directory for memory allocation of purgeable type
+   └── test                  # Purgeable type memory allocation link library self-test case directory
+```
+
+## c++ Instructions
+
+### 1.Create PurgeableMem
+
+Purgeable provides a method of c++calling. It can rebuild memory by inheriting the PurgeableMemBuilder class and overloading the Build function. The following code shows how to inherit the PurgeableMemBuilder class and create a PurgeableMem object.
+
+```
+class TestDataBuilder : public PurgeableMemBuilder {
+public:
+    TestDataBuilder(char start, char end)
+    {
+        this->start = start;
+        this->end = end;
+    }
+
+    bool Build(void *data, size_t size)
+    {
+        if (size <= 0) {
+            return true;
+        }
+        char *str = static_cast<char *>(data);
+        size_t len = 0;
+        for (char ch = start; ch <= end && len < size; ch++) {
+            str[len++] = ch;
+        }
+        str[size - 1] = 0;
+        std::cout << "rebuild addr("<< (unsigned long long)str <<") " <<
+            start << "~" << end << ", data=[" << str << "]" << std::endl;
+        return true;
+    }
+
+    ~TestDataBuilder()
+    {
+    }
+
+private:
+    char start, end;
+};
+
+```
+
+```
+std::unique_ptr<PurgeableMemBuilder> builder1 = std::make_unique<TestDataBuilder>('A', 'Z');   //Create builder object
+PurgeableMem pobj(27, std::move(builder1));	//Create PurgeableMem object
+```
+
+### 2.Read PuegeableMem
+
+Use BeginRead() before reading the contents of PurgeableMem, EndRead() after reading, and GetContent() to get the contents. Based on the creation of PuegeableMem, it shows how to read the data of PuegeableMem:
+
+```
+const char alphabetFinal[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\0";
+int ret1 = 1;
+if (pobj.BeginRead()) {
+    ret1 = strncmp(alphabetFinal, static_cast<char *>(pobj.GetContent()), 26);
+    pobj.EndRead();
+} 
+```
+
+### 3.Write PuegeableMem
+
+Call BeginWrite() before writing, and use EndWrite() after writing. When writing, you also need to define a class to inherit PurgeableMemBuilder, and overload the Build function to write data, as follows:
+
+```
+
+class TestDataModifier : public PurgeableMemBuilder {
+public:
+    TestDataModifier(char from, char to)
+    {
+        this->from = from;
+        this->to = to;
+    }
+
+    bool Build(void *data, size_t size)
+    {
+        char *str = static_cast<char *>(data);
+        for (size_t i = 0; i < size && str[i]; i++) {
+            if (str[i] == from) {
+                str[i] = to;
+            }
+        }
+        return true;
+    }
+
+    ~TestDataModifier()
+    {
+        std::cout << "~TestDataModifier" << std::endl;
+    }
+
+private:
+    char from, to;
+};
+```
+
+```
+std::unique_ptr<PurgeableMemBuilder> mod = std::make_unique<TestDataModifier>('A', 'B');
+if (!pobj->BeginWrite()) {
+    std::cout << __func__ << ": ERROR! BeginWrite failed." << std::endl;
+    return;
+}
+pobj->ModifyContentByBuilder(std::move(mod));
+pobj->EndWrite();
+```
+
+### 4.Get PuegeableMem buffer size
+
+Use GetContentSize() of PuegeableMem object to get the buffer byte size.
+
+
+
+## js instructions
+
+### 1.Create PurgeableMem
+
+Purgeable provides interfaces to operate PurgeableMem, such as create, read and write. The following shows how to create a PurgeableMem.
+
+Call the createPurgeableMem() function to create a PurgeableMem. The parameters are: number is the byte size of the requested memory, the callback function used by callback to rebuild memory, and the parameters required by the argv callback function, which can be of any data type.
+
+Note: The number of bytes of the DataView object used in the reconstruction memory should match the corresponding data type, otherwise an exception will be caused.
+
+```
+function createPurgeableMemory(size: number, callback :(dv: DataView, size: number, argv: {}) => boolean, argv: {}) :PurgeableMemory;
+```
+
+Example：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = memory.createPurgeableMemory(1024, function(dv, size, argv) {//1024 and size here are byte sizes, so when traversing and writing, it is necessary to note that the subscript is out of bounds.
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);//Select the appropriate data type here（Int8/Int16/Int32）
+	}
+	return true;
+}, argv);
+```
+
+### 2.Read PuegeableMem
+
+Purgeable provides an interface to operate PuegeableMem, such as create, read and write. The following shows how to read.
+
+Read by calling beginRead() and endRead(). GetContent() can be called only when beginRead returns true, and an ArrayBuffer is returned. Note: The ArrayBuffer is only readable. If you need to get the value in ArrayBuffer, you need to convert it to the corresponding data type of TypeBuffer (Int8Array, Int16Array, Int32Array, etc.). The corresponding data type should match the number of bytes of the memory requested, otherwise it will cause an exception.
+
+```
+beginRead(): boolean;
+endRead(): void;
+getContent(): Readonly<ArrayBuffer>;
+```
+
+Example：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = purgeable.createPurgeableMemory(1024, function(dv, size, argv) {
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+if(pobj.beginRead()) {
+    var bf = pobj.getContent();
+    var int8Arr = new Int8Array(bf);
+    for (var index = 0; index < int8Arr.length; index++) {
+        const val = int8Arr[index];
+        console.log(val);
+    }
+	pobj.endRead();
+}
+
+```
+
+### 3.Write PuegeableMem
+
+Purgeable provides an interface to operate PuegeableMem, such as create, read and write. The following shows how to write.
+
+Write by calling beginWrite() and endWrite(). ModifyContentByBuilder can be called to write data to it only when beginWrite returns true.
+
+```
+beginWrite(): bool;
+endWrite(): void;
+modifyContentByBuilder(callback: (dv: DataView, size : number, argv: {}) => boolean, argv: {}): boolean;
+```
+
+Example：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = purgeable.createPurgeableMemry(1024, function(dv, size, argv) {
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+var argv2 = {};
+argv2.num1 = 10;
+argv2.num2 = 20;
+argv2.num3 = 30;
+if(purgeableMem.beginWrite()) {
+	purgeableMem.ModifyContentByBuilder(function(dv, size, argv2) {
+		for(var i = 0; i < size; i++) {
+			dv.setInt8(i, argv2.num1 + argv2.num2 + argv2.num3);
+		}
+		return true;
+	}, argv2);
+	purgeableMem.endWrite();
+}
+
+```
+
+### 4.Get PuegeableMem buffer size
+
+Purgeable provides an interface to operate the PuegeableMem, such as create, read and write. The following shows how to obtain the buffer size.
+
+Get the buffer size by calling getContentSize(). Note: The returned size is bytes, not array length.
+
+```
+getContentSize(): number;
+```
+
+Example：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = purgeable.createPurgeableMemory(1024, function(dv, size, argv) {
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+var size = purgeableMem.getContentSize();
+console.log(size);
+```
+
+### 5.Destroy PuegeableMem
+
+Purgeable provides an interface to operate PuegeableMem, such as creating, reading, and writing. The following shows how to destroy PuegeableMem.
+
+Destroy by calling destroy ().
+
+```
+destroy(): void;
+```
+
+Example：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = purgeable.createPurgeableMemory(1024, function(dv, size, argv) {
+	for(var i = 0; i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+purgeableMem.destroy();
+```
+
diff --git a/libpurgeablemem/README_zh.md b/libpurgeablemem/README_zh.md
new file mode 100644
index 0000000000000000000000000000000000000000..610783c4c5293100a236abde71bfddaccbf4056a
--- /dev/null
+++ b/libpurgeablemem/README_zh.md
@@ -0,0 +1,325 @@
+
+
+# Purgeable
+
+- [简介](#index)
+
+- [目录](#index)
+
+- [c++  使用说明](#usage-guidelines)
+
+  - [创建PurgeableMem]()
+
+  - [对PuegeableMem读]()
+
+  - [对PuegeableMem写](#)
+
+  - [获取PuegeableMem缓冲区大小](#)
+
+- [js 使用说明](#usage-guidelines)
+
+  - [创建PurgeableMem]()
+
+  - [对PuegeableMem读]()
+
+  - [对PuegeableMem写](#)
+
+  - [获取PuegeableMem缓冲区大小](#)
+
+    
+
+## 简介
+
+Purgeable是在不使用时可以被回收的内存，当我们去使用的时候，如果这块内存被回收了可以通过重建的方式把数据还原出来。能够保证在使用期间这块内存不被回收。
+
+
+
+## 目录
+
+仓目录结构如下：
+
+/commonlibrary/memory_utils/libpurgeablemem/
+```
+libpurgeable            	 # 可丢弃类型内存管理库
+   ├── c                   	 # purgeable类型内存分配的c接口目录
+   ├── cpp             	     # purgeable类型内存分配的cpp接口目录
+   ├── common                # purgeable类型内存分配的公共接口目录
+   ├── js                    # purgeable类型内存分配的napi目录
+   └── test                  # purgeable类型内存分配链接库自测用例目录
+```
+
+## c++ 使用说明
+
+### 1.创建PurgeableMem
+
+Purgeable提供了c++调用的方式，通过继承PurgeableMemBuilder类，重载Build函数的方式去重建内存，如下代码展示了如何去继承PurgeableMemBuilder类以及创建一个PurgeableMem对象。
+
+```
+class TestDataBuilder : public PurgeableMemBuilder {
+public:
+    TestDataBuilder(char start, char end)
+    {
+        this->start = start;
+        this->end = end;
+    }
+
+    bool Build(void *data, size_t size)
+    {
+        if (size <= 0) {
+            return true;
+        }
+        char *str = static_cast<char *>(data);
+        size_t len = 0;
+        for (char ch = start; ch <= end && len < size; ch++) {
+            str[len++] = ch;
+        }
+        str[size - 1] = 0;
+        std::cout << "rebuild addr("<< (unsigned long long)str <<") " <<
+            start << "~" << end << ", data=[" << str << "]" << std::endl;
+        return true;
+    }
+
+    ~TestDataBuilder()
+    {
+    }
+
+private:
+    char start, end;
+};
+
+```
+
+```
+std::unique_ptr<PurgeableMemBuilder> builder1 = std::make_unique<TestDataBuilder>('A', 'Z');   //创建builder对象
+PurgeableMem pobj(27, std::move(builder1));	//创建PurgeableMem对象
+```
+
+### 2.对PuegeableMem读
+
+读取PurgeableMem的内容前使用BeginRead()，读取结束使用EndRead()，使用GetContent()获取到内容。在创建PuegeableMem的基础上展示了如何读取PuegeableMem的数据：
+
+```
+const char alphabetFinal[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\0";
+int ret1 = 1;
+if (pobj.BeginRead()) {
+    ret1 = strncmp(alphabetFinal, static_cast<char *>(pobj.GetContent()), 26);
+    pobj.EndRead();
+} 
+```
+
+### 3.对PuegeableMem写
+
+在写入前调用BeginWrite() ,写入结束使用EndWrite()，写入时同样需要定义一个类继承PurgeableMemBuilder，重载Build函数去写入数据，如下：
+
+```
+
+class TestDataModifier : public PurgeableMemBuilder {
+public:
+    TestDataModifier(char from, char to)
+    {
+        this->from = from;
+        this->to = to;
+    }
+
+    bool Build(void *data, size_t size)
+    {
+        char *str = static_cast<char *>(data);
+        for (size_t i = 0; i < size && str[i]; i++) {
+            if (str[i] == from) {
+                str[i] = to;
+            }
+        }
+        return true;
+    }
+
+    ~TestDataModifier()
+    {
+        std::cout << "~TestDataModifier" << std::endl;
+    }
+
+private:
+    char from, to;
+};
+```
+
+```
+std::unique_ptr<PurgeableMemBuilder> mod = std::make_unique<TestDataModifier>('A', 'B');
+if (!pobj->BeginWrite()) {
+    std::cout << __func__ << ": ERROR! BeginWrite failed." << std::endl;
+    return;
+}
+pobj->ModifyContentByBuilder(std::move(mod));
+pobj->EndWrite();
+```
+
+### 4.获取PuegeableMem缓冲区大小
+
+使用PuegeableMem对象的GetContentSize()即可获取到缓冲区字节大小。
+
+
+
+## js 使用说明
+
+### 1.创建PurgeableMem
+
+Purgeable提供了操作PurgeableMem的接口，如创建、读取和写入，以下展示了如何创建PurgeableMem。
+
+调用createPurgeableMem()函数去创建PurgeableMem，参数分别是：number是申请内存的字节大小、callback用来重建内存的回调函数、argv回调函数需要的参数，可以任何数据类型。
+
+注意：在重建内存使用DataView对象字节数与对应的数据类型要匹配，否则会引起异常。
+
+```
+function createPurgeableMemory(size: number, callback :(dv: DataView, size: number, argv: {}) => boolean, argv: {}) :PurgeableMemory;
+```
+
+示例：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = memory.createPurgeableMemory(1024, function(dv, size, argv) {//此处的1024与size是字节大小,故在遍历以及给写入时，需注意下标越界。
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);//此处需要选择合适的数据类型（Int8/Int16/Int32）
+	}
+	return true;
+}, argv);
+```
+
+### 2.对PuegeableMem读
+
+Purgeable提供了操作PuegeableMem的接口，如创建、读取和写入，以下展示了如何读取。
+
+通过调用beginRead()和endRead()读取。beginRead返回true时才能调用getContent()，返回一个ArrayBuffer。注意：该ArrayBuffer仅仅是可读的。如果需要获取ArrayBuffer里面的值需要转化成对应数据类型的TypeBuffer（Int8Array，Int16Array，Int32Array等）对应的数据类型应与申请内存的字节数匹配，否则会引起异常。
+
+```
+beginRead(): boolean;
+endRead(): void;
+getContent(): Readonly<ArrayBuffer>;
+```
+
+示例：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = memory.createPurgeableMemory(1024, function(dv, size, argv) {
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+if(pobj.beginRead()) {
+    var bf = pobj.getContent();
+    var int8Arr = new Int8Array(bf);
+    for (var index = 0; index < int8Arr.length; index++) {
+        const val = int8Arr[index];
+        console.log(val);
+    }
+	pobj.endRead();
+}
+
+```
+
+### 3.对PuegeableMem写
+
+Purgeable提供了操作PuegeableMem的接口，如创建、读取和写入，以下展示了如何写入。
+
+通过调用beginWrite()和endWrite()写。beginWrite返回true时才能调用ModifyContentByBuilder对其写入数据。
+
+```
+beginWrite(): bool;
+endWrite(): void;
+modifyContentByBuilder(callback: (dv: DataView, size : number, argv: {}) => boolean, argv: {}): boolean;
+```
+
+示例：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = memory.createPurgeableMemory(1024, function(dv, size, argv) {
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+var argv2 = {};
+argv2.num1 = 10;
+argv2.num2 = 20;
+argv2.num3 = 30;
+if(purgeableMem.beginWrite()) {
+	purgeableMem.ModifyContentByBuilder(function(dv, size, argv2) {
+		for(var i = 0; i < size; i++) {
+			dv.setInt8(i, argv2.num1 + argv2.num2 + argv2.num3);
+		}
+		return true;
+	}, argv2);
+	purgeableMem.endWrite();
+}
+
+```
+
+### 4.获取PuegeableMem缓冲区大小
+
+Purgeable提供了操作PuegeableMem的接口，如创建、读取和写入，以下展示了如何获取缓冲区大小。
+
+通过调用getContentSize()获取缓冲区大小。注意：返回的是字节大小，并不是数组长度。
+
+```
+getContentSize(): number;
+```
+
+示例：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = memory.createPurgeableMemory(1024, function(dv, size, argv) {
+	for(var i = 0;i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+var size = purgeableMem.getContentSize();
+console.log(size);
+```
+
+### 5.销毁PuegeableMem
+
+Purgeable提供了操作PuegeableMem的接口，如创建、读取和写入，以下展示了如何销毁PuegeableMem。
+
+通过调用destroy()销毁。
+
+```
+destroy(): void;
+```
+
+示例：
+
+```
+import memory from '@ohos.memory';
+...
+var argv = {};
+argv.num1 = 10;
+argv.num2 = 20;
+var purgeableMem = memory.createPurgeableMemory(1024, function(dv, size, argv) {
+	for(var i = 0; i < size; i++) {
+		dv.setInt8(i, argv.num1 + argv.num2);
+	}
+	return true;
+}, argv);
+purgeableMem.destroy();
+```
+
diff --git a/libpurgeablemem/common/include/pm_log.h b/libpurgeablemem/common/include/pm_log.h
new file mode 100644
index 0000000000000000000000000000000000000000..66c4529c2a1366a9805088efa1543df3d59e180f
--- /dev/null
+++ b/libpurgeablemem/common/include/pm_log.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_COMMON_INCLUDE_PM_LOG_H
+#define OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_COMMON_INCLUDE_PM_LOG_H
+
+#include "hilog/log.h"
+
+static constexpr OHOS::HiviewDFX::HiLogLabel LOG_LABEL = { LOG_CORE, 0xD001799, "MemMgrPurge" };
+
+#ifdef HILOG_ERROR
+#undef HILOG_ERROR
+#endif
+
+#ifdef HILOG_INFO
+#undef HILOG_INFO
+#endif
+
+#ifdef HILOG_DEBUG
+#undef HILOG_DEBUG
+#endif
+
+#define FILENAME "purgeable"
+
+#define HILOG_ERROR(logCore, fmt, ...)            \
+    (void)OHOS::HiviewDFX::HiLog::Error( \
+        LOG_LABEL, "[%{public}s(%{public}s:%{public}d)]" fmt, FILENAME, __FUNCTION__, __LINE__, ##__VA_ARGS__)
+
+#define HILOG_INFO(logCore, fmt, ...)            \
+    (void)OHOS::HiviewDFX::HiLog::Info( \
+        LOG_LABEL, "[%{public}s(%{public}s:%{public}d)]" fmt, FILENAME, __FUNCTION__, __LINE__, ##__VA_ARGS__)
+
+#define HILOG_DEBUG(logCore, fmt, ...)            \
+    (void)OHOS::HiviewDFX::HiLog::Debug( \
+        LOG_LABEL, "[%{public}s(%{public}s:%{public}d)]" fmt, FILENAME, __FUNCTION__, __LINE__, ##__VA_ARGS__)
+
+#endif
\ No newline at end of file
diff --git a/libpurgeablemem/common/include/pm_napi_utils.h b/libpurgeablemem/common/include/pm_napi_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..89142b0229532abf298d59ebaa9ff9aa041650e7
--- /dev/null
+++ b/libpurgeablemem/common/include/pm_napi_utils.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_COMMON_INCLUDE_PM_NAPI_UTILS_H
+#define OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_COMMON_INCLUDE_PM_NAPI_UTILS_H
+
+#include "napi/native_api.h"
+#include "napi/native_node_api.h"
+#include "pm_log.h"
+
+#define PM_IS_OK(x) ((x) == napi_ok)
+#define PM_NOT_NULL(p) ((p) != nullptr)
+#define PM_IS_READY(x, p) (PM_IS_OK(x) && PM_NOT_NULL(p))
+
+#define PM_NAPI_CHECK_RET_D(x, res, msg) \
+do \
+{ \
+    if (!(x)) \
+    { \
+        msg; \
+        return (res); \
+    } \
+} while (0)
+
+#define PM_ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+
+#define PM_FUNCTION_IN(...) HILOG_INFO(LOG_CORE, "%{public}s IN", __FUNCTION__, ##__VA_ARGS__)
+#define PM_FUNCTION_OUT(...) HILOG_INFO(LOG_CORE, "%{public}s OUT", __FUNCTION__, ##__VA_ARGS__)
+
+namespace OHOS {
+namespace PurgeableMem {
+const int32_t ARGS0 = 0;
+const int32_t ARGS1 = 1;
+const int32_t ARGS2 = 2;
+const int32_t ARGS3 = 3;
+const int32_t ARGS4 = 4;
+const int32_t PARAM0 = 0;
+const int32_t PARAM1 = 1;
+const int32_t PARAM2 = 2;
+const int32_t PARAM3 = 3;
+const int32_t PARAM4 = 4;
+
+class PmNapiUtils {
+public:
+    static napi_valuetype GetType(napi_env env, napi_value root);
+    static napi_value ThrowExceptionError(napi_env env, const int32_t errCode, const std::string& errMsg);
+};
+} // namespace PurgeableMem
+} // namespace OHOS
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_PM_NAPI_UTILS_H
diff --git a/libpurgeablemem/common/src/pm_napi_utils.cpp b/libpurgeablemem/common/src/pm_napi_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1dad368a44512dd0c4ac0264c25f69539d7a3c57
--- /dev/null
+++ b/libpurgeablemem/common/src/pm_napi_utils.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "pm_napi_utils.h"
+
+namespace OHOS {
+namespace PurgeableMem {
+napi_valuetype PmNapiUtils::GetType(napi_env env, napi_value root)
+{
+    napi_valuetype res = napi_undefined;
+    napi_typeof(env, root, &res);
+    return res;
+}
+
+napi_value PmNapiUtils::ThrowExceptionError(napi_env env, const int32_t errCode,
+    const std::string& errMsg)
+{
+    napi_value result = nullptr;
+    napi_status status = napi_throw_error(env, std::to_string(errCode).c_str(), errMsg.c_str());
+    if (status == napi_ok) {
+        napi_get_undefined(env, &result);
+    }
+    return result;
+}
+}
+}
\ No newline at end of file
diff --git a/libpurgeablemem/js/@ohos.memory.d.ts b/libpurgeablemem/js/@ohos.memory.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49e64e11e95e2bb68cf5cb34fb669bf30afedb63
--- /dev/null
+++ b/libpurgeablemem/js/@ohos.memory.d.ts
@@ -0,0 +1,111 @@
+/*
+* Copyright (C) 2022 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+ * @name memory
+ * @since 9
+ * @import import memory from '@ohos.memory';
+ */
+ declare namespace memory {
+ 
+	/**
+	 * PurgeableMemory object.
+	 * @since 9
+	 * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	 */
+	interface PurgeableMemory {
+	
+	  /**
+	   * begin read PurgeableMemory.
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   * @return returns true otherwise returns false.
+	   */
+	  beginRead() : boolean;
+  
+	  /**
+	   * end read PurgeableMemory.
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   */
+	  endRead(): void;
+  
+	  /**
+	   * begin write PurgeableMemory.
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   * @return returns true otherwise returns false.
+	   */
+	  beginWrite(): boolean;
+  
+	  /**
+	   * end write PurgeableMemory.
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   */
+	  endWrite(): void;
+  
+	  /**
+	   * get PurgeableMemory content.
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   * @return returns ArrayBuffer otherwise returns void.
+	   * @readonly
+	   */
+	  getContent(): Readonly<ArrayBuffer>;
+  
+	  /**
+	   * get PurgeableMemory size.
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   * @return returns memory bytes size otherwise returns void.
+	   */
+	  getContentSize(): number;
+  
+	  /**
+	   * set write PurgeableMemory content callback.
+	   * @param callback function Used to rebuild memory
+	   * @param argv Parameters required for callback function reconstruction
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   * @return returns true otherwise returns false.
+	   */
+	  modifyContentByBuilder(callback: (dv: DataView, size: number, argv: {}) => boolean, argv: {}): boolean;
+	  
+	  /**
+	   * destroy PurgeableMemory object.
+	   * @since 9
+	   * @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	   */
+	  destroy(): void;
+		  
+	}
+  
+	/**
+	* create an PurgeableMemory object through buffer size, callback function and required data
+	* @param size Create a purgeableMem, the size of the object pointing to the native pointer buffer
+	* @param callback This callback is a callback function used to create buffer space.
+	* @param dv is an access object to the buffer.
+	* @param size is the size of the buffer space.
+	* @param argv Parameters required for callback function reconstruction
+	* @since 9
+	* @syscap SystemCapability.Commonlibrary.MemoryUtils.PurgeableMem
+	* @return PurgeableMemory object.
+	*/
+	function createPurgeableMemory(size: number, callback :(dv: DataView, size: number, argv: {}) => boolean, argv: {}): PurgeableMemory;
+  
+  }
+	
+export default memory;
\ No newline at end of file
diff --git a/libpurgeablemem/js/BUILD.gn b/libpurgeablemem/js/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..0cb7c27e9bc97d0baf1f973b730251855c4cb963
--- /dev/null
+++ b/libpurgeablemem/js/BUILD.gn
@@ -0,0 +1,55 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos.gni")
+import("//build/ohos/ace/ace.gni")
+
+config("libpurgeable_mem_napi_config") {
+  include_dirs = [
+    "include",
+    "../cpp/include",
+    "../common/include",
+  ]
+  cflags_cc = [ "-fexceptions" ]
+}
+
+js_declaration("purgeable_js") {
+  part_name = "purgeable"
+  sources = [ "./@ohos.memory.d.ts" ]
+}
+
+purgeable_deps = [ "../:libpurgeablemem" ]
+
+ohos_shared_library("memory") {
+  cflags = [ "-DPM_DEBUG_FLAG" ]
+  sources = [
+    "../common/src/pm_napi_utils.cpp",
+    "src/builder_buffer.cpp",
+    "src/native_module_ohos_purgeable_mem.cpp",
+    "src/purgeable_mem_napi.cpp",
+  ]
+
+  deps = purgeable_deps
+
+  external_deps = [
+    "ability_runtime:napi_base_context",
+    "c_utils:utils",
+    "hiviewdfx_hilog_native:libhilog",
+    "napi:ace_napi",
+  ]
+  include_dirs = [ "include" ]
+  public_configs = [ ":libpurgeable_mem_napi_config" ]
+  relative_install_dir = "module"
+  subsystem_name = "commonlibrary"
+  part_name = "memory_utils"
+}
diff --git a/libpurgeablemem/js/include/builder_buffer.h b/libpurgeablemem/js/include/builder_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..5aebd3dd1ebfcf4d51d39f4ed9458789f728f0c4
--- /dev/null
+++ b/libpurgeablemem/js/include/builder_buffer.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_JS_INCLUDE_BUILD_BUFFER_H
+#define OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_JS_INCLUDE_BUILD_BUFFER_H
+
+#include "napi/native_api.h"
+#include "napi/native_node_api.h"
+#include "purgeable_mem_builder.h"
+
+namespace OHOS {
+namespace PurgeableMem {
+class BuilderBuffer : public PurgeableMemBuilder {
+public:
+    BuilderBuffer(napi_env env, napi_value fun, napi_value param);
+    ~BuilderBuffer();
+    bool Build(void *data, size_t size);
+private:
+    napi_env env_ = nullptr;
+    napi_ref refFun_;
+    napi_ref refParam_;
+};
+} // namespace PurgeableMem
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/libpurgeablemem/js/include/native_module_ohos_purgeable_mem.h b/libpurgeablemem/js/include/native_module_ohos_purgeable_mem.h
new file mode 100644
index 0000000000000000000000000000000000000000..89746da1dd5c1bad4af06c6c50856bc871bcaab5
--- /dev/null
+++ b/libpurgeablemem/js/include/native_module_ohos_purgeable_mem.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_JS_INCLUDE_NATIVE_MODULE_OHOS_PURGEABLE_MEM_H
+#define OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_JS_INCLUDE_NATIVE_MODULE_OHOS_PURGEABLE_MEM_H
+
+#include "napi/native_node_api.h"
+#include "purgeable_mem_napi.h"
+
+
+#endif // OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_JS_INCLUDE_NATIVE_MODULE_OHOS_PURGEABLE_MEM_H
\ No newline at end of file
diff --git a/libpurgeablemem/js/include/purgeable_mem_napi.h b/libpurgeablemem/js/include/purgeable_mem_napi.h
new file mode 100644
index 0000000000000000000000000000000000000000..2de48e411df91c62c1be40d0f7f962a411d8e93d
--- /dev/null
+++ b/libpurgeablemem/js/include/purgeable_mem_napi.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_JS_INCLUDE_PURGEABLE_MEM_NAPI_H
+#define OHOS_UTILS_MEMORY_LIBPURGEABLEMEM_JS_INCLUDE_PURGEABLE_MEM_NAPI_H
+
+#include "napi/native_api.h"
+#include "napi/native_node_api.h"
+#include "purgeable_mem.h"
+#include <memory>
+#include "hilog/log.h"
+
+
+namespace OHOS {
+namespace PurgeableMem {
+class PurgeableMemNapi;
+struct Context {
+    napi_env env = nullptr;
+    PurgeableMemNapi *constructor_ = nullptr;
+    uint32_t status;
+};
+class PurgeableMemNapi {
+public:
+    static napi_value Init(napi_env env, napi_value exports);
+    PurgeableMemNapi();
+    ~PurgeableMemNapi();
+private:
+    static napi_value Constructor(napi_env env, napi_callback_info info);
+    static void Destructor(napi_env env, void *nativeObject, void *finalize);
+    static napi_value CreatePurgeableMem(napi_env env, napi_callback_info info);
+    static napi_value Destroy(napi_env env, napi_callback_info info);
+    static napi_value BeginRead(napi_env env, napi_callback_info info);
+    static napi_value EndRead(napi_env env, napi_callback_info info);
+    static napi_value BeginWrite(napi_env env, napi_callback_info info);
+    static napi_value EndWrite(napi_env env, napi_callback_info info);
+    static napi_value GetContent(napi_env env, napi_callback_info info);
+    static napi_value GetContentSize(napi_env env, napi_callback_info info);
+    static napi_value ModifyContentByBuilder(napi_env env, napi_callback_info info);
+    static std::unique_ptr<Context> UnwarpContext(napi_env env, napi_callback_info info);
+private:
+    static thread_local napi_ref sConstructor_;
+    static std::shared_ptr<PurgeableMem> staticInstance_;
+    std::shared_ptr<PurgeableMem> purgeableMem_;
+    napi_env env_ = nullptr;
+};
+} // namespace PurgeableMem
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/libpurgeablemem/js/src/builder_buffer.cpp b/libpurgeablemem/js/src/builder_buffer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e7b625b16ab7be43b04cf61e031b9a6ad7cdd82
--- /dev/null
+++ b/libpurgeablemem/js/src/builder_buffer.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "builder_buffer.h"
+#include "purgeable_mem_builder.h"
+#include "pm_napi_utils.h"
+#include "pm_log.h"
+
+namespace OHOS {
+namespace PurgeableMem {
+BuilderBuffer::BuilderBuffer(napi_env env, napi_value fun, napi_value param) : env_(env)
+{
+    napi_create_reference(env_, fun, 1, &refFun_);
+    napi_create_reference(env_, param, 1, &refParam_);
+}
+
+BuilderBuffer::~BuilderBuffer()
+{
+    napi_delete_reference(env_, refFun_);
+    napi_delete_reference(env_, refParam_);
+}
+
+bool BuilderBuffer::Build(void *data, size_t size)
+{
+    PM_FUNCTION_IN();
+    if (size <= 0) {
+        return true;
+    }
+
+    napi_value argv[ARGS3] = {0};
+    napi_value return_val = nullptr;
+    napi_value arrayBuff = nullptr;
+    napi_value global = nullptr;
+    napi_value jsFun = nullptr;
+    napi_value param = nullptr;
+    bool result = false;
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_reference_value(env_, refFun_, &jsFun)),
+        result, HILOG_ERROR(LOG_CORE, "fail to napi_get_reference_value jsFun")
+    );
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_reference_value(env_, refParam_, &param)),
+        result, HILOG_ERROR(LOG_CORE, "fail to napi_get_reference_value param")
+    );
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_create_external_arraybuffer(env_, data, size,
+        [](napi_env env, void *finalize_data, void *finalize_hint) {},
+        nullptr, &arrayBuff)),
+        result, HILOG_ERROR(LOG_CORE, "fail to create external arraybuffer")
+    );
+    
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_create_dataview(env_, size, arrayBuff, 0, &argv[PARAM0])),
+        result, HILOG_ERROR(LOG_CORE, "fail to create dataview")
+    );
+
+    napi_create_int32(env_, size, &argv[PARAM1]);
+    argv[PARAM2] = param;
+    napi_get_global(env_, &global);
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_call_function(env_, global, jsFun, ARGS3, argv, &return_val)),
+        result, HILOG_ERROR(LOG_CORE, "fail to call function")
+    );
+    napi_get_value_bool(env_, return_val, &result);
+    PM_FUNCTION_OUT();
+    return result;
+}
+} // namespace PurgeableMem
+} // namespace OHOS
\ No newline at end of file
diff --git a/libpurgeablemem/js/src/native_module_ohos_purgeable_mem.cpp b/libpurgeablemem/js/src/native_module_ohos_purgeable_mem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77fa7db92d740b399e6484b31c5f5f7ce4dc3e3c
--- /dev/null
+++ b/libpurgeablemem/js/src/native_module_ohos_purgeable_mem.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "native_module_ohos_purgeable_mem.h"
+#include "hilog/log.h"
+#include "pm_napi_utils.h"
+#include "pm_log.h"
+
+using OHOS::HiviewDFX::HiLog;
+namespace OHOS {
+namespace PurgeableMem {
+/*
+ * Function registering all props and functions of ohos.memory module
+ */
+static napi_value Export(napi_env env, napi_value exports)
+{
+    PurgeableMemNapi::Init(env, exports);
+    return exports;
+}
+
+/*
+ * module define
+ */
+static napi_module g_module = {
+    .nm_version = 1,
+    .nm_flags = 0,
+    .nm_filename = nullptr,
+    .nm_register_func = Export,
+    .nm_modname = "memory",
+    .nm_priv = (reinterpret_cast<void *>(0)),
+    .reserved = {0}
+};
+
+/*
+ * module register
+ */
+extern "C" __attribute__((constructor)) void RegisterModule(void)
+{
+    napi_module_register(&g_module);
+}
+} // namespace PurgeableMem
+} // namespace OHOS
diff --git a/libpurgeablemem/js/src/purgeable_mem_napi.cpp b/libpurgeablemem/js/src/purgeable_mem_napi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..476f62a7055487ba47d4973adc87000c9c669d94
--- /dev/null
+++ b/libpurgeablemem/js/src/purgeable_mem_napi.cpp
@@ -0,0 +1,389 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "purgeable_mem_napi.h"
+#include "pm_napi_utils.h"
+#include "pm_log.h"
+#include "builder_buffer.h"
+#include <string>
+#include <iostream>
+
+namespace OHOS {
+namespace PurgeableMem {
+static const std::string CLASS_NAME = "PurgeableMemory";
+thread_local napi_ref PurgeableMemNapi::sConstructor_ = nullptr;
+std::shared_ptr<PurgeableMem> PurgeableMemNapi::staticInstance_;
+PurgeableMemNapi::PurgeableMemNapi() : env_(nullptr)
+{
+}
+
+PurgeableMemNapi::~PurgeableMemNapi()
+{
+}
+
+napi_value PurgeableMemNapi::Init(napi_env env, napi_value exports)
+{
+    PM_FUNCTION_IN();
+    napi_property_descriptor static_prop[] = {
+        DECLARE_NAPI_STATIC_FUNCTION("createPurgeableMemory", CreatePurgeableMem),
+    };
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_define_properties(env, exports, PM_ARRAY_SIZE(static_prop), static_prop)),
+        nullptr, HILOG_ERROR(LOG_CORE, "define properties fail")
+    );
+
+    napi_property_descriptor props[] = {
+        DECLARE_NAPI_FUNCTION("beginRead", BeginRead),
+        DECLARE_NAPI_FUNCTION("endRead", EndRead),
+        DECLARE_NAPI_FUNCTION("beginWrite", BeginWrite),
+        DECLARE_NAPI_FUNCTION("endWrite", EndWrite),
+        DECLARE_NAPI_FUNCTION("getContent", GetContent),
+        DECLARE_NAPI_FUNCTION("getContentSize", GetContentSize),
+        DECLARE_NAPI_FUNCTION("modifyContentByBuilder", ModifyContentByBuilder),
+        DECLARE_NAPI_FUNCTION("destroy", Destroy),
+    };
+    napi_value constructor = nullptr;
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_define_class(env, CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Constructor,
+        nullptr, PM_ARRAY_SIZE(props), props, &constructor)),
+        nullptr,
+        HILOG_ERROR(LOG_CORE, "define class fail")
+    );
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_create_reference(env, constructor, 1, &sConstructor_)),
+        nullptr,
+        HILOG_ERROR(LOG_CORE, "create reference fail")
+    );
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_set_named_property(env, exports, CLASS_NAME.c_str(), constructor)),
+        nullptr,
+        HILOG_ERROR(LOG_CORE, "set named property fail")
+    );
+
+    PM_FUNCTION_OUT();
+    return exports;
+}
+
+napi_value PurgeableMemNapi::Constructor(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value undefineVar = nullptr;
+    napi_get_undefined(env, &undefineVar);
+
+    napi_status status;
+    napi_value thisVar = nullptr;
+
+    status = napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
+    if (status != napi_ok || thisVar == nullptr) {
+        return undefineVar;
+    }
+    std::unique_ptr<PurgeableMemNapi> reference = std::make_unique<PurgeableMemNapi>();
+    if (reference == nullptr) {
+        return undefineVar;
+    }
+    reference->env_ = env;
+    reference->purgeableMem_ = std::move(staticInstance_);
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_wrap(env, thisVar, reinterpret_cast<void *>(reference.get()), PurgeableMemNapi::Destructor,
+        nullptr, nullptr)),
+        undefineVar,
+        HILOG_ERROR(LOG_CORE, "Failure wrapping js to native napi")
+    );
+    reference.release();
+    return thisVar;
+}
+
+void PurgeableMemNapi::Destructor(napi_env env, void *nativeObject, void *finalize)
+{
+    PurgeableMemNapi* purgeNapi = static_cast<PurgeableMemNapi*>(nativeObject);
+    if (purgeNapi != nullptr) {
+        delete purgeNapi;
+        purgeNapi = nullptr;
+    }
+    HILOG_INFO(LOG_CORE, "PurgeableMemNapi :Destructor");
+}
+
+napi_value PurgeableMemNapi::CreatePurgeableMem(napi_env env, napi_callback_info info)
+{
+    napi_value constructor = nullptr;
+    napi_value result = nullptr;
+    napi_value thisVar = nullptr;
+    napi_value func = nullptr;
+    napi_value obj = nullptr;
+    napi_value argv[ARGS3];
+    size_t argc = ARGS3;
+    int32_t size = 0;
+    PM_FUNCTION_IN();
+    napi_get_undefined(env, &result);
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)),
+        result, HILOG_ERROR(LOG_CORE, "define properties fail")
+    );
+
+    HILOG_INFO(LOG_CORE, "PurgeableMemNapi :argc  is:  %{public}d", argc);
+    if (argc < ARGS3) {
+        HILOG_ERROR(LOG_CORE, "Invailed arg counts ");
+        return result;
+    }
+
+    napi_valuetype argvType = PmNapiUtils::GetType(env, argv[PARAM0]);
+    if (argvType != napi_number) {
+        HILOG_ERROR(LOG_CORE, "Invailed arg number type");
+        return result;
+    }
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_value_int32(env, argv[PARAM0], &size)),
+        result, HILOG_ERROR(LOG_CORE, "Invailed arg number")
+    );
+
+    argvType = PmNapiUtils::GetType(env, argv[PARAM1]);
+    if (argvType != napi_function) {
+        HILOG_ERROR(LOG_CORE, "callback_ not is a function");
+        return result;
+    }
+    func = argv[PARAM1];
+	
+    obj = argv[PARAM2];
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_reference_value(env, sConstructor_, &constructor)),
+        result, HILOG_ERROR(LOG_CORE, "Failed to get reference of constructor")
+    );
+
+    std::unique_ptr<BuilderBuffer> builder = std::make_unique<BuilderBuffer>(env, func, obj);
+    staticInstance_ = std::make_shared<PurgeableMem>(size, std::move(builder));
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_new_instance(env, constructor, 0, nullptr, &result)),
+        result, HILOG_ERROR(LOG_CORE, "New instance could not be obtained")
+    );
+    return result;
+}
+
+napi_value PurgeableMemNapi::Destroy(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value result = nullptr;
+    napi_value thisVar;
+    size_t argc = ARGS0;
+    void* nativePtr = nullptr;
+    napi_get_undefined(env, &result);
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)),
+        result, HILOG_ERROR(LOG_CORE, "fail to napi_get_cb_info")
+    );
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_remove_wrap(env, thisVar, &nativePtr)),
+        result, HILOG_ERROR(LOG_CORE, "fail to napi_remove_wrap")
+    );
+
+    PM_FUNCTION_OUT();
+    return result;
+}
+
+napi_value PurgeableMemNapi::BeginRead(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value result = nullptr;
+    napi_get_undefined(env, &result);
+    std::unique_ptr<Context> context = UnwarpContext(env, info);
+    if (context == nullptr || context->constructor_ == nullptr || context->constructor_->purgeableMem_ == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap constructor");
+        return result;
+    }
+    bool bRes = context->constructor_->purgeableMem_->BeginRead();
+    napi_get_boolean(env, bRes, &result);
+    PM_FUNCTION_OUT();
+    return result;
+}
+
+napi_value PurgeableMemNapi::EndRead(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value result = nullptr;
+    napi_get_undefined(env, &result);
+    std::unique_ptr<Context> context = UnwarpContext(env, info);
+    if (context == nullptr || context->constructor_ == nullptr || context->constructor_->purgeableMem_ == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap constructor");
+        return result;
+    }
+    context->constructor_->purgeableMem_->EndRead();
+    PM_FUNCTION_OUT();
+    return result;
+}
+
+napi_value PurgeableMemNapi::BeginWrite(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value result = nullptr;
+    napi_get_undefined(env, &result);
+    std::unique_ptr<Context> context = UnwarpContext(env, info);
+    if (context == nullptr || context->constructor_ == nullptr || context->constructor_->purgeableMem_ == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap constructor");
+        return result;
+    }
+    bool bRes = context->constructor_->purgeableMem_->BeginWrite();
+    napi_get_boolean(env, bRes, &result);
+    PM_FUNCTION_OUT();
+    return result;
+}
+
+napi_value PurgeableMemNapi::EndWrite(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value result = nullptr;
+    napi_get_undefined(env, &result);
+    
+    std::unique_ptr<Context> context = UnwarpContext(env, info);
+    if (context == nullptr || context->constructor_ == nullptr || context->constructor_->purgeableMem_ == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap constructor");
+        return result;
+    }
+    context->constructor_->purgeableMem_->EndWrite();
+    PM_FUNCTION_OUT();
+    return result;
+}
+
+napi_value PurgeableMemNapi::GetContent(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value result = nullptr;
+    napi_get_undefined(env, &result);
+    std::unique_ptr<Context> context = UnwarpContext(env, info);
+    if (context == nullptr || context->constructor_ == nullptr || context->constructor_->purgeableMem_ == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap constructor");
+        return result;
+    }
+    void* data = context->constructor_->purgeableMem_->GetContent();
+    size_t size = context->constructor_->purgeableMem_->GetContentSize();
+    if (data == nullptr || size <= 0) {
+        HILOG_ERROR(LOG_CORE, "get data is null or size <= 0");
+        return result;
+    }
+    napi_value bf;
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_create_external_arraybuffer(env, data, size,
+        [](napi_env env, void *finalize_data, void *finalize_hint) {},
+        nullptr, &bf)),
+        result, HILOG_ERROR(LOG_CORE, "fail to create external arraybuffer")
+    );
+
+    napi_value dv;
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_create_dataview(env, size, bf, 0, &dv)),
+        result, HILOG_ERROR(LOG_CORE, "fail to create  dataview")
+    );
+
+    napi_value dvBuffer;
+    napi_get_named_property(env, dv, "buffer", &dvBuffer);
+    return dvBuffer;
+}
+
+napi_value PurgeableMemNapi::GetContentSize(napi_env env, napi_callback_info info)
+{
+    PM_FUNCTION_IN();
+    napi_value result = nullptr;
+    napi_status status;
+    napi_get_undefined(env, &result);
+    std::unique_ptr<Context> context = UnwarpContext(env, info);
+    if (context == nullptr || context->constructor_ == nullptr || context->constructor_->purgeableMem_ == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap constructor");
+        return result;
+    }
+    size_t size = context->constructor_->purgeableMem_->GetContentSize();
+    status = napi_create_int32(env, size, &result);
+    PM_FUNCTION_OUT();
+    return result;
+}
+
+napi_value PurgeableMemNapi::ModifyContentByBuilder(napi_env env, napi_callback_info info)
+{
+    napi_status status;
+    napi_value result = nullptr;
+    napi_value thisVar = nullptr;
+    
+    size_t argc = ARGS2;
+    napi_value argv[ARGS2];
+    napi_value func;
+    napi_value obj;
+    PM_FUNCTION_IN();
+    napi_get_boolean(env, false, &result);
+
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)),
+        result, HILOG_ERROR(LOG_CORE, "fail to napi_get_cb_info ")
+    );
+
+    if (argc < ARGS1) {
+        HILOG_ERROR(LOG_CORE, "Invailed arg counts");
+        return result;
+    }
+    
+    napi_valuetype argvType = PmNapiUtils::GetType(env, argv[PARAM0]);
+    if (argvType != napi_function) {
+        HILOG_ERROR(LOG_CORE, "Invailed arg");
+        return result;
+    }
+
+    func = argv[PARAM0];
+    if (argc >= ARGS2) {
+        obj = argv[PARAM1];
+    } else {
+        napi_get_undefined(env, &obj);
+    }
+
+    std::unique_ptr<PurgeableMemBuilder> builder = std::make_unique<BuilderBuffer>(env, func, obj);
+    PurgeableMemNapi *pNapi;
+    status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&pNapi));
+    if (!PM_IS_OK(status) || pNapi == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap pNapi %{public}d", status);
+        return result;
+    }
+    bool bRes = pNapi->purgeableMem_->ModifyContentByBuilder(std::move(builder));
+    napi_get_boolean(env, bRes, &result);
+
+    PM_FUNCTION_OUT();
+    return result;
+}
+
+std::unique_ptr<Context> PurgeableMemNapi::UnwarpContext(napi_env env, napi_callback_info info)
+{
+    napi_status status;
+    napi_value thisVar = nullptr;
+    size_t argc = ARGS0;
+    
+    PM_FUNCTION_IN();
+    PM_NAPI_CHECK_RET_D(PM_IS_OK(
+        napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)),
+        nullptr, HILOG_ERROR(LOG_CORE, "fail to napi_get_cb_info ")
+    );
+    std::unique_ptr<Context> context = std::make_unique<Context>();
+    status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&context->constructor_));
+    if (status != napi_ok || context->constructor_ == nullptr) {
+        HILOG_ERROR(LOG_CORE, "fail to unwrap constructor_ %{public}d", status);
+        return nullptr;
+    }
+    PM_FUNCTION_OUT();
+    return context;
+}
+} // namespace PurgeableMem
+} // namespace OHOS
\ No newline at end of file