HarmonyOS事件通信能力解决方案

private uiAbilityContext = getContext() as common.UIAbilityContext;

aboutToAppear(): void { 
  this.uiAbilityContext.eventHub.on('openDialog', () => { 
  this.openDialog('自定义弹窗'); 
}); 
} 
 
openDialog(str: string) { 
  let uiContext = this.getUIContext(); 
  let promptAction = uiContext.getPromptAction(); 
  let contentNode = new ComponentContent(uiContext, wrapBuilder(buildText), new Params(str)); 
  promptAction.openCustomDialog(contentNode); 
}

this.uiAbilityContext.eventHub.emit('openDialog');

this.uiAbilityContext.eventHub.off('openDialog');

private applicationContext = getContext().getApplicationContext();

eventFunc(arg: Dog) { 
  promptAction.showDialog({ 
    'message': 'dog age is ' + arg.age 
  }); 
} 
 
aboutToAppear(): void { 
  this.applicationContext.eventHub.on('myEvent', this.eventFunc); 
}

@Observed 
class Dog { 
  public age: number; 
 
  constructor(size: number) { 
    this.age = ageID++; 
  } 
} 
 
this.applicationContext.eventHub.emit("myEvent", this.dog);

this.applicationContext.eventHub.off('myEvent');

"buildOption": { 
  "sourceOption": { 
    "workers": [ 
    "./src/main/ets/model/Worker.ts", 
    ] 
  } 
}

async executeWorkerFunc(inPutStr: string) { 
  //判断输入是否为空 
  if (!this.jsWorkerInPutStr.length) { 
    this.jsWorkerOutPutStr = "No input for the string to be reserved.\n"; 
    return; 
  } 
  this.myWorker.postMessage(inPutStr);//主线程向worker线程传递消息 
  let strFlag = false; 
  let outPutStr = ''; 
  //主线程接收worker线程消息 
  this.myWorker.onmessage = (e) => { 
    outPutStr = e.data.toString(); 
    strFlag = true; 
  } 
  this.jsWorkerOutPutStr = outPutStr; 
}
// worker.ets 
let workerPort: ThreadWorkerGlobalScope = worker.workerPort; 
 
//接收来自主线程的消息 
workerPort.onmessage = (e: MessageEvents) => { 
  let oldData : string = e.data; 
  let newData = oldData.split("").reverse().join("");  //将字符串倒序 
  workerPort.postMessage(newData);  //将处理结果返回主线程 
}

emitter.on("eventId", (eventData: emitter.EventData) => { 
  promptAction.showToast({ 
    message: 'receive' + eventData.data?.content, 
    duration: 2000 
  }); 
})

async executeImmediately() { 
  if (!this.taskPoolInPutStr.length) { 
    this.taskPoolOutPutStr = 'No input for the string to be sorted.\n'; 
    return; 
  } 
  // 创建task任务 
  let task = new taskpool.Task(strSort, this.taskPoolInPutArr); 
  this.taskPoolStack.push(task); 
  // 将待执行的函数放入taskpool内部任务队列 
  await taskpool.execute(task).then((result) => { 
    this.taskPoolOutPutStr = `${this.taskPoolOutPutStr}Task executed successfully: ` 
    this.taskPoolOutPutStr += `Task executed successfully:${result.toString()}`; 
  }).catch((e: Error) => { 
    this.taskPoolOutPutStr += `Task executed failed:${e.toString()}`; 
  }); 
  this.taskPoolStack.pop(); 
}

function strSort(inPutArr: string[]): string[] { 
  let newArr = inPutArr.sort(); 
  let eventData: emitter.EventData = { 
    data: { 
      'content': JSON.stringify(newArr), 
    } 
  }; 
  emitter.emit('eventId', eventData) 
  return newArr; 
}

// 公共事件相关信息 
let options: CommonEventManager.CommonEventPublishData = { 
  bundleName: 'com.example.mysubscriber', //表示订阅者包名称，只有包名为bundleName的订阅者才能收到该公共事件。 
}; 
 
CommonEventManager.publish('eventTest', options, (err: Base.BusinessError) => { 
  if (err) { 
    hilog.error(0xFF00, LOG_TAG, `PublishCallBack err = ${JSON.stringify(err)}`); 
  } else { 
    hilog.info(0xFF00, LOG_TAG, 'commonEvent Publish success'); 
  } 
});

let subscriber: CommonEventManager.CommonEventSubscriber; //用于保存创建成功的订阅者对象，后续使用其完成订阅及退订的动作 
//订阅者信息 
let subscribeInfo: CommonEventManager.CommonEventSubscribeInfo = { 
  events: ['eventTest'] 
}; 
 
//订阅公共事件回调 
function SubscribeCB(err: Base.BusinessError, data: CommonEventManager.CommonEventData) { 
  if (err) { 
    hilog.error(0xFF00, LOG_TAG, `subscribe failed, code is ${err.code}, message is ${err.message}`); 
  } else { 
    publishNotification(); 
    hilog.info(0xFF00, LOG_TAG, 'subscribe success'); 
  } 
} 
 
//创建订阅者回调 
function createCB(err: Base.BusinessError, commonEventSubscriber: CommonEventManager.CommonEventSubscriber) { 
  if (!err) { 
    hilog.info(0xFF00, LOG_TAG, 'createSubscriber'); 
    subscriber = commonEventSubscriber; 
    //订阅公共事件 
    try { 
      CommonEventManager.subscribe(subscriber, SubscribeCB); 
    } catch (error) { 
      let err: Base.BusinessError = error as Base.BusinessError; 
      hilog.error(0xFF00, LOG_TAG, `subscribe failed, code is ${err.code}, message is ${err.message}`); 
    } 
  } else { 
    hilog.error(0xFF00, LOG_TAG, `createSubscriber failed, code is ${err.code}, message is ${err.message}`); 
  } 
}

notificationManager.requestEnableNotification();//开启通知权限 
async function publishNotification() { 
  let wantAgent: _WantAgent; 
  //WantAgentInfo对象 
  let wantAgentInfo: WantAgent.WantAgentInfo = { 
    wants: [ 
      { 
        bundleName: 'com.example.mysubscriber', 
        abilityName: 'EntryAbility', 
      } as Want 
    ], 
    operationType: WantAgent.OperationType.START_ABILITIES, 
    requestCode: 0, 
    wantAgentFlags: [WantAgent.WantAgentFlags.UPDATE_PRESENT_FLAG] 
  }; 
 
  WantAgent.getWantAgent(wantAgentInfo).then((data) => { 
    wantAgent = data; 
    let notificationRequest: notificationManager.NotificationRequest = { 
      content: { 
        notificationContentType: notificationManager.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT, 
        normal: { 
          title: '自定义公共事件', 
          text: '收到其他应用一条消息', 
          additionalText: 'Test_AdditionalText', 
        }, 
      }, 
      id: 6, 
      tapDismissed: true, //通知是否自动清除 
      notificationSlotType: notificationManager.SlotType.SOCIAL_COMMUNICATION, //社交类型通知 
      label: 'Receive CommonEvent', 
      wantAgent: wantAgent, 
    }; 
    notificationManager.publish(notificationRequest); 
  }); 
}