SDK API

              
                  /**
     * debug log 设置，默认false
     *
     * @param debug true 为 debug，false 为非 debug
     */
    setDebug(debug: boolean)

            

              
              EPushInterface.setDebug(true)//启用 debug

            

              
                  /**
     * 设置appkey
     *
     * @param appKey 为平台的appkey
     */
    setAppKey(appKey: string)

            

              
              EPushInterface.setAppKey("你的appKey")

            

              
                  /**
     * 配置渠道
     *
     * @param channel 渠道名称
     */
    setChannel(channel: string)

            

              
              EPushInterface.setChannel("渠道名称")

            

              
                  /**
     * 配置自定义后台信息缓存条数
     *
     * @param maxCacheCount 缓存条数
     */
    setCustomMessageMaxCacheCount(maxCacheCount: number)

            

              
              EPushInterface.setCustomMessageMaxCacheCount(2)

            

              
                  /**
     * 设置是否由用户自己调用通知申请权限
     * @param applicationContext 应用上下文
     * @param enable true: 用户自己调用通知申请权限, false: SDK调用通知申请权限（默认）
     */
    setUserRequestNotificationPermission(applicationContext: common.ApplicationContext, enable: boolean)

            

              
              // 设置用户自己调用通知申请权限
EPushInterface.setUserRequestNotificationPermission(this.context.getApplicationContext(), true)

