HarmonyOS-两种PreferencesUtil实现方式

const TAG = "PreferencesUtil"
const PREFERENCES_NAME = 'graduation_preferences'
type ValueType = number | string | boolean | Array<number> | Array<string> | Array<boolean> | Uint8Array | object
  | bigint ;

export class PreferencesUtil {
  private static preferences: dataPreferences.Preferences
  private static preferencesAsync: Promise<dataPreferences.Preferences>

  private constructor() {
  }

  public static init(context: common.UIAbilityContext, name: string = PREFERENCES_NAME) {
    if (PreferencesUtil.preferences) return
    PreferencesUtil.preferences = dataPreferences.getPreferencesSync(context, { name })
    PreferencesUtil.preferencesAsync = dataPreferences.getPreferences(context, name).then(r => {
      return r
    })
  }

  private static async getPreferencesAsync(): Promise<dataPreferences.Preferences> {
    if (!(await PreferencesUtil.preferencesAsync)) {
      throw new Error('调用init()方法完成初始化')
    }
    return PreferencesUtil.preferencesAsync
  }


  private static getPreferences(): dataPreferences.Preferences {
    if (!PreferencesUtil.preferences) {
      throw new Error('调用init()方法完成初始化')
    }
    return PreferencesUtil.preferences
  }


  static async getAsync<T extends ValueType>(key: string, def?: ValueType): Promise<T> {
    const p = await PreferencesUtil.getPreferencesAsync()
    return new Promise<T>((resolve, reject) => {
      p.get(key, def, (err: BusinessError, data: dataPreferences.ValueType) => {
        if (err) {
          console.error(TAG,err)
          reject(def)
        }
        if (data) {
          resolve(data as T)
        }
      })
    })
  }


  static get<T extends ValueType>(key: string, def?: ValueType): T {
    try {
      return PreferencesUtil.getPreferences().getSync(key, def) as T
    } catch (err) {
      // Logger.et(TAG, e)
      console.error(TAG,err)
    }
    return def as T
  }



  static async getAllAsync(): Promise<Object> {
    let preferences = await PreferencesUtil.getPreferencesAsync()
    return preferences.getAll()
  }

  static getAll(): Object | null {
    try {
      return PreferencesUtil.getPreferences().getAllSync()
    } catch (err) {
      console.error(TAG,err)
    }
    return null

  }

  static async putAsync(key: string, value: ValueType): Promise<void> {
    const r = await PreferencesUtil.getPreferencesAsync().then(async (p) => {
      await p.put(key, value)
      await p.flush();
    }).catch((err: Error) => {
      console.error(TAG,err)
    })
    return r
  }


  static put(key: string, value: ValueType): void {
    try {
      PreferencesUtil.getPreferences().putSync(key, value)
      PreferencesUtil.getPreferences().flush()
    } catch (err) {
      console.error(TAG,err)
    }

  }

  static hasKey(key: string): boolean {
    let has: boolean = false
    try {
      has = PreferencesUtil.getPreferences().hasSync(key)
    } catch (err) {
      console.error(TAG,err)
    }
    return has
  }

  static async deleteAsync(key: string): Promise<void> {
    return (await PreferencesUtil.getPreferencesAsync()).delete(key)
      .catch((err: Error) => {
        console.error(TAG,err)
      })
      .finally(async () => {
        (await PreferencesUtil.getPreferencesAsync()).flush()
      })
  }

  static delete(key: string): void {
    try {
      PreferencesUtil.getPreferences().deleteSync(key)
      PreferencesUtil.getPreferences().flush()
    } catch (err) {
      console.error(TAG,err)
    }
  }

  static async clearAsync(): Promise<void> {
    return (await PreferencesUtil.getPreferencesAsync()).clear()
      .catch((err: Error) => {
        console.error(TAG,err)
      })
      .finally(async () => {
        (await PreferencesUtil.getPreferencesAsync()).flush()
      })
  }

  static clear(): void {
    try {
      PreferencesUtil.preferences.clearSync()
      PreferencesUtil.preferences.flush()
    } catch (err) {
      console.error(TAG,err)
    }
  }
}

const TAG = 'PreferencesUtil';
const MY_STORE = 'myStore';
const FORM_ID = 'formIds';

export class PreferencesUtil {
  private static preferencesUtil: PreferencesUtil;

