ts
  // MoneyTrack/components/bill_data_processing/src/main/ets/utils/accountingdb/AccountingDB.ets
  const TAG = '[AccountingDB]';
  
  class AccountingDB extends BaseDB {
    protected dbConfig: relationalStore.StoreConfig =
      AccountingDBConstants.DB_CONFIG;
    protected tableSchemas: TableSchema[] = [
      {
        tableName: AccountingDBConstants.ACCOUNT_TABLE_NAME,
        createSQL: AccountingDBConstants.ACCOUNT_TABLE_SQL_CREATE,
        indexes: AccountingDBConstants.ACCOUNT_TABLE_INDEXES_CREATE,
      },
      {
        tableName: AccountingDBConstants.TRANSACTION_TABLE_NAME,
        createSQL: AccountingDBConstants.TRANSACTION_TABLE_SQL_CREATE,
        indexes: AccountingDBConstants.TRANSACTION_TABLE_INDEXES_CREATE,
      },
      {
        tableName: AccountingDBConstants.ASSET_TABLE_NAME,
        createSQL: AccountingDBConstants.ASSET_TABLE_SQL_CREATE,
        indexes: AccountingDBConstants.ASSET_TABLE_INDEXES_CREATE,
      },
    ];
  
    public async initialize(context: Context) {
      await super.initialize(context);
      await this._initDefaultAccounts();
    }
  
    // 初始化账本
    private async _initDefaultAccounts() {
      const accountTable: AccountTableBasis = {
        accountId: AccountID.DEFAULT,
        name: '默认账本',
        type: 'default',
      };
      const existing = await this.query<Account>(
        AccountingDBConstants.ACCOUNT_TABLE_NAME,
        [
          {
            field: AccountTableFields.NAME,
            operator: DBOperator.EQUAL,
            value: accountTable.name,
          },
          {
            field: AccountTableFields.TYPE,
            operator: DBOperator.EQUAL,
            value: accountTable.type,
          },
        ],
      );
  
      if (existing.length === 0) {
        await this.insert(AccountingDBConstants.ACCOUNT_TABLE_NAME, accountTable);
        Logger.info(TAG, 'create account table success');
      }
    }
  
    // 新增交易记录
    public async addTransaction(userTx: UserTransaction): Promise<void> {
      const tx: TransactionTableBasis = {
        transactionId: new Date().getTime(),
        accountId: userTx.accountId,
        type: userTx.type,
        resource: userTx.resource,
        amount: userTx.amount,
        date: userTx.date,
        note: userTx.note,
        excluded: userTx.excluded,
        assetId: userTx.assetId,
      };
      return this.transaction(async () => {
        try {
          await this.insert(AccountingDBConstants.TRANSACTION_TABLE_NAME, tx);
          promptAction.showToast({ message: '交易记录新增成功~' });
          await this.updateAssetAccountFromTransaction(userTx);
          Logger.info(TAG, 'insert transaction success.');
        } catch (err) {
          promptAction.showToast({ message: '交易记录新增失败，请稍后重试~' });
          Logger.error(
            TAG,
            'insert transaction failed. error:' + JSON.stringify(err),
          );
        }
      });
    }
  	// ...
  }
  
  const accountingDB = new AccountingDB();
  
  export { accountingDB as AccountingDB };

