HarmonyOS开发实例：【事件的订阅和发布】

最新推荐文章于 2024-07-03 15:53:18 发布
最新推荐文章于 2024-07-03 15:53:18 发布
阅读量1.4k 收藏 16
点赞数 25
分类专栏： 鸿蒙开发 文章标签： harmonyos typescript 鸿蒙开发 openharmony 鸿蒙系统 移动开发 程序员
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70748845/article/details/137789076
版权

介绍

本示例主要展示了公共事件相关的功能，实现了一个检测用户部分行为的应用。具体而言实现了如下几点功能：

1.通过订阅系统公共事件，实现对用户操作行为（亮灭屏、锁屏和解锁屏幕、断联网）的监测；

2.通过在用户主动停止监测行为时发布自定义有序公共事件，实现对用户主动触发监听行为的持久化记录；

3.通过在用户设置对某一事件的监听状态时发布粘性事件，记录下本次应用运行期间允许监听的事件列表，同时在应用退出时将临时允许的修改为不允许；

4.打开自定义订阅事件页面需先安装[CardEvent]应用，通过订阅指定应用事件，实现用户对指定卡片发送事件的监听。

效果预览

订阅系统公共事件，主动停止监听行为及对某一事件的监听状态时发布粘性事件

image.png

使用说明：鸿蒙开发文档参考了gitee.com/li-shizhen-skin/harmony-os/blob/master/README.md点击或者复制转到即可。

1.安装编译生成的hap包，依赖包hap，桌面上显示应用图标如下，点击图标即可进入应用。

image.png

2.进入应用显示菜单页，可选择“进入”，“历史”，“设置”及“关于”几个选项。

3.点击“进入”后跳转至主页面，点击主页面“开始监控”按钮，将开始监听系统公共事件，并进行计时，此时按钮内容变更为“停止监听”；点击停止监听按钮，页面上将显示本次监听时长及监听期间收到的干扰信息汇总，并在页面右下角显示“查看详情”按钮，点击按钮将跳转至详情页，显示监听期间收到的干扰信息，应用当前仅监听了亮灭屏、锁屏和解锁屏幕、断联网等用户可操作的系统公共事件，后续可根据需求快速扩展。

4.返回至应用菜单页面，点击“历史”可查看用户操作监听的历史记录，当前支持每次运行期间最多存储10条历史记录，超过10条后将删除历史数据。

5.返回至应用菜单页面，点击“设置”可进行具体系统事件的监听配置，应用提供了“一直”、“仅本次”及“从不”三个选项，其中“仅本次”选项是指本次应用运行期间将监听特定系统公共事件，应用退出后该选项将自动调整为“从不”。

6.在设置页面，点击“自定义事件定向订阅”进入订阅页面，

  • 点击”订阅“按钮进行订阅事件，同时订阅指定本应用事件和订阅非指定应用事件。
  • 点击应用内卡片发送事件或点击应用外卡片发送事件。
  • 点击应用内卡片发送事件后，指定应用事件和非指定应用事件均会接收到卡片所发送的事件 ；点击应用外卡片发送事件后，非指定应用事件会被接收，指定应用事件不会被接收。
  • 点击”取消订阅“ 页面中会提示当前事件取消订阅。

7.返回至应用菜单页面，点击“关于”可查看应用版本信息及本示例的说明。

搜狗高速浏览器截图20240326151547.png

代码解读

CustomCommonEvent

HarmonyOS与OpenHarmony开发文档+mau123789是v直接拿取
entry/src/main/ets/
|---Application
|   |---MyAbilityStage.ts                    
|---component
|   |---Header.ets                           // 头部组件
|---entryformability
|   |---EntryFormAbility.ts                  // 卡片提供方  
|---feature
|   |---HistoryFeature.ts                    
|   |---LaunchFeature.ts                    
|   |---MainFeature.ts                    
|   |---SettingFeature.ts                    
|---LauncherAbility 
|   |---LauncherAbility.ts
|---MainAbility
|   |---MainAbility.ts
|---model
|   |---Consts.ts                            // 数据定义
|   |---Logger.ts                            // 日志打印  
|   |---SurveillanceEventsManager.ts         // 公共事件模块
|   |---Utils.ts                        
|---pages
|   |---About.ets                            // 关于页面
|   |---Detail.ets                           // 详情页面
|   |---History.ets                          // 历史页面
|   |---jumpToCommonEvent.ets                // 自定义订阅事件页面
|   |---Launch.ets                           // 发起页面
|   |---Main.ets                             // 进入页面
|   |---Setting.ets                          // 设置页面
|---publishcard
|   |---pages
|   |	|---PublishCard.ets              	 // 卡片页面

