DEV Community

Cover image for Advanced usage of preference data caching
liu yang
liu yang

Posted on

Advanced usage of preference data caching

#harmonyosnext

Advanced Preference Data Caching Techniques

PreferencesUtil Tool Class Implementation 

import Logger from './Logger';
import common from '@ohos.app.ability.common';
import { preferences } from '@kit.ArkData';

let preference: preferences.Preferences | undefined = undefined;
const context = getContext(this) as common.UIAbilityContext;

export class PreferencesUtil {
  private readonly TAG: string = 'PreferencesUtil';

  writeString(key: string, value?: string) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.putSync(key, value);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  readString(key: string, defaultValue?: string): string | undefined {
    if (preference === undefined) {
      this.getPreferences();
    }
    let value: preferences.ValueType | undefined = undefined;
    try {
      value = preference!!.getSync(key, defaultValue);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    return value as string | undefined;
  }

  writeArrayString(key: string, value?: Array<string>) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.putSync(key, value);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  readArrayString(key: string, defaultValue?: Array<string>): Array<string> | undefined {
    if (preference === undefined) {
      this.getPreferences();
    }
    let value: preferences.ValueType | undefined = undefined;
    try {
      value = preference!!.getSync(key, defaultValue);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    return value as Array<string> | undefined;
  }

  writeNumber(key: string, value?: number) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.putSync(key, value);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  readNumber(key: string, defaultValue?: number): number | undefined {
    if (preference === undefined) {
      this.getPreferences();
    }
    let value: preferences.ValueType | undefined = undefined;
    try {
      value = preference!!.getSync(key, defaultValue);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    return value as number | undefined;
  }

  writeArrayNumber(key: string, value?: Array<number>) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.putSync(key, value);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  readArrayNumber(key: string, defaultValue?: Array<number>): Array<number> | undefined {
    if (preference === undefined) {
      this.getPreferences();
    }
    let value: preferences.ValueType | undefined = undefined;
    try {
      value = preference!!.getSync(key, defaultValue);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    return value as Array<number> | undefined;
  }

  writeBoolean(key: string, value?: boolean) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.putSync(key, value);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  readBoolean(key: string, defaultValue?: boolean): boolean | undefined {
    if (preference === undefined) {
      this.getPreferences();
    }
    let value: preferences.ValueType | undefined = undefined;
    try {
      value = preference!!.getSync(key, defaultValue);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    return value as boolean | undefined;
  }

  writeArrayBoolean(key: string, value?: Array<boolean>) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.putSync(key, value);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  readArrayBoolean(key: string, defaultValue?: Array<boolean>): Array<boolean> | undefined {
    if (preference === undefined) {
      this.getPreferences();
    }
    let value: preferences.ValueType | undefined = undefined;
    try {
      value = preference!!.getSync(key, defaultValue);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    return value as Array<boolean> | undefined;
  }

  writeObject<T>(key: string, value?: T) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.putSync(key, value);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  readObject<T>(key: string): T | undefined {
    if (preference === undefined) {
      this.getPreferences();
    }
    let value: preferences.ValueType | undefined = undefined;
    try {
      value = preference!!.getSync(key, undefined);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    return value as T | undefined;
  }

  delete(key: string) {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.deleteSync(key);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  clear() {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.clearSync();
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference!!.flush();
  }

  flush() {
    if (preference === undefined) {
      this.getPreferences();
    }
    try {
      preference!!.flush();
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
  }

  private getPreferences() {
    try {
      const options: preferences.Options = { name: 'myStore' };
      preference = preferences.getPreferencesSync(context, options);
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
  }

  private deletePreferences() {
    try {
      if (preference) {
        preference.deleteSync('myStore');
      }
    } catch (e) {
      Logger.error(`${this.TAG}, cause: ${e}`);
    }
    preference = undefined;
  }
}

export default new PreferencesUtil();
Enter fullscreen mode Exit fullscreen mode

Adding Data 

addUserInfo() {
  const getid: number | undefined = PreferencesUtil.readNumber("id", 0);
  if (this.account !== '' && this.password !== '' && getid !== undefined) {
    const contentdata: UserInfo = {
      username: this.account,
      password: this.password,
      id: getid,
    };
    this.userdatalist.push(contentdata);
    getid++;
    PreferencesUtil.writeString("userdata", JSON.stringify(this.userdatalist));
    PreferencesUtil.writeNumber("id", getid);
    this.showToast("Data storage succeeded");
  } else {
    this.showToast("Input data cannot be empty");
  }
}
Enter fullscreen mode Exit fullscreen mode

Querying Data 

queryUserInfo() {
  const getdatajson: string | undefined = PreferencesUtil.readString("userdata", '');
  if (getdatajson !== undefined && getdatajson !== '') {
    this.getdatalist = JSON.parse(getdatajson) as UserInfo[];
    this.uidatalist = this.getdatalist;
    this.showToast("Data query succeeded");
  } else {
    this.showToast("No cached data locally");
  }
}
Enter fullscreen mode Exit fullscreen mode

Updating Data 

updateUserInfo() {
  const getdatajson: string | undefined = PreferencesUtil.readString("userdata", '');
  if (getdatajson !== undefined && getdatajson !== '') {
    let getdatalist: UserInfo[] = JSON.parse(getdatajson) as UserInfo[];
    for (let index = 0; index < getdatalist.length; index++) {
      const userinfo: UserInfo = getdatalist[index];
      if (index === 2) {
        const contentdata: UserInfo = {
          username: "Updated Account 17387272",
          password: "Updated Password 13432332",
          id: userinfo.id,
        };
        getdatalist[index] = contentdata;
        PreferencesUtil.writeString("userdata", JSON.stringify(getdatalist));
        this.showToast("Data update succeeded");
        break;
      }
    }
  } else {
    this.showToast("No cached data locally");
  }
}
Enter fullscreen mode Exit fullscreen mode

Deleting Data 

deleteUserInfo(deletedata: number) {
  const getdatajson: string | undefined = PreferencesUtil.readString("userdata", '');
  if (getdatajson !== undefined && getdatajson !== '') {
    this.getdatalist = JSON.parse(getdatajson) as UserInfo[];
    for (let index = 0; index < this.getdatalist.length; index++) {
      const userinfo: UserInfo = this.getdatalist[index];
      if (userinfo.id === deletedata) {
        this.getdatalist.splice(index, 1);
        PreferencesUtil.writeString("userdata", JSON.stringify(this.getdatalist));
        this.showToast("Data deletion succeeded");
        break;
      }
    }
  } else {
    this.showToast("No cached data locally");
  }
}
Enter fullscreen mode Exit fullscreen mode

Top comments (0)