ts
  // MoneyTrack/products/entry/src/main/ets/common/WidgetUtil.ets
  import { preferences } from '@kit.ArkData';
  import { BusinessError, commonEventManager } from '@kit.BasicServicesKit';
  import { formBindingData, formProvider } from '@kit.FormKit';
  import { AmountSummary, BillProcessingModel } from 'bill_data_processing';
  import { Logger } from 'commonlib';
  
  const TAG = '[WidgetUtil]';
  
  export class WidgetUtil {
    private static readonly _fileName: string = 'accounting_form_id_file';
    private static readonly _formIdKey: string = 'accounting_form_id_key';
    private static readonly _formIdEventName: string = 'form_id_event_name';
    private static _billProcessing: BillProcessingModel =
      new BillProcessingModel();
  
    public static getFormIds(ctx: Context) {
      const store = WidgetUtil._getStore(ctx);
      return store.getSync(WidgetUtil._formIdKey, []) as string[];
    }
  
    public static async addFormId(formId: string, cxt: Context) {
      const list = WidgetUtil.getFormIds(cxt);
      if (!list.some((id) => id === formId)) {
        list.push(formId);
        const store = WidgetUtil._getStore(cxt);
        store.putSync(WidgetUtil._formIdKey, list);
        await store.flush();
      }
    }
  
    public static async delFormId(formId: string, cxt: Context) {
      const list = WidgetUtil.getFormIds(cxt);
      const index = list.findIndex((id) => id === formId);
      if (index !== -1) {
        list.splice(index, 1);
        const store = WidgetUtil._getStore(cxt);
        store.putSync(WidgetUtil._formIdKey, list);
        await store.flush();
      }
    }
  
    // 发布公共事件跨进程传递卡片id
    public static publishFormId(formId: string, isDelete: boolean) {
      commonEventManager.publish(
        WidgetUtil._formIdEventName,
        { data: formId, parameters: { isDelete } },
        (err: BusinessError) => {
          if (err) {
            Logger.error(
              TAG,
              `Failed to publish common event. Code is ${err.code}, message is ${err.message}`,
            );
          } else {
            Logger.info(TAG, 'Succeeded in publishing common event.');
          }
        },
      );
    }
  
    // 订阅获取卡片id
    public static async subscribeFormId(ctx: Context) {
      let subscriber: commonEventManager.CommonEventSubscriber | undefined =
        undefined;
      let subscribeInfo: commonEventManager.CommonEventSubscribeInfo = {
        events: [WidgetUtil._formIdEventName],
        publisherPermission: '',
      };
      commonEventManager.createSubscriber(subscribeInfo, (err1, data1) => {
        if (err1) {
          Logger.error(
            TAG,
            `Failed to create subscriber. Code is ${err1.code}, message is ${err1.message}`,
          );
          return;
        }
        subscriber = data1;
        // 订阅公共事件回调
        commonEventManager.subscribe(subscriber, async (err2, data2) => {
          if (err2) {
            Logger.error(
              TAG,
              `Failed to subscribe common event. Code is ${err2.code}, message is ${err2.message}`,
            );
            return;
          } else {
            if (data2.parameters?.isDelete) {
              WidgetUtil.delFormId(data2.data as string, ctx);
            } else {
              WidgetUtil.addFormId(data2.data as string, ctx);
              WidgetUtil.updateWidgetsWhenChange();
            }
            Logger.info(TAG, 'Succeeded in creating subscriber1.');
          }
        });
      });
    }
  
    public static async updateWidgetsWhenChange() {
      await WidgetUtil._billProcessing.getBillReport();
      const summary: AmountSummary = {
        totalExpense: Number(WidgetUtil._billProcessing.totalExpense),
        totalIncome: Number(WidgetUtil._billProcessing.totalIncome),
      };
      WidgetUtil.getFormIds(getContext()).forEach((id) => {
        const income = summary.totalIncome;
        const expense = summary.totalExpense;
        class TempForm {
          date: Date = new Date();
          income: number = 0;
          expense: number = 0;
        }
        const formData: TempForm = {
          date: new Date(),
          income,
          expense,
        };
        formProvider.updateForm(
          id,
          formBindingData.createFormBindingData(formData),
        );
      });
    }
  
    private static _getStore(ctx: Context) {
      return preferences.getPreferencesSync(ctx, { name: WidgetUtil._fileName });
    }
  }

ts
  // MoneyTrack/products/entry/src/main/ets/entryformability/EntryFormAbility.ets
  import { Want } from '@kit.AbilityKit';
  import { emitter } from '@kit.BasicServicesKit';
  import { formBindingData, FormExtensionAbility, formInfo } from '@kit.FormKit';
  import { WidgetUtil } from '../common/WidgetUtil';
  
  export default class EntryFormAbility extends FormExtensionAbility {
    public onAddForm(want: Want) {
      let formId = want.parameters?.[formInfo.FormParam.IDENTITY_KEY] as string | undefined;
      if (formId) {
        WidgetUtil.addFormId(formId, this.context);
        WidgetUtil.publishFormId(formId, false);
      }
      return formBindingData.createFormBindingData('');
    }
  
    public onUpdateForm() {
      emitter.emit({ eventId: 1 });
    }
  
    public onRemoveForm(formId: string) {
      WidgetUtil.delFormId(formId, this.context);
      WidgetUtil.publishFormId(formId, true);
    }
  }