store paste data text into rdb

Author: WhiredPlanck

entry/oh-package-lock.json5

@@ -6,6 +6,7 @@
   "author": "",
   "license": "",
   "dependencies": {
-    "libentry.so": "file:./src/main/cpp/types/libentry"
+    "libentry.so": "file:./src/main/cpp/types/libentry",
+    "@liushengyi/smartdb": "^4.0.1"
   }
 }

entry/oh-package.json5

@@ -1,30 +1,89 @@
 import { Context } from '@kit.AbilityKit'
 import { BusinessError, pasteboard } from '@kit.BasicServicesKit'
+import sql from '@liushengyi/smartdb'
+import { PasteboardDao } from './PasteboardDao'
+import { PasteboardDatabase } from './PasteboardDatabase'
+import { PasteboardEntry } from './PasteboardEntry'
+import { HashSet } from '@kit.ArkTS'
+import { StrUtil } from '../../../utils/StrUtil'
 
 const systemPasteboard: pasteboard.SystemPasteboard = pasteboard.getSystemPasteboard()
 
+export interface OnPasteboardUpdateListener {
+  onUpdate(entry: PasteboardEntry): void
+}
+
 export class PasteboardController {
+  private psbDao: PasteboardDao | null = null
+
   constructor() {
   }
-  
+
+  private onUpdateListeners = new HashSet<OnPasteboardUpdateListener>()
+
+  public addOnUpdateListener(listener: OnPasteboardUpdateListener): void {
+    this.onUpdateListeners.add(listener)
+  }
+
+  public removeOnUpdateListener(listener: OnPasteboardUpdateListener): void {
+    this.onUpdateListeners.remove(listener)
+  }
+
+  public lastEntry: PasteboardEntry | null = null
+
+  private updateLastEntry(entry: PasteboardEntry): void {
+    this.lastEntry = entry
+    this.onUpdateListeners.forEach((listener) => {
+      listener?.onUpdate(entry)
+    })
+  }
+
   public onCreate(context: Context): void {
     console.debug('onCreate')
+    PasteboardDatabase.init(context)
+    this.psbDao = new PasteboardDao()
     systemPasteboard.on('update', this.onSystemPasteboardUpdate)
   }
-  
+
   public onDestroy(): void {
     console.debug('onDestroy')
     systemPasteboard.off('update', this.onSystemPasteboardUpdate)
   }
-  
+
+  @sql.Transactional()
+  private async insertEntry(entry: PasteboardEntry): Promise<PasteboardEntry> {
+    const rowId = await this.psbDao!.insert(entry)
+    if (!rowId) {
+      return entry
+    }
+    const inserted = await this.psbDao!.get(rowId)
+    return inserted ? inserted : entry
+  }
+
   public onSystemPasteboardUpdate(): void {
-    systemPasteboard.getData((err: BusinessError, data: pasteboard.PasteData) => {
+    systemPasteboard.getData(async (err: BusinessError, data: pasteboard.PasteData) => {
       if (err) {
         console.error(`Failed to get paste data: ${err.message}`)
         return
       }
-      const text = data.getPrimaryText()
-      console.debug(`get primary text: ${text}`)
+      const entry = PasteboardEntry.fromPasteData(data)
+      if (!entry || StrUtil.isBlank(entry.text)) {
+        return
+      }
+      try {
+        const existed = await pasteboardController.psbDao!.find(entry.text, entry.sensitive)
+        if (existed) {
+          await pasteboardController.psbDao!.updateTime(existed.id, entry.timestamp)
+        } else {
+          const insertedEntry = await pasteboardController.insertEntry(entry)
+          console.debug('get entry text: ' + insertedEntry.text)
+          pasteboardController.updateLastEntry(insertedEntry)
+        }
+      } catch (e) {
+        const error = e as Error
+        console.warn(`Failed to update clipboard database: ${error.message}`)
+        pasteboardController.updateLastEntry(entry)
+      }
     })
   }
 }

entry/src/main/ets/InputMethodExtensionAbility/model/pasteboard/PasteboardController.ets

@@ -0,0 +1,32 @@
+import sql from '@liushengyi/smartdb';
+import { PasteboardEntry } from './PasteboardEntry';
+
+export class PasteboardDao {
+  constructor() {
+  }
+
+  @sql.SqlInsert(`INSERT OR ABORT INTO ${PasteboardEntry.TABLE_NAME} (text, pinned, timestamp, type, deleted, sensitive)
+  VALUES (#{entry.text}, #{entry.pinned}, #{entry.timestamp}, #{entry.type}, #{entry.deleted}, #{entry.sensitive})`,
+  { table: PasteboardEntry.TABLE_NAME, id: 'id' })
+  insert(@sql.Param('entry') entry: PasteboardEntry): Promise<number> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlUpdate(`UPDATE ${PasteboardEntry.TABLE_NAME} SET timestamp=#{timestamp} WHERE id=#{id}`)
+  updateTime(@sql.Param('id') id: number, @sql.Param('timestamp') timestamp: number): Promise<void> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlQuery(`SELECT * FROM ${PasteboardEntry.TABLE_NAME} WHERE rowId=#{rowId} AND deleted=0 LIMIT 1`)
+  @sql.ReturnType(PasteboardEntry)
+  get(@sql.Param('rowId') rowId: number): Promise<PasteboardEntry> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlQuery(`SELECT * FROM ${PasteboardEntry.TABLE_NAME} WHERE text=#{text} AND sensitive=#{sensitive} AND deleted=0 LIMIT 1`)
+  @sql.ReturnType(PasteboardEntry)
+  find(@sql.Param('text') text: string,
+    @sql.Param('sensitive') sensitive: boolean = false): Promise<PasteboardEntry> {
+    return sql.PromiseNull()
+  }
+}

entry/src/main/ets/InputMethodExtensionAbility/model/pasteboard/PasteboardDao.ets

@@ -0,0 +1,29 @@
+import sql from '@liushengyi/smartdb';
+import relationalStore from '@ohos.data.relationalStore';
+
+export class PasteboardDatabase {
+  static VERSION = 1
+
+  static init(context: Context): void {
+    sql.dbHelper.initDb(context, 'clbdb', PasteboardDatabase.VERSION, new PasteboardDbOpenHelper())
+  }
+}
+
+class PasteboardDbOpenHelper extends sql.DbOpenHelper {
+  constructor() {
+    super()
+  }
+
+  override onCreate(db: relationalStore.RdbStore): void {
+    db.executeSync("CREATE TABLE IF NOT EXISTS clipboard (" +
+      "id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
+      "text TEXT NOT NULL, " +
+      "pinned INTEGER NOT NULL, timestamp INTEGER NOT NULL DEFAULT -1, " +
+      "type TEXT NOT NULL DEFAULT 'text/plain', " +
+      "deleted INTEGER NOT NULL DEFAULT 0, " +
+      "sensitive INTEGER NOT NULL DEFAULT 0)")
+  }
+
+  override onUpgrade(db: relationalStore.RdbStore, oldVersion: number, newVersion: number): void {
+  }
+}

entry/src/main/ets/InputMethodExtensionAbility/model/pasteboard/PasteboardDatabase.ets

@@ -0,0 +1,35 @@
+import { pasteboard } from '@kit.BasicServicesKit';
+import sql from '@liushengyi/smartdb';
+
+export class PasteboardEntry {
+  static TABLE_NAME = 'clipboard'
+  @sql.SqlColumn(sql.ColumnType.INTEGER)
+  id: number = 0
+  @sql.SqlColumn(sql.ColumnType.TEXT)
+  text: string
+  @sql.SqlColumn(sql.ColumnType.INTEGER)
+  pinned: boolean = false
+  @sql.SqlColumn(sql.ColumnType.INTEGER)
+  timestamp: number = Date.now()
+  @sql.SqlColumn(sql.ColumnType.TEXT)
+  type: string = pasteboard.MIMETYPE_TEXT_PLAIN
+  @sql.SqlColumn(sql.ColumnType.INTEGER)
+  deleted: boolean = false
+  @sql.SqlColumn(sql.ColumnType.INTEGER)
+  sensitive: boolean = false
+
+  constructor(text: string) {
+    this.text = text
+  }
+
+  static fromPasteData(pasteData: pasteboard.PasteData): PasteboardEntry | undefined {
+    const prop = pasteData.getProperty()
+    const record = pasteData.getRecord(0)
+    const str = record.plainText
+    if (!str) return undefined
+    const newEntry = new PasteboardEntry(str)
+    newEntry.timestamp = prop.timestamp
+    newEntry.type = prop.mimeTypes[0]
+    return newEntry
+  }
+}

entry/src/main/ets/InputMethodExtensionAbility/model/pasteboard/PasteboardEntry.ets

@@ -0,0 +1,5 @@
+export namespace StrUtil {
+  export function isBlank(str: string): boolean {
+    return Array.from(str).every((ch) => ch.match(/\s/))
+  }
+}