// 设置SDK调用通知申请权限（默认）
EPushInterface.setUserRequestNotificationPermission(this.context.getApplicationContext(), false)

            

              
                 /**
   * 开启推送业务功能
   * @param context 上下文
   */
    init(context: common.UIAbilityContext | common.AbilityStageContext)

            

              
              EPushInterface.init(this.context)

            

              
                  /**
     * 反回注册的rid
     *
     */
    getRegistrationId(): string

            

              
              let rid = EPushInterface.getRegistrationId()

            

              
                  /**
     * 清除 token
     */
    clearToken()

            

              
              EPushInterface.clearToken()

            

              
                  /**
     * 监听回调事件和数据
     *
     * @param callBackMsg 
     */
    setCallBackMsg(callBackMsg: CallBackMsg)

            

              
              class MyCallBackMsg extends CallBackMsg {
  context: common.ApplicationContext

  constructor(co: common.ApplicationContext) {
    super();
    this.context = co
  }

  /**
   * 注册成功后回调rid
   * @param registrationId 注册成功后回调rid
   */
  onRegister(registrationId: string): void {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onRegister registrationId:' + registrationId);
    this.context.eventHub.emit('jPush_event', "registrationId:" + registrationId);
  }

  /**
   * 长连接登陆 回调
   * @param isConnected true:成功，false：失败
   */
  onConnected(isConnected: boolean): void {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onConnected isConnected:' + isConnected);
    this.context.eventHub.emit('jPush_event', "isConnected:" + isConnected);
  }

  /**
   * 操作 tag 接口回调
   * @param eTagMessage
   * export class ETagMessage {
   * sequence?: number //对应操作id，全局不要重复
   * code?: number //0成功，ETagMessage.CODE_TIME_OUT超时
   * op?: string
   * tags?: string[] //对应数据
   * curr?: number //数据当前页数，页数从1开始
   * total?: number //数据总页数
   * msg?: string
   * validated?:boolean //checkTagBindState 查询tag是否存在
   * }
   */
  onTagOperatorResult(eTagMessage: ETagMessage): void {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onTagOperatorResult ETagMessage:' + JSON.stringify(eTagMessage));
    this.context.eventHub.emit('jPush_event', "onTagOperatorResult:" + JSON.stringify(eTagMessage));
  }

  /**
   * 操作 Alias 接口回调
   * @param eAliasMessage
   * export class EAliasMessage {
   * sequence?: number //对应操作id，全局不要重复
   * code?: number //0成功，EAliasMessage.CODE_TIME_OUT超时
   * op?: string
   * alias?: string //对应数据
   * curr?: number 
   * total?: number 
   * msg?: string
   * }
   */
  onAliasOperatorResult(eAliasMessage: EAliasMessage): void {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onAliasOperatorResult eAliasMessage:' + JSON.stringify(eAliasMessage));
    this.context.eventHub.emit('jPush_event', "onAliasOperatorResult:" + JSON.stringify(eAliasMessage));
  }

  /**
   * 通知点击事件回调
   * @param eMessage
   *
   * export class EMessage {
   * msgId?: string //通知id
   * title?: string //通知标题
   * content?: string//通知内容
   * extras?: Record<string, Object>//自定义数据
   * channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道（开始支持的版本：EPush HarmonyOS SDK v1.0.0）
   * }
   */
  onClickMessage(eMessage: EMessage) {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onClickMessage eMessage:' + JSON.stringify(eMessage));
    this.context.eventHub.emit('jPush_event', "onClickMessage:" + JSON.stringify(eMessage));
  }
  
  /**
   * 通知到达事件回调（仅通过EngageLab通道下发通知会触发此函数，通过鸿蒙系统通道下发通知由设备系统处理，暂不支持回调）
   * 开始支持的版本：EPush HarmonyOS SDK v1.0.0
   * @param eMessage
   *
   * export class EMessage {
   * msgId?: string //通知id
   * title?: string //通知标题
   * content?: string//通知内容
   * extras?: Record<string, Object>//自定义数据
   * channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道（实际情况，此处获取到的值只有可能是1）
   * }
   */
  onArrivedMessage(eMessage: EMessage) {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onArrivedMessage eMessage:' + JSON.stringify(eMessage));
    this.context.eventHub.emit('jPush_event', "onArrivedMessage:" + JSON.stringify(eMessage));
  }
  
  /**
   * 通知在前台不展示功能生效时触发的事件回调
   * 开始支持的版本：EPush HarmonyOS SDK v1.0.0
   * @param eMessage
   *
   * export class EMessage {
   * msgId?: string //通知id
   * title?: string //通知标题
   * content?: string//通知内容
   * extras?: Record<string, Object>//自定义数据
   * channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道
   * }
   */
  onUnShowMessage(eMessage: EMessage) {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onUnShowMessage eMessage:' + JSON.stringify(eMessage));
    this.context.eventHub.emit('jPush_event', "onUnShowMessage:" + JSON.stringify(eMessage));
  }
  
   /**
   * 自定义信息回调
   *  回调一：冷启动调用sdk初始化后回调之前还没有回调的信息
   *  回调二：app存活时会直接回调信息
   *  想要触发自定义信息走厂商通道下发时回调，请关注接口「customMessageBackgroundData」说明，或查看集成指南的「配置自定义信息」说明。
   * @param eCustomMessage
   *
   * export class ECustomMessage {
   *  msgId?: string //通知id
   *  title?: string //通知标题
   *  content?: string //通知内容
   *  contentType?: string //通知内容类型
   *  extras?: Record<string, Object> //通知自定义键值对
   *  ttl?: number //后台下发的信息过期时间，单位秒
   *  stime?: number //后台下发时间，毫秒
   *  channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道（开始支持的版本：EPush HarmonyOS SDK v1.0.0）
   * }
   */
  onCustomMessage(eCustomMessage: ECustomMessage) {
    hilog.info(0x0000, TAG, '%{public}s', 'onCustomMessage eCustomMessage:' + JSON.stringify(eCustomMessage));
    this.context.eventHub.emit('jPush_event', "onCustomMessage:" + JSON.stringify(eCustomMessage));
  }
  
  /**
   * 通知扩展消息回调
   * 想要触发通知扩展消息走厂商通道下发时回调，请关注接口「extraMessageBackgroundData」、「receiveExtraDataMessage」说明，或查看集成指南的「配置通知扩展消息」说明。
   * 
   * @param eMessageExtra
   *
   * export class EMessageExtra {
   * msgId?: string //通知id
   * title?: string //通知标题
   * content?: string//通知内容
   * extras?: Record<string, Object>//自定义数据
   * extraData?: string//通知扩展消息的自定义数据
   * }
   */
  onEMessageExtra(eme: EMessageExtra) {
    hilog.info(0x0000, TAG, '%{public}s', 'onEMessageExtra eme:' + JSON.stringify(eme));
    this.context.eventHub.emit('jPush_event', "onEMessageExtra:" + JSON.stringify(eme));
  }
  
  /**
   * VoIP呼叫消息回调
   * 想要触发VoIP呼叫消息走厂商通道下发时回调，请关注接口「voIPMessageBackgroundData」说明，或查看集成指南的「配置推送VoIP呼叫消息」说明。
   * 
   * export class EMessageVoIP {
   * msgId?: string //通知id
   * extraData?: string //VoIP自定义数据
   }
   * @param jmVoIP
   */
  onEMessageVoIP(emVoIP: EMessageVoIP) {
    hilog.info(0x0000, TAG, '%{public}s', 'EMessageVoIP emVoIP:' + JSON.stringify(emVoIP));
    this.context.eventHub.emit('jPush_event', "EMessageVoIP:" + JSON.stringify(emVoIP));
  }
  
   /**
   * export class ECmdMessage {
   * cmd?: number //操作类型
   * errorCode?: number //状态码
   * msg?: string //内容
   * extra?: Record<string, Object>
   * }
   * @param cmdMessage
   */
  onCommandResult(cmdMessage: ECmdMessage) {
    hilog.info(0x0000, TAG, '%{public}s', 'onCommandResult cmdMessage:' + JSON.stringify(cmdMessage));
    this.context.eventHub.emit('jPush_event', "onCommandResult:" + JSON.stringify(cmdMessage));
  }
}