CustomCommonEventRely

entry/src/main/ets/
|---entryformability
|   |---EntryFormAbility.ts					// 发布事件
|---pages
|   |---Index.ets
|---widget
|   |---pages
|   |	|---PublishCard.ets 				// 发布事件的卡片

具体实现

  • 该示例entry部分分为五个模块：

    • 进入模块

      • 使用到应用文上下文，createSubscriber方法创建订阅者，getCurrentTime获取获取自Unix纪元以来经过的时间进行对用户操作行为的监测功能页面开发。

  • 源码链接：[Consts.ts]

/*

 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import commonEvent from '@ohos.commonEventManager';



export default class consts {

  // definition for database

  static readonly DATA_BASE_NAME: string = "nothing_pre";

  static readonly DATA_BASE_KEY_TOTAL_TIMES: string = "totalTimes";

  static readonly DATA_BASE_KEY_START_TIME: string = "startTime";

  static readonly DATA_BASE_KEY_WIFI_POWER_STATE: string = commonEvent.Support.COMMON_EVENT_WIFI_POWER_STATE;

  static readonly DATA_BASE_KEY_SCREEN_OFF: string = commonEvent.Support.COMMON_EVENT_SCREEN_OFF;

  static readonly DATA_BASE_KEY_SCREEN_ON: string = commonEvent.Support.COMMON_EVENT_SCREEN_ON;

  static readonly DATA_BASE_KEY_SCREEN_LOCKED: string = commonEvent.Support.COMMON_EVENT_SCREEN_LOCKED;

  static readonly DATA_BASE_KEY_SCREEN_UNLOCKED: string = commonEvent.Support.COMMON_EVENT_SCREEN_UNLOCKED;

  static readonly DATA_BASE_KEY_ONCE_EVENTS: string = "onceCall";

  static readonly DATA_BASE_KEY_NEVER_EVENTS: string = "neverCall";



  // definition for event enable state

  static readonly ENABLE_STATE_ALWAYS : number = 0

  static readonly ENABLE_STATE_ONCE : number = 1

  static readonly ENABLE_STATE_NEVER : number = 2



  // definition for record volume

  static readonly MAX_RECORD_NUM: number = 10;



  // definition for self defined common events

  static readonly COMMON_EVENT_FINISH_MEDITATION: string = "finish_meditation"

  static readonly COMMON_EVENT_SETTING_UPDATE: string = "setting_update"

}

[LaunchFeature.ts]

/*

 * Copyright (c) 2024 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import common from '@ohos.app.ability.common';

import commonEvent from '@ohos.commonEventManager';

import dataPreferences from '@ohos.data.preferences';

import Want from '@ohos.app.ability.Want';

import router from '@ohos.router';

import consts from '../module/Consts';

import Logger from '../module/Logger';



export default class LaunchFeature {

  private innerContext: common.UIAbilityContext = null;

  private pref: dataPreferences.Preferences = null;

  private subscriber = null;

  private subscriberLow = null;

  private currentRecordTimes: number = 0;



  constructor(abilityContext: common.UIAbilityContext) {

    this.innerContext = abilityContext;

  }



  async init(): Promise<void> {

    await dataPreferences.getPreferences(this.innerContext, consts.DATA_BASE_NAME).then((pref) => {

      this.pref = pref;

    });

    await this.pref.get(consts.DATA_BASE_KEY_WIFI_POWER_STATE, 0).then((value: number) => {

      globalThis.settings.set(commonEvent.Support.COMMON_EVENT_WIFI_POWER_STATE, value);

    });

    await this.pref.get(consts.DATA_BASE_KEY_SCREEN_OFF, 0).then((value1: number) => {

      globalThis.settings.set(commonEvent.Support.COMMON_EVENT_SCREEN_OFF, value1);

    });

    await this.pref.get(consts.DATA_BASE_KEY_SCREEN_ON, 0).then((value2: number) => {

      globalThis.settings.set(commonEvent.Support.COMMON_EVENT_SCREEN_ON, value2);

    });

    await this.pref.get(consts.DATA_BASE_KEY_SCREEN_LOCKED, 0).then((value3: number) => {

      globalThis.settings.set(commonEvent.Support.COMMON_EVENT_SCREEN_LOCKED, value3);

    });

    await this.pref.get(consts.DATA_BASE_KEY_SCREEN_UNLOCKED, 0).then((value4: number) => {

      globalThis.settings.set(commonEvent.Support.COMMON_EVENT_SCREEN_UNLOCKED, value4);

    });

  }



  private insertRecord = (event, value) => {

    value.push(event.parameters[consts.DATA_BASE_KEY_START_TIME]);

    // refresh database

    this.pref.put(consts.DATA_BASE_KEY_TOTAL_TIMES, value).then(() => {

      let detail: Array<string> = [];

      detail.push(event.parameters["startTime"]);

      detail.push(event.parameters["endTime"]);

      detail.push(event.parameters["totalTime"]);

      detail.push(event.parameters["totalEvents"]);

      this.pref.put(event.parameters[consts.DATA_BASE_KEY_START_TIME], detail).then(() => {

        this.pref.flush()

      })

    });

  }



  private callbackFunc = (error, event) => {

    this.pref.has(consts.DATA_BASE_KEY_TOTAL_TIMES, (err, ret) => {

      if (ret) {

        this.pref.get(consts.DATA_BASE_KEY_TOTAL_TIMES, []).then((value) => {

          this.insertRecord(event, value);

        });

      } else {

        let value: Array<string> = [];

        this.insertRecord(event, value);

      }

      if (this.currentRecordTimes >= consts.MAX_RECORD_NUM) {

        this.subscriber.finishCommonEvent();

        return;

      }

      this.subscriber.abortCommonEvent();

      this.subscriber.finishCommonEvent();

      this.currentRecordTimes++;

    })

  }



  private callbackLowFunc = (error, event) => {

    this.currentRecordTimes = 1;

    this.pref.get(consts.DATA_BASE_KEY_TOTAL_TIMES, []).then((value: Array<string>) => {

      for (let i = 0; i < consts.MAX_RECORD_NUM; i++) {

        this.pref.delete(value[i]).then(() => {

          this.pref.flush();

          this.subscriberLow.finishCommonEvent();

        })

      }

      let records = value.slice(consts.MAX_RECORD_NUM, consts.MAX_RECORD_NUM + 1);

      this.pref.put(consts.DATA_BASE_KEY_TOTAL_TIMES, records);

      this.pref.flush();

    })

  }



  jumpToStart = () => {

    // subscribe

    if (this.subscriber == null) {

      let highSubscriberInfo = {

        events: [

          consts.COMMON_EVENT_FINISH_MEDITATION // unordered self defined event

        ],

        priority: 2 // 2 indicates high priority subscriber

      };

      commonEvent.createSubscriber(highSubscriberInfo, (err, subscriber) => {

        this.subscriber = subscriber

        if (subscriber != null) {

          commonEvent.subscribe(subscriber, this.callbackFunc)

        }

      });

    }

    // subscribe

    if (this.subscriberLow == null) {

      let lowSubscriberInfo = {

        events: [

          consts.COMMON_EVENT_FINISH_MEDITATION // unordered self defined event

        ],

        priority: 1 // 1 indicates low priority subscriber

      };

      commonEvent.createSubscriber(lowSubscriberInfo, (updaerr, subscriber) => {

        this.subscriberLow = subscriber

        if (subscriber != null) {

          commonEvent.subscribe(subscriber, this.callbackLowFunc)

        }

      });

    }

    let want = {

      bundleName: 'com.samples.customcommonevent',

      abilityName: 'MainAbility',

    };

    this.innerContext.startAbility(want);

  }



  jumpToHistory = () => {

    Logger.info("ready to jump to history page");

    router.pushUrl({

      url: 'pages/History',

      params: {}

    });

  }



  jumpToSetting = () => {

    Logger.info("ready to jump to setting page");

    router.pushUrl({

      url: 'pages/Setting',

      params: {}

    });

  }



  jumpToAbout = () => {

    Logger.info("ready to jump to about page");

    router.pushUrl({

      url: 'pages/About',

      params: {}

    });

  }



  jumpToCommonEvent = (): void => {

    Logger.info('ready to jump to commonEvent page');

    let context: common.UIAbilityContext | undefined = AppStorage.get('context');

    let want: Want = {

      bundleName: "com.samples.cardevent",

      abilityName: "EntryAbility",

    };

    context && context.startAbility(want,  (err) => {

      if (err.code) {

        Logger.error('StartAbility', `Failed to startAbility. Code: ${err.code}, message: ${err.message}`);

      }

    });

  };

}

[LauncherAbility.ts]

/*

 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import UIAbility from '@ohos.app.ability.UIAbility';

import commonEvent from '@ohos.commonEventManager';

import consts from '../module/Consts';

import dataPreferences from '@ohos.data.preferences';

import surveillanceEventsManager from '../module/SurveillanceEventsManager';

import Logger from '../module/Logger';



export default class LauncherAbility extends UIAbility {

  onCreate(want) {

    globalThis.abilityWant = want;

    let settings: Map<string, number> = new Map();

    surveillanceEventsManager.surveillanceEvents.forEach((element: string) => {

      settings.set(element, consts.ENABLE_STATE_ALWAYS);

    });

    globalThis.settings = settings;

    AppStorage.setOrCreate('context', this.context);

    Logger.info(`LauncherAbility onCreate, settings.size = ${globalThis.settings.size}`)

  }



  async onDestroy() {

    Logger.info("LauncherAbility onDestroy")

    globalThis.settings.forEach((value: number, key: string) => {

      if (value == consts.ENABLE_STATE_ONCE) {

        globalThis.settings.set(key, consts.ENABLE_STATE_NEVER);

      }

    });

    let thisPref = null;

    await dataPreferences.getPreferences(this.context, consts.DATA_BASE_NAME).then((pref) => {

      thisPref = pref;

    });

    for (let element of surveillanceEventsManager.surveillanceEvents) {

      await thisPref.put(element, globalThis.settings.get(element));

    };

    await thisPref.flush();

    let options = {

      isSticky: true,

      parameters: surveillanceEventsManager.getSurveillanceEventStates()

    };

    commonEvent.publish(consts.COMMON_EVENT_SETTING_UPDATE, options, () => {

      Logger.info("success to publish once enable event");

    });

  }



  onWindowStageCreate(windowStage) {

    // Main window is created, set main page for this ability

    windowStage.loadContent("pages/Launch", (err, data) => {

      if (err.code) {

        Logger.error('Failed to load the content. Cause:' + JSON.stringify(err));

        return;

      }

      Logger.info('Succeeded in loading the content. Data: ' + JSON.stringify(data));

    });

  }



  onWindowStageDestroy() {

    // Main window is destroyed, release UI related resources

    Logger.info("LauncherAbility onWindowStageDestroy");

  }



  onForeground() {

    // Ability has brought to foreground

    Logger.info("LauncherAbility onForeground");

  }



  onBackground() {

    // Ability has back to background

    Logger.info("LauncherAbility onBackground");

  }

}

[SurveillanceEventsManager.ts]

/*

 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import commonEvent from '@ohos.commonEventManager';



export class EventData {

  "usual.event.wifi.POWER_STATE": number;

  "usual.event.SCREEN_OFF": number;

  "usual.event.SCREEN_ON": number;

  "usual.event.SCREEN_LOCKED": number;

  "usual.event.SCREEN_UNLOCKED": number;

}



export default class SurveillanceEventsManager {

  constructor() {

  }



  static getSurveillanceEventStates(): EventData {

    return {

      "usual.event.wifi.POWER_STATE": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_WIFI_POWER_STATE),

      "usual.event.SCREEN_OFF": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_OFF),

      "usual.event.SCREEN_ON": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_ON),

      "usual.event.SCREEN_LOCKED": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_LOCKED),

      "usual.event.SCREEN_UNLOCKED": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_UNLOCKED)

    }

  }



  static surveillanceEvents: Array<string> = [

  commonEvent.Support.COMMON_EVENT_WIFI_POWER_STATE,

  commonEvent.Support.COMMON_EVENT_SCREEN_OFF,

  commonEvent.Support.COMMON_EVENT_SCREEN_ON,

  commonEvent.Support.COMMON_EVENT_SCREEN_LOCKED,

  commonEvent.Support.COMMON_EVENT_SCREEN_UNLOCKED,

  ]

}

  • 参考接口：[@ohos.app.ability.common]，[@ohos.commonEventManager]，[@ohos.data.preferences]，[@ohos.commonEvent]，[@ohos.router]，[@ohos.systemTime]

    • 历史模块

      • 使用到应用文上下文，getPreferences方法获取Preferences实例，组件Header进行历史页面开发。

  • 源码链接：[Header.ets]

/*

 * Copyright (c) 2022 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import router from '@ohos.router'



@Component

export struct Header {

  @State src: string = ''



  build() {

    Column() {

    }

    .backgroundImage($rawfile(this.src))

    .backgroundImageSize(ImageSize.Cover)

    .position({ x: '2%', y: '2%' })

    .size({ width: 100, height: 50 })

    .onClick(() => {

      router.back()

    })

  }

}

[Consts.ts]

/*

 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import commonEvent from '@ohos.commonEventManager';



export default class consts {

  // definition for database

  static readonly DATA_BASE_NAME: string = "nothing_pre";

  static readonly DATA_BASE_KEY_TOTAL_TIMES: string = "totalTimes";

  static readonly DATA_BASE_KEY_START_TIME: string = "startTime";

  static readonly DATA_BASE_KEY_WIFI_POWER_STATE: string = commonEvent.Support.COMMON_EVENT_WIFI_POWER_STATE;

  static readonly DATA_BASE_KEY_SCREEN_OFF: string = commonEvent.Support.COMMON_EVENT_SCREEN_OFF;

  static readonly DATA_BASE_KEY_SCREEN_ON: string = commonEvent.Support.COMMON_EVENT_SCREEN_ON;

  static readonly DATA_BASE_KEY_SCREEN_LOCKED: string = commonEvent.Support.COMMON_EVENT_SCREEN_LOCKED;

  static readonly DATA_BASE_KEY_SCREEN_UNLOCKED: string = commonEvent.Support.COMMON_EVENT_SCREEN_UNLOCKED;

  static readonly DATA_BASE_KEY_ONCE_EVENTS: string = "onceCall";

  static readonly DATA_BASE_KEY_NEVER_EVENTS: string = "neverCall";



  // definition for event enable state

  static readonly ENABLE_STATE_ALWAYS : number = 0

  static readonly ENABLE_STATE_ONCE : number = 1

  static readonly ENABLE_STATE_NEVER : number = 2



  // definition for record volume

  static readonly MAX_RECORD_NUM: number = 10;



  // definition for self defined common events

  static readonly COMMON_EVENT_FINISH_MEDITATION: string = "finish_meditation"

  static readonly COMMON_EVENT_SETTING_UPDATE: string = "setting_update"

}

[HistoryFeature.ts]

/*

 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import common from '@ohos.app.ability.common'

import consts from '../module/Consts'

import dataPreferences from '@ohos.data.preferences'

import Logger from '../module/Logger'



const TAG: string = '[Sample_CustomCommonEvent_HistoryFeature]'



export default class HistoryFeature {

  constructor(abilityContext: common.UIAbilityContext) {

    this.innerContext = abilityContext

  }



  async getData() {

    await this.init()

    return new Promise((resolve) => {

      resolve(this.dataSource)

    })

  }



  private async init() {

    let prefer = null

    await dataPreferences.getPreferences(this.innerContext, consts.DATA_BASE_NAME).then((pref) => {

      prefer = pref

    })

    let records: Array<string>

    await prefer.get(consts.DATA_BASE_KEY_TOTAL_TIMES, []).then((value: Array<string>) => {

      records = value

    })

    for (let item of records) {

      await prefer.get(item, []).then((detail: Array<string>) => {

        if(JSON.stringify(detail) !== '[]'){

          this.dataSource.push(detail)

        }

      }).catch((error)=>{

        Logger.info(TAG, `Failed to get value code is ${error.code}`)

      })

    }

  }



  private dataSource: Array<Array<string>> = []

  private innerContext: common.UIAbilityContext = null

}

  • 参考接口：[@ohos.app.ability.common]，[@ohos.data.preferences]

    • 设置模块

      • 本模块分为三个事件，分别为记录联网事件，记录灭屏事件，记录亮屏事件，进行锁屏事件、进行解锁屏幕事件，每一个事件都可进行一直，仅本次和从不的单项选择，使用到应用文上下文吗，CommonEvent.publish发布公共事件，getPreferences方法获取Preferences实例进行功能页面开发。
      • 源码链接：[Header.ets]，[Consts.ts]

[SettingFeature.ts]

/*

 * Copyright (c) 2022 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import commonEvent from '@ohos.commonEventManager';

import common from '@ohos.app.ability.common';

import consts from '../module/Consts';

import dataPreferences from '@ohos.data.preferences';

import Logger from '../module/Logger';

import surveillanceEventsManager from '../module/SurveillanceEventsManager';



export default class SettingFeature {

  private innerContext: common.UIAbilityContext = null

  private pref: dataPreferences.Preferences = null



  constructor(abilityContext: common.UIAbilityContext) {

    this.innerContext = abilityContext

  }



  async init() {

    await dataPreferences.getPreferences(this.innerContext, consts.DATA_BASE_NAME).then((pref=>{

      this.pref = pref

    })).catch(err=>{

      Logger.info(`getPreferences err ${JSON.stringify(err)}`)

    })

  }



  changeState(group: string, state: number) {

    globalThis.settings.set(group, state);

    let options = {

      isSticky: true,

      parameters: surveillanceEventsManager.getSurveillanceEventStates()

    }

    commonEvent.publish(consts.COMMON_EVENT_SETTING_UPDATE, options, () => {

      Logger.info('success to publish setting update event')

    })

    this.pref.put(group, state).then(() => {

      this.pref.flush()

    })

  }



  checkStateForAlways(group: string): boolean {

    return globalThis.settings.get(group) == consts.ENABLE_STATE_ALWAYS

  }



  checkStateForOnce(group: string): boolean {

    return globalThis.settings.get(group) == consts.ENABLE_STATE_ONCE

  }



  checkStateForNever(group: string): boolean {

    return globalThis.settings.get(group) == consts.ENABLE_STATE_NEVER

  }



  changeStateToAlways(group: string) {

    this.changeState(group, consts.ENABLE_STATE_ALWAYS)

  }



  changeStateToOnce(group: string) {

    this.changeState(group, consts.ENABLE_STATE_ONCE)

  }



  changeStateToNever(group: string) {

    this.changeState(group, consts.ENABLE_STATE_NEVER)

  }

}

[SurveillanceEventsManager.ts]

/*

 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



import commonEvent from '@ohos.commonEventManager';



export class EventData {

  "usual.event.wifi.POWER_STATE": number;

  "usual.event.SCREEN_OFF": number;

  "usual.event.SCREEN_ON": number;

  "usual.event.SCREEN_LOCKED": number;

  "usual.event.SCREEN_UNLOCKED": number;

}



export default class SurveillanceEventsManager {

  constructor() {

  }



  static getSurveillanceEventStates(): EventData {

    return {

      "usual.event.wifi.POWER_STATE": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_WIFI_POWER_STATE),

      "usual.event.SCREEN_OFF": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_OFF),

      "usual.event.SCREEN_ON": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_ON),

      "usual.event.SCREEN_LOCKED": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_LOCKED),

      "usual.event.SCREEN_UNLOCKED": globalThis.settings.get(commonEvent.Support.COMMON_EVENT_SCREEN_UNLOCKED)

    }

  }



  static surveillanceEvents: Array<string> = [

  commonEvent.Support.COMMON_EVENT_WIFI_POWER_STATE,

  commonEvent.Support.COMMON_EVENT_SCREEN_OFF,

  commonEvent.Support.COMMON_EVENT_SCREEN_ON,

  commonEvent.Support.COMMON_EVENT_SCREEN_LOCKED,

  commonEvent.Support.COMMON_EVENT_SCREEN_UNLOCKED,

  ]

}

  • 参考接口：[@ohos.app.ability.common]，[@ohos.data.preferences]，[@ohos.commonEvent],[@ohos.router]，[@ohos.commonEvent]

    • 关于模块

      • 该模块开发主要介绍了本示例的功能作用以及说明了什么情况下不能使用。
      • 源码链接：[Header.ets]，[Consts.ts]

    • 设置中订阅事件模块

      • 本模块主要支持指定应用订阅自定义事件。subScribeInfo新增可选属性publisherBundleName,创建订阅对象时可指定PublisherBundlerName，事件发布时，获取订阅者信息，增加校验bundleName是否等于publisherBundlerName，相等则加入事件回调方，达成只接收指定发布方发布的事件的效果。
      • 源码链接：[EntryFormAbility.ts]，[PublishCard.ets]
      • 参考接口：[@ohos.commonEventManager]，[@ohos.hilog]，[@ohos.app.form.formInfo]，[@ohos.app.form.formBindingData]，[@ohos.app.form.FormExtensionAbility]
移动开发技术栈
关注
  • 25
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
事件的发布-订阅实现
夏狗花花的博客
09-06 549
学习笔记，简要记录一下。 适用场景 监听事件的位置和触发事件的位置不受限，可以用于任意组件间的通信。Vue 中的 EventBus 就是一个典型应用。 实现思路 处理事件和监听函数的对应关系 —— 用对象（eventMap）存储事件和处理函数的映射关系 实现事件订阅 —— 往 eventMap 写入事件处理函数 实现事件发布 —— 从 eventMap 读取事件处理函数并依次执行 具体实现 class myEventEmitter { constructor() { this.event.
HarmonyOS应用开发基础——点击事件的四种写法
明宇逸风的博客
09-23 336
HarmonyOS应用开发基础 点击事件的四种写法 首先在ability_main.xml中添加一个Button。<Button ohos:id="$+id:but1" ohos:height="match_content" ohos:width="match_content" ohos:text="点我" ohos:text_size="200" ohos:background_element="red" /> 第一种方法：定义实现类 首先我们需要去找到我们之前已经定义的button，通过id
HarmonyOS实战开发-事件的订阅和发布。
2401_82546228的博客
04-13 657
本示例主要展示了公共事件相关的功能，实现了一个检测用户部分行为的应用。具体而言实现了如下几点功能：
【鸿蒙应用开发系列】- 事件订阅者CommonEventSubscriber使用
枫的专栏
09-14 2143
我们定义一个MessageCommonEventSubscriber 类，继承自CommonEventSubscriber，然后实现onReceiveEvent方法，在方法中获取消息事件。由于一个事件订阅者可以订阅多个action（多个事件），因此我们这里通过getAction获取到对应的事件意图，然后再获取传递的数据。
鸿蒙应用中的事件
owlivendy的博客
07-03 867
鸿蒙应用中的应用事件按照 通信方式分成进程间通信和线程间通信。进程间通信负责系统级别的事件发布、订阅和取消订阅，其中包含了开发者的创建自定义的公共事件，实现应用间的通信；而线程间通信提供了App应用内的事件订阅、取消订阅以及发送事件。CES（Common Event Service，公共事件服务）为应用程序提供订阅、发布、退订公共事件的能力。公共事件从系统角度可分为：系统公共事件和自定义公共事件。系统公共事件。
HarmonyOS实战开发-如何实现事件的订阅和发布，使用自定义弹窗设置广告信息。
2401_82546228的博客
04-12 858
本示例使用Emitter实现事件的订阅和发布，使用自定义弹窗设置广告信息。
Android 组件化
大模型学习路线
06-03 2247
软件开发的六大设计原则 开闭原则 对扩展开放，对修改关闭。其目的在于当我们需要拓展一个功能的时候，不能去修改原有的代码，而应该去通过其它的方法来达到这个目的，其实此处的其它方法，便是针对代码中容易发生改动的位子，利用接口或抽象类来进行拓展，在需要改动的时候，只需要根据需求重新派生一个新的实现类就可以了。 里氏代换原则 任何基类可以出现的地方，子类一定可以出现。这就要求，子类可以实现父类中的抽象方法，但不要覆盖父类已实现的方法。如果随意修改了父类已实现的方法，可能会带来未知的错误。 依赖倒置原则 高层模块不应
HarmonyOS鸿蒙学习笔记（23）监听Wifi状态变化
菜鸟博客
01-25 942
HarmonyOS 监听Wifi状态
HarmonyOS开发案例：抽奖转盘
最新发布
07-27
基于画布组件、动画样式，实现的一个自定义抽奖圆形转盘。包含如下功能： 通过画布组件canvas，画出抽奖圆形转盘。 通过动画样式设置动画，实现抽奖功能。 通过自定义弹窗dialog弹出抽中的奖品。...
HarmonyOS应用开发：集成语音识别功能全攻略
07-07
通过实际的代码示例和开发指南，开发者可以快速在自己的HarmonyOS应用中集成语音识别功能，为用户提供更加丰富和便捷的交互体验。 本文提供了在HarmonyOS应用中集成语音识别功能的全面指南，从服务集成到实际代码...
harmonyos2-node-obj-watch:监视对象的更改并触发事件以进行通知
07-01
和声2 节点对象手表 监视对象的更改并触发事件以进行通知 示例用法 ObjWatcher = require('node-obj-watch') appWatch = new ObjWatcher("App") appWatch.watch "Post", "load", -> console.log("Posts loaded and called back") -或者- 如果您想轻松地将其添加到您的模块/框架中 Tower.Support.on_load = require('node-obj-watch').on_load Tower.Support.on_load "App", "Post", -> console.log("Posts loaded and called back") 提示 这仅在 NodeJS 0.8.2 上测试过 建议您打开和声代理，但它确实使用节点代理作为后备。 代码应该很容易移植到浏览器，但同样只适用于实现了和谐代理的浏览器。
精通HarmonyOS应用开发：从入门到高级实战"
07-06
- 安装HarmonyOS应用开发所需的SDK和开发工具。 - 熟悉DevEco Studio IDE的使用。 ### 3. 学习应用开发框架 - 理解HarmonyOS的应用开发框架，包括Ability、Window、Scene等。 - 学习如何使用HarmonyOS的UI框架和...
HarmonyOS 开发平台和工具
02-11
总的来说，HarmonyOS开发平台是一个全面的开发生态系统，旨在推动跨设备应用的创新和发展，提供一站式的开发、测试和分发支持，帮助开发者轻松应对超级终端时代的挑战。通过利用其新能力和丰富的工具，开发者能够...
华为鸿蒙HarmonyOS开发整理资料汇总.zip
11-25
华为鸿蒙HarmonyOS开发整理资料汇总，共38份。 1学前必读：HarmonyOS学习资源主题分享 2学前必读：OpenHarmony-联盟生态资料合集 3-1.HarmonyOS概述：技术特性 3-2.HarmonyOS概述：开发工具与平台 3-3.HarmonyOS...
HarmonyOS4.0系统性深入开发18公共事件简介
qq_46189388的博客
01-11 1606
公共事件服务提供了动态订阅和静态订阅两种订阅方式。动态订阅与静态订阅最大的区别在于，动态订阅是应用运行时行为，而静态订阅是后台服务无需处于运行状态。动态订阅：指订阅方在运行时调用公共事件订阅的API实现对公共事件的订阅，详见动态订阅公共事件。静态订阅：订阅方通过配置文件声明和实现继承自StaticSubscriberExtensionAbility的类实现对公共事件的订阅，详见静态订阅公共事件。
HarmonyOS实战开发：静态订阅公共事件
2401_84194030的博客
04-27 985
静态订阅者在未接收订阅的目标事件时，处于未拉起状态。
HarmonyOS之公共事件的发布、订阅与退订
╰つ栺尖篴夢ゞ
07-27 1908
一、简介 ① 概念 HarmonyOS 通过 CES（Common Event Service，公共事件服务）为应用程序提供订阅、发布、退订公共事件的能力，通过 ANS（Advanced Notification Service，即通知增强服务）系统服务来为应用程序提供发布通知的能力。 公共事件可分为系统公共事件和自定义公共事件： 系统公共事件：系统将收集到的事件信息，根据系统策略发送给订阅该事件的用户程序。 公共事件包括：终端设备用户可感知的亮灭屏事件，以及系统关键服务发布的系统事件（例如：USB
鸿蒙开发接口公共事件与通知：【@ohos.commonEvent (公共事件模块)】
2301_76813281的博客
05-20 1092
鸿蒙—作为国家主力推送的国产操作系统。部分的高校已经取消了安卓课程，从而开设鸿蒙课程；企业纷纷跟进启动了鸿蒙研发。并且鸿蒙是完全具备无与伦比的机遇和潜力的；预计到年底将有 5,000 款的应用完成原生鸿蒙开发，未来将会支持 50 万款的应用。那么这么多的应用需要开发，也就意味着需要有更多的鸿蒙人才。鸿蒙开发工程师也将会迎来爆发式的增长，学习鸿蒙势在必行！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值