  public static getInstance(): PreferencesUtil {
    if (!PreferencesUtil.preferencesUtil) {
      PreferencesUtil.preferencesUtil = new PreferencesUtil();
    }
    return PreferencesUtil.preferencesUtil;
  }

  getPreferences(context: Context): Promise<preferences.Preferences> {
    return new Promise((resolve, reject) => {
      preferences.getPreferences(context, MY_STORE, (err, pref: preferences.Preferences) => {
        if (err) {
          Logger.error(TAG, `Failed to get preferences. Code:${err.code},message:${err.message}`);
          reject(err);
          return;
        }
        resolve(pref);
      })
    })
  }

  preferencesFlush(preferences: preferences.Preferences) {
    preferences.flush((err) => {
      if (err) {
        Logger.error(TAG, `Failed to flush. Code:${err.code}, message:${err.message}`);
      }
    })
  }

  preferencesPut(preferences: preferences.Preferences, formIds: Array<string>): Promise<boolean> {
    return new Promise((resolve, reject) => {
      try {
        preferences.put(FORM_ID, formIds, (err) => {
          if (err) {
            reject(err);
            Logger.error(TAG, `Failed to put data. Code:${err.code}, message:${err.message}`);
            return;
          }
          Logger.info(TAG, `preferencesPut succeed,formIds: ${JSON.stringify(formIds)}`);
          resolve(true);
        })
      } catch (error) {
        Logger.error(TAG, `Failed to put data. Code: ${(error as BusinessError).code},
        message:${(error as BusinessError).message}`);
      }
    });
  }

  async preferencesHas(preferences: preferences.Preferences): Promise<boolean> {
    return new Promise((resolve, reject) => {
      preferences.has(FORM_ID, (err, value) => {
        if (err) {
          reject(err);
          Logger.error(TAG, `WANG to check the key 'formIds'. Code:${err.code}, message:${err.message}`);
          return;
        }
        resolve(value);
      });
    })
  }

  removePreferencesFromCache(context: Context): void {
    preferences.removePreferencesFromCache(context, MY_STORE);
  }

  async getFormIds(context: Context): Promise<Array<string>> {
    try {
      let preferences = await this.getPreferences(context);
      return new Promise((resolve, reject) => {
        if (preferences === null) {
          Logger.error(TAG, `preferences is null`);
          return;
        }
        preferences.get(FORM_ID, [''], (err: BusinessError, value: preferences.ValueType) => {
          if (err) {
            reject(err);
            Logger.error(TAG, `Failed to get value of 'formIds'. Code:${err.code}, message:${err.message}`);
            return;
          }
          resolve(value as Array<string>);
          Logger.info(TAG, `Succeeded in getting value of 'formIds'. val: ${value}.`);
        })
      })
    } catch (error) {
      Logger.error(TAG, `WANG Failed to get value of 'formIds'. Code:${(error as BusinessError).code},
       message:${(error as BusinessError).message}`);
    }
    return new Promise((resolve, reject) => {})
  }

  async addFormId(context: Context, formId: string) {
    try {
      let preferences = await this.getPreferences(context);
      if (preferences === null) {
        Logger.error(TAG, `preferences is null`);
        return;
      }

      if (await this.preferencesHas(preferences)) {
        let formIds = await this.getFormIds(context);
        if (formIds.indexOf(formId) === -1) {
          formIds.push(formId);
          if (!await this.preferencesPut(preferences, formIds)) {
            return;
          }
          this.preferencesFlush(preferences);
        }
      } else {
        if (!await this.preferencesPut(preferences, [formId])) {
          return;
        }
        this.preferencesFlush(preferences);
      }
    } catch (error) {
      Logger.error(TAG, `Failed to check the key 'formIds'. Code:${(error as BusinessError).code},
       message:${(error as BusinessError).message}`);
    }
  }

  async removeFormId(context: Context, formId: string) {
    try {
      let preferences = await this.getPreferences(context);
      if (preferences === null) {
        Logger.error(TAG, `preferences is null`);
        return;
      }
      if (await this.preferencesHas(preferences)) {
        let formIds = await this.getFormIds(context);
        let index = formIds.indexOf(formId);
        if (index !== -1) {
          formIds.splice(index, 1);
        }
        if (!await this.preferencesPut(preferences, formIds)) {
          return;
        }
        this.preferencesFlush(preferences);
      }
    } catch (error) {
      Logger.error(TAG, `WANG Failed to get preferences. Code:${(error as BusinessError).code},
      message:${(error as BusinessError).message}`);
    }
  }
}