EPushInterface.setCallBackMsg(new MyCallBackMsg(this.context))

            

              
                  /**
     * 注册结果回调
     *
     * @param registrationId  rid   
     */		
    onRegister(registrationId: string)

            

              
                  /**
     * 长连接是否连接成功
     *
     * 在开启推送业务功能后会进行长连接，连接成功/失败均会回调此方法
     *
     * @param isConnected  长连接是否连接成功，true为成功；false为失败   
     */		
    onConnected(isConnected: boolean)

            

              
                  /**
     * 通知点击事件回调
       export class EMessage {
       msgId?: string //通知id
       title?: string //通知标题
       content?: string //通知内容
       extras?: Record<string, Object> //自定义数据
       channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道（开始支持的版本：EPush HarmonyOS SDK v1.0.0）
       }
     *
     * @param eMessage  
     */		
    onClickMessage(eMessage: EMessage)

            

              
                  /**
     * 通知到达事件回调
       export class EMessage {
       msgId?: string //通知id
       title?: string //通知标题
       content?: string //通知内容
       extras?: Record<string, Object> //自定义数据
       channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道（实际情况，此处获取到的值只有可能是1）
       }
     *
     * @param eMessage  
     */		
    onArrivedMessage(eMessage: EMessage)

            

              
                  /**
     * 通知在前台不展示功能生效时触发的事件回调
       export class EMessage {
       msgId?: string //通知id
       title?: string //通知标题
       content?: string //通知内容
       extras?: Record<string, Object> //自定义数据
       channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道
       }
     *
     * @param eMessage  
     */		
    onUnShowMessage(eMessage: EMessage)

            

              
                /**
   * 交互事件回调
   * @param cmdMessage
   * export class ECmdMessage {
   * public static readonly CMD_TOKEN = 10000 //	token 注册回调（开始支持的版本：EPush HarmonyOS SDK v1.0.0）
   *
   * cmd?: number  //操作事件
   * errorCode?: number //0表示成功，其他为错误
   * msg?: string //内容信息
   * extra?: Record<string, Object>
   * }
   */
  onCommandResult(cmdMessage: ECmdMessage);

            

              
                /**
   * 自定义信息通知回调
   *  回调一：冷启动调用sdk初始化后回调之前还没有回调的信息
   *  回调二：app存活时会直接回调信息
   *  想要有自定义信息回调，还需查看集成指南的自定义信息集成配置方式
   * @param eCustomMessage
   *
   * export class ECustomMessage {
   *  msgId?: string //通知id
   *  title?: string //通知标题
   *  content?: string //通知内容
   *  contentType?: string //通知内容类型
   *  extras?: Record<string, Object> //通知自定义键值对
   *  ttl?: number //后台下发的信息过期时间，单位秒
   *  stime?: number //后台下发时间，毫秒
   *  channel?: number //数据来源通道 0:厂商通道 1:EngageLab通道（开始支持的版本：EPush HarmonyOS SDK v1.0.0）
   * }
   */
  onCustomMessage(eCustomMessage: ECustomMessage)；

            

              
                /**
   * 通知扩展消息回调
   * @param eMessageExtra
   *
   * export class EMessageExtra {
   * msgId?: string //通知id
   * title?: string //通知标题
   * content?: string//通知内容
   * extras?: Record<string, Object>//自定义数据
   * extraData?: string//通知扩展消息的自定义数据
   * }
   */
  onEMessageExtra(eme: EMessageExtra);

            

              
                 /**
   * VoIP呼叫消息回调
   * export class EMessageVoIP {
   * msgId?: string //通知id
   * extraData?: string //VoIP自定义数据
   }
   * @param emVoIP
   */
  onEMessageVoIP(emVoIP: EMessageVoIP)；

            

              
                 /**
    * 操作 tag 接口回调
      export class ETagMessage {
      sequence?: number //对应操作id，全局不要重复
      code?: number //0成功，ETagMessage.CODE_TIME_OUT超时
      op?: string
      tags?: string[] //对应数据
      curr?: number //数据当前页数，页数从1开始
      total?: number //数据总页数
      msg?: string
      }
    *
    * @param eTagMessage
   */
  onTagOperatorResult(eTagMessage: ETagMessage)

            

              
                /**
   * 操作 Alias 接口回调
     export class EAliasMessage {
      sequence?: number //对应操作id，全局不要重复
      code?: number //0成功，EAliasMessage.CODE_TIME_OUT超时
      op?: string
      alias?: string //对应数据
      curr?: number
      total?: number
      msg?: string
     }
   *
   * @param eAliasMessage
   */
  onAliasOperatorResult(eAliasMessage: EAliasMessage)

            

              
                 /**
   * 在通知跳转页面UIAbility的onCreate、onNewWant中调用：传入want和context，通过上面的onClickMessage接口回调自定义数据
   *
   * @param want UIAbility中的want
   * @param context 应用上下文，在UIAbility中传this.context，在AbilityStage中传context
   */
    setClickWant(want: Want, context: common.ApplicationContext | common.AbilityStageContext): Promise<EMessage | undefined>

            

              
              onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
    this.setClickWant(want)
}

