@react-native-ohos/clipboard 1.2.0-beta.1

package/harmony/clipboard/src/main/ets/RNCClipboardTurboModule.ts

@@ -0,0 +1,759 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { pasteboard, BusinessError } from '@kit.BasicServicesKit';
+import util from '@ohos.util';
+import image from '@ohos.multimedia.image';
+import logger from './Logger';
+import abilityAccessCtrl, { Permissions } from '@ohos.abilityAccessCtrl';
+import url from '@ohos.url';
+
+const TAG = "RNCClipboardTurboModule"
+const prefixPNG = "data:image/png;base64,"
+const prefixJPG = "data:image/jpg;base64,"
+const imageMimePrefix = "image/"
+const defaultImageMimeType = "image/png"
+const PERMISSIONS: Array<Permissions> = [
+  'ohos.permission.READ_PASTEBOARD'
+]
+
+export class RNCClipboardTurboModule extends TurboModule {
+  constructor(protected ctx: TurboModuleContext) {
+    super(ctx);
+    logger.debug(TAG, "RNCClipboardTurboModule constructor");
+  }
+
+  getConstants() {
+    logger.debug(TAG, "RNCClipboardTurboModule call getConstants");
+    return {};
+  }
+
+  getString(): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          systemPasteboard.getData().then((pasteData) => {
+            let text = pasteData.getPrimaryText();
+            logger.debug(TAG, `getString,text out:${text}`);
+            resolve(text);
+          }).catch((err) => {
+            logger.error(TAG, `getString,Failed to get PasteData. Cause:${err.message}`);
+            reject(err);
+          })
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      })
+    });
+  }
+
+  getStrings(): Promise<string[]> {
+    return new Promise<string[]>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "call getStrings fun");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          systemPasteboard.getData().then((pasteData) => {
+            let count = pasteData.getRecordCount();
+            let resultSet = []
+            logger.debug(TAG, `getStrings fun,getRecordCount :${count}`);
+            for (let index = 0; index < count; index++) {
+              let record = pasteData.getRecord(index)
+              if (record.mimeType == pasteboard.MIMETYPE_TEXT_PLAIN) {
+                resultSet.push(record.plainText)
+              }
+            }
+            resolve(resultSet)
+          }).catch((err) => {
+            logger.error(TAG, `getString fun,Failed to get PasteData. Cause:${err.message}`);
+            reject(err)
+          })
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      })
+    });
+  }
+
+  setString(content: string) {
+    logger.debug(TAG, "setString fun");
+    let systemPasteboard = pasteboard.getSystemPasteboard();
+    let dataText = content;
+    let pasteData = pasteboard.createData(pasteboard.MIMETYPE_TEXT_PLAIN, dataText);
+    systemPasteboard.setData(pasteData).then((data) => {
+      logger.debug(TAG, "setString fun,Succeeded PasteData");
+    }).catch((err) => {
+      logger.error(TAG, `setString fun,Failed to set PasteData.setString, Cause:${err.message}`);
+    });
+    return;
+  }
+
+  hasString(): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "RNCClipboardTurboModule call hasString fun");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          systemPasteboard.getData().then((pasteData) => {
+            let count = pasteData.getRecordCount();
+            resolve(count > 0)
+          }).catch((err) => {
+            logger.error(TAG, `RNCClipboardTurboModule hasString,Failed to get PasteData. Cause:${err.message}`);
+            reject(err)
+          })
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      })
+    });
+  }
+
+  hasNumber(): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call hasNumber");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          let reg = /^[\d]*$/;
+          systemPasteboard.getData().then((pasteData) => {
+            let count = pasteData.getRecordCount();
+            let result = false
+            for (let index = 0; index < count; index++) {
+              let record = pasteData.getRecord(index);
+              if (record.mimeType == pasteboard.MIMETYPE_TEXT_PLAIN && reg.test(record.plainText)) {
+                result = true
+                logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule hasNumber,result out:${result}`);
+                break
+              }
+            }
+            resolve(result)
+          }).catch((err) => {
+            logger.error(TAG, `[RNOH]: hasNumber,Failed to get PasteData. Cause:${err.message}`);
+            reject(err)
+          })
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      })
+    });
+  }
+
+  // ios
+  getImagePNG(): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call getImagePNG");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+
+          systemPasteboard.getData().then((pasteData) => {
+            let pixMap = pasteData.getPrimaryPixelMap();
+            if (!pixMap) {
+              logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImagePNG,pixMap is null or undefined");
+              reject({
+                code: 1,
+                message: "Clipboard does not contain an image"
+              });
+              return;
+            }
+            const imagePackerApi = image.createImagePacker();
+            let packOpt: image.PackingOption = {
+              format: "image/png",
+              quality: 96
+            }
+            imagePackerApi.packing(pixMap, packOpt).then(data => {
+              let uint8Array = new Uint8Array(data);
+              let base64Helper = new util.Base64Helper();
+              let base64Str = base64Helper.encodeToStringSync(uint8Array, util.Type.BASIC)
+              let finalStr = prefixPNG + base64Str
+              resolve(finalStr)
+            }).catch((err) => {
+              logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImagePNG,failed to packing");
+              reject(err)
+            }).finally(() => {
+              imagePackerApi.release().then(() => {
+                logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call getImagePNG, releasing image packaging");
+              }).catch((error: BusinessError) => {
+                logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImagePNG, releasing image packaging error");
+              })
+            })
+
+          }).catch((err) => {
+            logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImagePNG,failed to getData");
+            reject(err)
+          })
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      }).catch((err) => {
+        logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImagePNG,failed to request permission");
+        reject({
+          code: 2,
+          message: "Failed to request permission"
+        })
+      });
+    });
+  }
+
+  // ios
+  getImageJPG(): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call getImageJPG");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+
+          systemPasteboard.getData().then((pasteData) => {
+            let pixMap = pasteData.getPrimaryPixelMap();
+            if (!pixMap) {
+              logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImageJPG,pixMap is null or undefined");
+              reject({
+                code: 1,
+                message: "Clipboard does not contain an image"
+              });
+              return;
+            }
+            const imagePackerApi = image.createImagePacker();
+            let packOpt: image.PackingOption = {
+              format: "image/jpeg",
+              quality: 96
+            }
+            imagePackerApi.packing(pixMap, packOpt).then(data => {
+              let uint8Array = new Uint8Array(data);
+              let base64Helper = new util.Base64Helper();
+              let base64Str = base64Helper.encodeToStringSync(uint8Array, util.Type.BASIC)
+              let finalStr = prefixJPG + base64Str
+              resolve(finalStr)
+            }).catch((err) => {
+              logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImageJPG,failed to packing");
+              reject(err)
+            }).finally(() => {
+              imagePackerApi.release().then(() => {
+                logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call getImageJPG, releasing image packaging");
+              }).catch((error: BusinessError) => {
+                logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImageJPG, releasing image packaging error");
+              })
+            })
+
+          }).catch((err) => {
+            logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImageJPG,failed to getData");
+            reject(err)
+          })
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      }).catch((err) => {
+        logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call getImageJPG,failed to request permission");
+        reject({
+          code: 2,
+          message: "Failed to request permission"
+        })
+      });
+    });
+  }
+
+  setImage(content: string) {
+    logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule call setImage:${content}`);
+    let iconBase64 = content
+
+    let base64 = new util.Base64Helper();
+    let uint8 = base64.decodeSync(iconBase64, util.Type.BASIC)
+    let arrayBuffer = uint8.buffer.slice(uint8.byteOffset, uint8.byteLength + uint8.byteOffset)
+    let imageSource: image.ImageSource = image.createImageSource(arrayBuffer);
+    logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call setImage100");
+
+    // 获取图片格式信息
+    let imageFormat = this.getImageFormatFromArrayBuffer(arrayBuffer);
+    logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule call setImage, detected format: ${imageFormat}`);
+
+    imageSource.getImageInfo().then(value => {
+      let hValue = Math.round(value.size.height);
+      let wValue = Math.round(value.size.width);
+      let defaultSize: image.Size = {
+        height: hValue,
+        width: wValue
+      };
+      let opts: image.DecodingOptions = {
+        editable: true,
+        desiredSize: defaultSize
+      };
+      logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call setImage200");
+      imageSource.createPixelMap(opts).then((pixMap) => {
+        let iconPixelMap = pixMap
+        logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call setImage300");
+        imageSource.release()
+
+        let systemPasteboard = pasteboard.getSystemPasteboard();
+        systemPasteboard.getData().then((pasteData) => {
+          // 使用 MIMETYPE_PIXELMAP 创建记录，确保兼容性
+          let record = pasteboard.createRecord(pasteboard.MIMETYPE_PIXELMAP, iconPixelMap)
+          // 在 record 的 data 中保存原始格式信息，供 getImage 读取
+          if (!record.data) {
+            record.data = {};
+          }
+          record.data[imageFormat] = arrayBuffer;
+          pasteData.addRecord(record)
+
+          systemPasteboard.setData(pasteData).then((data: void) => {
+            logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule call setImage305,successed in setting pasteData with format: ${imageFormat}`);
+          }).catch((err) => {
+            logger.error(TAG, "[RNOH]:RNCClipboardTurboModule call setImage305,failed in setting pasteData");
+          })
+        }).catch((err) => {
+          logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule call setImage,failed get pasteData.cause:${err.message}`);
+        })
+      })
+    })
+
+  }
+
+  // 从 ArrayBuffer 中检测图片格式
+  private getImageFormatFromArrayBuffer(buffer: ArrayBuffer): string {
+    let uint8Array = new Uint8Array(buffer);
+
+    // 检查 JPEG (FF D8 FF)
+    if (uint8Array.length >= 3 &&
+      uint8Array[0] === 0xFF &&
+      uint8Array[1] === 0xD8 &&
+      uint8Array[2] === 0xFF) {
+      return "image/jpeg";
+    }
+
+    // 检查 PNG (89 50 4E 47 0D 0A 1A 0A)
+    if (uint8Array.length >= 8 &&
+      uint8Array[0] === 0x89 &&
+      uint8Array[1] === 0x50 &&
+      uint8Array[2] === 0x4E &&
+      uint8Array[3] === 0x47 &&
+      uint8Array[4] === 0x0D &&
+      uint8Array[5] === 0x0A &&
+      uint8Array[6] === 0x1A &&
+      uint8Array[7] === 0x0A) {
+      return "image/png";
+    }
+
+    // 检查 WEBP (52 49 46 46 ... 57 45 42 50)
+    if (uint8Array.length >= 12 &&
+      uint8Array[0] === 0x52 &&
+      uint8Array[1] === 0x49 &&
+      uint8Array[2] === 0x46 &&
+      uint8Array[3] === 0x46 &&
+      uint8Array[8] === 0x57 &&
+      uint8Array[9] === 0x45 &&
+      uint8Array[10] === 0x42 &&
+      uint8Array[11] === 0x50) {
+      return "image/webp";
+    }
+
+    // 检查 GIF (47 49 46 38)
+    if (uint8Array.length >= 4 &&
+      uint8Array[0] === 0x47 &&
+      uint8Array[1] === 0x49 &&
+      uint8Array[2] === 0x46 &&
+      uint8Array[3] === 0x38) {
+      return "image/gif";
+    }
+
+    // 检查 BMP (42 4D)
+    if (uint8Array.length >= 2 &&
+      uint8Array[0] === 0x42 &&
+      uint8Array[1] === 0x4D) {
+      return "image/bmp";
+    }
+
+    // 默认返回 PNG
+    logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule getImageFormatFromArrayBuffer, unknown format, defaulting to image/png");
+    return "image/png";
+  }
+
+  getImage(): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call getImage");
+      this.requestPermission().then(async res => {
+        if (!res) {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+          return
+        }
+
+        try {
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          let pasteData = await systemPasteboard.getData();
+
+          // 检查剪贴板中是否有 JPEG 或 PNG 格式的数据
+          // 如果有，使用与 getImageJPG/getImagePNG 相同的逻辑：通过 getPrimaryPixelMap 重新打包
+          let imageFormat = this.getImageFormatFromPasteData(pasteData);
+          if (imageFormat) {
+            logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule getImage, detected format: ${imageFormat}, using getImageJPG/getImagePNG logic`);
+            let pixelMapObj = pasteData.getPrimaryPixelMap();
+            if (pixelMapObj) {
+              // 使用与 getImageJPG/getImagePNG 相同的参数重新打包
+              let imageDataUri = await this.packPixelMapAsDataUri(pixelMapObj, imageFormat);
+              resolve(imageDataUri);
+              return;
+            }
+          }
+
+          let imageDataUri = await this.getImageDataUriFromPasteData(pasteData);
+          resolve(imageDataUri)
+        } catch (err) {
+          logger.error(TAG, `[RNOH]:RNCClipboardTurboModule call getImage,failed to get image. Cause:${err.message}`);
+          reject(err)
+        }
+      }).catch((err) => {
+        logger.error(TAG, `[RNOH]:RNCClipboardTurboModule call getImage,failed to request permission. Cause:${err.message}`);
+        reject(err)
+      })
+    });
+  }
+
+  // 从剪贴板数据中检测图片格式
+  private getImageFormatFromPasteData(pasteData: pasteboard.PasteData): string | null {
+    let count = pasteData.getRecordCount();
+    for (let index = 0; index < count; index++) {
+      let record = pasteData.getRecord(index);
+      // 检查 record.mimeType
+      let mimeType = record.mimeType?.toLowerCase() || "";
+      if (mimeType === "image/jpeg" || mimeType === "image/jpg") {
+        return "image/jpeg";
+      }
+      if (mimeType === "image/png") {
+        return "image/png";
+      }
+      // 检查 record.data 中的 mimeType
+      if (record.data) {
+        for (let mt of Object.keys(record.data)) {
+          let lowerMt = mt.toLowerCase();
+          if (lowerMt === "image/jpeg" || lowerMt === "image/jpg") {
+            return "image/jpeg";
+          }
+          if (lowerMt === "image/png") {
+            return "image/png";
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  private async getImageDataUriFromPasteData(pasteData: pasteboard.PasteData): Promise<string> {
+    let count = pasteData.getRecordCount();
+    for (let index = 0; index < count; index++) {
+      let record = pasteData.getRecord(index);
+      let dataUri = await this.getImageDataUriFromRecord(record);
+      if (dataUri.length > 0) {
+        return dataUri
+      }
+    }
+
+    try {
+      let pixelMapObj = pasteData.getPrimaryPixelMap();
+      if (pixelMapObj) {
+        return await this.packPixelMapAsDataUri(pixelMapObj, defaultImageMimeType)
+      }
+    } catch (err) {
+      logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule getImage,no primary PixelMap. Cause:${err.message}`);
+    }
+
+    return ""
+  }
+
+  private async getImageDataUriFromRecord(record: pasteboard.PasteDataRecord): Promise<string> {
+    if (this.isImageMimeType(record.mimeType)) {
+      let dataUri = await this.getImageDataUriByMimeType(record, record.mimeType);
+      if (dataUri.length > 0) {
+        return dataUri
+      }
+    }
+
+    if (record.data) {
+      let customMimeTypes = Object.keys(record.data);
+      for (let index = 0; index < customMimeTypes.length; index++) {
+        let mimeType = customMimeTypes[index];
+        if (this.isImageMimeType(mimeType)) {
+          return this.createDataUri(mimeType, record.data[mimeType])
+        }
+      }
+    }
+
+    if (record.pixelMap) {
+      let mimeType = this.isImageMimeType(record.mimeType) ? record.mimeType : defaultImageMimeType;
+      return await this.packPixelMapAsDataUri(record.pixelMap, mimeType)
+    }
+
+    return ""
+  }
+
+  private async getImageDataUriByMimeType(record: pasteboard.PasteDataRecord, mimeType: string): Promise<string> {
+    if (record.data && record.data[mimeType]) {
+      return this.createDataUri(mimeType, record.data[mimeType])
+    }
+
+    try {
+      let value = await record.getData(mimeType);
+      if (value instanceof ArrayBuffer) {
+        return this.createDataUri(mimeType, value)
+      }
+
+      if (this.isPixelMap(value)) {
+        return await this.packPixelMapAsDataUri(value as image.PixelMap, mimeType)
+      }
+    } catch (err) {
+      logger.debug(TAG, `[RNOH]:RNCClipboardTurboModule getImage,failed to read mimeType:${mimeType}. Cause:${err.message}`);
+    }
+
+    return ""
+  }
+
+  private async packPixelMapAsDataUri(pixelMapObj: image.PixelMap, mimeType: string): Promise<string> {
+    const imagePackerApi = image.createImagePacker();
+    let packingMimeType = this.getPackingMimeType(mimeType);
+    let packOpt: image.PackingOption = {
+      format: packingMimeType,
+      quality: 96
+    }
+
+    try {
+      let data = await imagePackerApi.packing(pixelMapObj, packOpt);
+      return this.createDataUri(packingMimeType, data)
+    } finally {
+      imagePackerApi.release().then(() => {
+        logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call getImage, releasing image packaging");
+      }).catch((error: BusinessError) => {
+        logger.error(TAG, `[RNOH]:RNCClipboardTurboModule call getImage, releasing image packaging error. Cause:${error.message}`);
+      })
+    }
+  }
+
+  private createDataUri(mimeType: string, data: ArrayBuffer): string {
+    let uint8Array = new Uint8Array(data);
+    let base64Helper = new util.Base64Helper();
+    let base64Str = base64Helper.encodeToStringSync(uint8Array, util.Type.BASIC);
+    return `data:${mimeType};base64,${base64Str}`
+  }
+
+  private getPackingMimeType(mimeType: string): string {
+    let normalizedMimeType = mimeType.toLowerCase();
+    if (normalizedMimeType == "image/jpeg" || normalizedMimeType == "image/jpg") {
+      return "image/jpeg"
+    }
+    if (normalizedMimeType == "image/webp") {
+      return "image/webp"
+    }
+    return defaultImageMimeType
+  }
+
+  private isImageMimeType(mimeType: string): boolean {
+    return mimeType != undefined && mimeType.length > 0 && mimeType.toLowerCase().indexOf(imageMimePrefix) == 0
+  }
+
+  private isPixelMap(value: pasteboard.ValueType): boolean {
+    return value != undefined && typeof value == "object" && "getImageInfo" in value
+  }
+
+  setStrings(content: string[]) {
+    logger.debug(TAG, "[RNOH]:RNCClipboardTurboModule call setStrings fun");
+    let systemPasteboard = pasteboard.getSystemPasteboard();
+    systemPasteboard.clear().then(() => {
+      systemPasteboard.getData().then((pasteData) => {
+        while (content.length > 0) {
+          pasteData.addRecord(pasteboard.MIMETYPE_TEXT_PLAIN, content.pop())
+        }
+
+        // setData
+        systemPasteboard.setData(pasteData).then((data: void) => {
+          logger.debug(TAG, "setStrings,Succeeded in setting PasteData.");
+        }).catch((err) => {
+          logger.error(TAG, `setStrings,Failed to set PasteData. Cause:${err.message}`);
+        });
+      }).catch((err) => {
+        logger.error(TAG, `setStrings,getData error,Cause:${err.message}`);
+      })
+    }).catch((err: BusinessError) => {
+      console.error(`Failed to clear the PasteData. Cause: ${err.message}`);
+    });
+    return;
+  }
+
+  hasImage(): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "RNCClipboardTurboModule call hasImage");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          systemPasteboard.getData().then((pasteData) => {
+            let pixelMapObj = pasteData.getPrimaryPixelMap();
+            let result = false
+            if (pixelMapObj) {
+              logger.debug(TAG, "RNCClipboardTurboModule call hasImage,hasPixelobj");
+              result = true
+            }
+            resolve(result)
+          }).catch((err) => {
+            logger.error(TAG, `hasImage,Failed to get PasteData. Cause:${err.message}`);
+            reject(err)
+          })
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      });
+    });
+  }
+
+  hasURL(): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "RNCClipboardTurboModule call hasWebURL");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          systemPasteboard.getData().then((pasteData) => {
+            let count = pasteData.getRecordCount();
+            let result = false;
+            let isValidUrl = (string) => {
+              try {
+                url.URL.parseURL(string);
+                return true;
+              } catch (err) {
+                return false;
+              }
+            };
+            for (let index = 0; index < count; index++) {
+              let record = pasteData.getRecord(index);
+              if (record.mimeType == pasteboard.MIMETYPE_TEXT_URI) {
+                if (isValidUrl(record.uri)) {
+                  logger.debug(TAG, "hasURL,mimeType=MIMETYPE_TEXT_URI");
+                  result = true
+                  break
+                }
+              } else if (record.mimeType == pasteboard.MIMETYPE_TEXT_PLAIN) {
+                if (isValidUrl(record.plainText)) {
+                  logger.debug(TAG, "hasURL,find URL in MIMETYPE_TEXT_PLAIN");
+                  result = true
+                  break
+                }
+              }
+            }
+            resolve(result)
+          }).catch((err) => {
+            logger.error(TAG, `[RNOH]: hasURL,Failed to get PasteData. Cause:${err.message}`);
+            reject(err)
+          });
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      });
+    });
+  }
+
+  hasWebURL(): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      this.requestPermission().then(res => {
+        if (res) {
+          logger.debug(TAG, "RNCClipboardTurboModule call hasWebURL");
+          let systemPasteboard = pasteboard.getSystemPasteboard();
+          systemPasteboard.getData().then((pasteData) => {
+            let count = pasteData.getRecordCount();
+            let result = false
+            let reg = /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/;
+
+            for (let index = 0; index < count; index++) {
+              let record = pasteData.getRecord(index);
+              if (record.mimeType == pasteboard.MIMETYPE_TEXT_URI) {
+                if (reg.test(record.uri)) {
+                  logger.debug(TAG, "hasWebURL,find webURL in MIMETYPE_TEXT_URI");
+                  result = true
+                  break
+                }
+              } else if (record.mimeType == pasteboard.MIMETYPE_TEXT_PLAIN) {
+                if (reg.test(record.plainText)) {
+                  logger.debug(TAG, "hasWebURL,find webURL in MIMETYPE_TEXT_PLAIN");
+                  result = true
+                  break
+                }
+              }
+
+            }
+            resolve(result)
+          }).catch((err) => {
+            logger.error(TAG, `hasWebURL,Failed to get PasteData. Cause:${err.message}`);
+            reject(err)
+          });
+        } else {
+          reject({
+            code: 0,
+            message: "User refuses authorization"
+          })
+        }
+      });
+    });
+  }
+
+  requestPermission(): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+      abilityAccessCtrl.createAtManager()
+        .requestPermissionsFromUser(this.ctx.uiAbilityContext, PERMISSIONS).then(result => {
+        if (result.authResults[0] == 0) {
+          resolve(true);
+        } else {
+          logger.debug(TAG, `getString,text out:用户拒绝授权`);
+          resolve(false);
+        }
+      }).catch(() => {
+        logger.debug(TAG, `getString,text out:用户拒绝授权`);
+        resolve(false);
+      })
+    });
+  }
+
+  addListener(eventName: string): void {}
+  removeListeners(count: number): void {}
+}