onNewWant(want: Want, launchParam: AbilityConstant.LaunchParam): void {
  super.onNewWant(want, launchParam)
  this.setClickWant(want)
}

private async setClickWant(want: Want) {
    let j:EMessage|undefined = await EPushInterface.setClickWant(want, this.context);
    hilog.info(0x0000, TAG, '%{public}s', 'setClickWant: '+JSON.stringify(j));
}

            

              
                  /**
     * 停止通知
     *
     */
    stopPush()

            

              
              EPushInterface.stopPush()

            

              
                  /**
     * 恢复通知
     *
     */
    resumePush()

            

              
              EPushInterface.resumePush()

            

              
                  /**
     * 通知状态查询
     *
     */
    isPushStopped(): boolean | undefined

            

              
              let isPushStopped = EPushInterface.isPushStopped()

            

              
                  /**
     * 增加指定tag，累加逻辑，之前设置的标签依然存在
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tags     标签数组，每个tag命名长度限制为40字节，最多支持设置1000个tag，且单次操作总长度不得超过5000字节
     */
    addTags(sequence: number, tags: string[])

            

              
              EPushInterface.addTags(this.sequence++, ["ccc", "ddddd"])

            

              
                  /**
     * 删除指定tag，删除逻辑，会删除指定的标签
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tags     标签数组，每个tag命名长度限制为40字节，最多支持设置1000个tag，且单次操作总长度不得超过5000字节
     */
    deleteTags(sequence: number, tags: string[])

            

              
                EPushInterface.deleteTags(this.sequence++, ["ccc"])

            

              
                  /**
     * 更新指定tag，覆盖逻辑，之前添加的tag会清空
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tags     标签数组，每个tag命名长度限制为40字节，最多支持设置1000个tag，且单次操作总长度不得超过5000字节
     */
    setTags(sequence: number, tags: string[])

            

              
              EPushInterface.setTags(this.sequence++, ["xxx", "yyy"])

            

              
                  /**
     * 查询指定tag
     * 
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tag      标签，每个tag命名长度限制为40字节
     */
    checkTagBindState(sequence: number, tag: string) 

            

              
               EPushInterface.checkTagBindState(this.sequence++, "ccc")

            

              
                  /**
     * 删除所有tag，清空逻辑，会删除所有的标签
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     */
    cleanTags(sequence: number)

            

              
              EPushInterface.cleanTags(this.sequence++)

            

              
                  /**
     * 查询所有tag，获取逻辑，会获取所有标签
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param curr  获取当前的页数，开始页数值为1
     */
    getTags(sequence: number, curr: number)

            

              
              EPushInterface.getTags(this.sequence++, 1)

            

              
                  /**
     * 设置alias
     * 
     * 同一个应用程序内，对不同的用户，建议取不同的别名。这样，尽可能根据别名来唯一确定用户
     * 
     * 不限定一个别名只能指定一个用户
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param alias    有效的别名组成：字母（区分大小写）、数字、下划线、汉字、特殊字符@!#$&*+=.|。限制：alias命名长度限制为 40 字节（判断长度需采用 UTF-8 编码）
     *                             
     */
    setAlias(sequence: number, alias: string)

            

              
               EPushInterface.setAlias(this.sequence++, "gggdd")

            

              
                  /**
     * 获取alias
     * 
     * 同一个应用程序内，对不同的用户，建议取不同的别名。这样，尽可能根据别名来唯一确定用户
     * 
     * 不限定一个别名只能指定一个用户
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     */
    getAlias(sequence: number)

            

              
              EPushInterface.getAlias(this.sequence++)

            

              
                  /**
     * 清除alias
     *
     * 同一个应用程序内，对不同的用户，建议取不同的别名。这样，尽可能根据别名来唯一确定用户
     * 
     * 不限定一个别名只能指定一个用户
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     */
    deleteAlias(sequence: number)

            

              
              EPushInterface.deleteAlias(this.sequence++)

            

              
                  /**
     * 设置 TCP SSL
     * @param b true: 使用 SSL 加密, false: 不使用 SSL 加密
     */
    setTcpSSl(b: boolean)

            

              
              EPushInterface.setTcpSSl(true) // 启用 SSL 加密

            

              
                  /**
     * 设置长连接心跳周期
     * @param heartbeatTime 单位秒，范围[30,290]
     */
    setHeartbeatTime(heartbeatTime: number)

            

              
              EPushInterface.setHeartbeatTime(60) // 设置心跳周期为 60 秒

            

              
                  /**
     * 设置角标
     *
     * @param badgeNumber 角标值
     */
    setBadgeNumber(badgeNumber: number)

            

              
                EPushInterface.setBadgeNumber(0)

            

              
                  /**
     * 自定义消息集成使用
     * 后台自定义信息接收
     * @param data BACKGROUND消息
     */
    customMessageBackgroundData(data: pushCommon.PushPayload): Promise<boolean>

            

              
              import { UIAbility } from '@kit.AbilityKit';
import { EPushInterface } from '@engagelab/push';
import { pushCommon, pushService } from '@kit.PushKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

const TAG: string = 'ENGAGELAB-JLog-PushMessageAbility'
export default class PushMessageAbility extends UIAbility {
  onCreate(): void {
    try { // receiveMessage中的参数固定为BACKGROUND-------后台自定义信息接收
      pushService.receiveMessage('BACKGROUND', this, async (data: pushCommon.PushPayload) => {
        let jg = await EPushInterface.customMessageBackgroundData(data)
        if (jg) { //如果是true为已经处理
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'BACKGROUND fail:'+JSON.stringify(e));
    }
}

            

              
                  /**
     * VoIP呼叫消息集成使用
     * VoIP呼叫消息接收
     * @param data VoIP消息
     */
    voIPMessageBackgroundData(data: pushCommon.PushPayload): Promise<boolean>

            

              
              import { UIAbility } from '@kit.AbilityKit';
import { EPushInterface } from '@engagelab/push';
import { pushCommon, pushService } from '@kit.PushKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

const TAG: string = 'ENGAGELAB-JLog-PushMessageAbility'
export default class PushMessageAbility extends UIAbility {
  onCreate(): void {
    try {
      pushService.receiveMessage('VoIP', this, async (data) => {
        let jg = await EPushInterface.voIPMessageBackgroundData(data)
        if (jg) { //如果是true为已经处理
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'VoIP fail:'+JSON.stringify(e));
    }
  }


}

            

              
                  /**
     * 通知扩展消息集成使用
     * 通知扩展消息接收
     * @param data IM消息
     */
    extraMessageBackgroundData(data: pushCommon.PushPayload): Promise<boolean>

            

              
              import { UIAbility } from '@kit.AbilityKit';
import { EPushInterface } from '@engagelab/push';
import { pushCommon, pushService } from '@kit.PushKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

const TAG: string = 'ENGAGELAB-JLog-PushMessageAbility'
export default class PushMessageAbility extends UIAbility {
  onCreate(): void {
    try { // receiveMessage中的参数固定为IM-------拓展通知接收
      pushService.receiveMessage('IM', this, async (data) => {
        let jg = await EPushInterface.extraMessageBackgroundData(data)
        if (jg) { //如果是true为已经处理
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'IM fail:'+JSON.stringify(e));
    }
}

            

              
                  /**
     * 通知扩展消息集成使用
     * 通知扩展消息接收
     * @param rNEAbility 对应RemoteNotificationExtensionAbility
     * @param data onReceiveMessage数据
     */
    receiveExtraDataMessage(rNEAbility: RemoteNotificationExtensionAbility, remoteNotificationInfo: pushCommon.RemoteNotificationInfo): Promise<EMessageExtra | undefined>

            

              
              import { pushCommon, RemoteNotificationExtensionAbility } from '@kit.PushKit';
import { hilog } from '@kit.PerformanceAnalysisKit';
import { EPushInterface } from '@engagelab/push';

const TAG: string = 'ENGAGELAB-JLog-RemoteNotificationExtAbility'

export default class RemoteNotificationExtAbility extends RemoteNotificationExtensionAbility {
  async onReceiveMessage(remoteNotificationInfo: pushCommon.RemoteNotificationInfo): Promise<pushCommon.RemoteNotificationContent> {
    hilog.info(0x0000, TAG, 'onReceiveMessage, remoteNotificationInfo: %{public}s',
      JSON.stringify(remoteNotificationInfo));

    let eMessageExtra = await EPushInterface.receiveExtraDataMessage(this, remoteNotificationInfo);
    hilog.info(0x0000, TAG, 'onReceiveMessage eMessageExtra:' + JSON.stringify(eMessageExtra));
    // Return the replaced message content.
    return {}//如果要修改通知可以反回有数据通知
  }

  onDestroy(): void {
    hilog.info(0x0000, TAG, 'RemoteNotificationExtAbility onDestroy.');
  }
}

            

              
                  /**
     * 「前台不展示功能」集成使用
     * 「前台不展示功能」数据接收
     * @param data 「前台不展示功能」消息数据
     */
    defaultMessageBackgroundData(data: pushCommon.PushPayload): Promise<boolean>

            

              
              import { UIAbility } from '@kit.AbilityKit';
import { EPushInterface } from '@engagelab/push';
import { pushCommon, pushService } from '@kit.PushKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

const TAG: string = 'ENGAGELAB-JLog-PushMessageAbility'
export default class PushMessageAbility extends UIAbility {
  onCreate(): void {
    try {
      pushService.receiveMessage('DEFAULT', this, async (data: pushCommon.PushPayload) => {
        let jg = await EPushInterface.defaultMessageBackgroundData(data)
        if (jg) { //如果是true为已经处理
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'DEFAULT fail:'+JSON.stringify(e));
    }
  }
}

            

              
                  /**
     * 通过通知ID清除通知
     * @param id 通知ID
     */
    clearNotification(id: number)

            

              
              EPushInterface.clearNotification(notificationId)

            

              
                  /**
     * 通过消息ID清除通知
     * @param msgId 消息ID
     */
    clearNotificationByMsgId(msgId: string)

            

              
              EPushInterface.clearNotificationByMsgId("your_message_id")

            

              
                  /**
     * 清除所有通知
     */
    clearNotificationAll()

            

              
              EPushInterface.clearNotificationAll()

            

              
                  /**
     * 上报自定义消息展示
     * @param channel 数据来源通道 0:厂商通道 1:EngageLab通道
     * @param msgId 消息ID
     */
    reportCustomDisplay(channel: number, msgId: string)

            

              
              EPushInterface.reportCustomDisplay(eCustomMessage.channel, eCustomMessage.msgId as string)

            

              
                  /**
     * 上报自定义消息点击
     * @param channel 数据来源通道 0:厂商通道 1:EngageLab通道
     * @param msgId 消息ID
     */
    reportCustomClick(channel: number, msgId: string)

            

              
              EPushInterface.reportCustomClick(eCustomMessage.channel, eCustomMessage.msgId as string)

            

              
                  /**
     * 上报通知展示
     * @param channel 数据来源通道 0:厂商通道 1:EngageLab通道
     * @param msgId 消息ID
     */
    reportNotificationDisplay(channel: number, msgId: string)

            

              
              EPushInterface.reportNotificationDisplay(eMessage.channel, eMessage.msgId as string)

            

              
                  /**
     * 上报通知点击
     * @param channel 数据来源通道 0:厂商通道 1:EngageLab通道
     * @param msgId 消息ID
     */
    reportNotificationClick(channel: number, msgId: string)

            

              
              EPushInterface.reportNotificationClick(eMessage.channel, eMessage.msgId as string)