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

        

          JPushInterface.setDebug(true)//启用 debug

        

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

        

          JPushInterface.setAppKey("你的appKey")

        

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

        

          JPushInterface.setChannel("渠道名称")

        

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

        

          JPushInterface.init(this.context)

        

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

        

          let rid = JPushInterface.getRegistrationId()

        

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

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

  /**
   * 通知点击事件回调
   * @param jMessage
   *
   * export class JMessage {
   * msgId?: string //通知id
   * title?: string //通知标题
   * content?: string//通知内容
   * extras?: Record<string, Object>//自定义数据
   * }
   */
  onClickMessage(jMessage: JMessage) {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onClickMessage jMessage:' + JSON.stringify(jMessage));
    this.context.eventHub.emit('jPush_event', "onClickMessage:" + JSON.stringify(jMessage));
  }
  
   /**
   * 自定义信息通知回调
   *  回调一：冷启动调用sdk初始化后回调之前还没有回调的信息
   *  回调二：app存活时会直接回调信息
   *  想要有自定义信息回调，还需查看集成指南的自定义信息集成配置方式
   * @param jCustomMessage
   *
   * export class JCustomMessage {
   *  msgId?: string //通知id
   *  title?: string //通知标题
   *  content?: string //通知内容
   *  contentType?: string //通知内容类型
   *  extras?: Record<string, Object> //通知自定义键值对
   *  ttl?: number //后台下发的信息过期时间，单位秒
   *  stime?: number //后台下发时间，毫秒
   * }
   */
  onCustomMessage(jCustomMessage: JCustomMessage) {
    hilog.info(0x0000, TAG, '%{public}s', 'onCustomMessage jCustomMessage:' + JSON.stringify(jCustomMessage));
    this.context.eventHub.emit('jPush_event', "onCustomMessage:" + JSON.stringify(jCustomMessage));
  }
  
  /**
   * 通知扩展消息回调
   * @param jMessageExtra
   *
   * export class JMessageExtra {
   * msgId?: string //通知id
   * title?: string //通知标题
   * content?: string//通知内容
   * extras?: Record<string, Object>//自定义数据
   * extraData?: string//通知扩展消息的自定义数据
   * }
   */
  onJMessageExtra(jme: JMessageExtra) {
    hilog.info(0x0000, TAG, '%{public}s', 'onJMessageExtra jme:' + JSON.stringify(jme));
    this.context.eventHub.emit('jPush_event', "onJMessageExtra:" + JSON.stringify(jme));
  }
  
  /**
   * VoIP呼叫消息回调
   * export class JMessageVoIP {
   * msgId?: string //通知id
   * extraData?: string //VoIP自定义数据
   }
   * @param jmVoIP
   */
  onJMessageVoIP(jmVoIP: JMessageVoIP) {
    hilog.info(0x0000, TAG, '%{public}s', 'JMessageVoIP jmVoIP:' + JSON.stringify(jmVoIP));
    this.context.eventHub.emit('jPush_event', "JMessageVoIP:" + JSON.stringify(jmVoIP));
  }
  
   /**
   * export class JCmdMessage {
   * public static CMD_PUSH_STOP = 2007 //通知停止 设置回调
   * public static CMD_PUSH_RESUME = 2006 //    通知恢复 设置回调
   * cmd?: number //操作类型
   * errorCode?: number //状态码
   * msg?: string //内容
   * extra?: Record<string, Object>
   * }
   * @param cmdMessage
   */
  onCommandResult(cmdMessage: JCmdMessage) {
    hilog.info(0x0000, TAG, '%{public}s', 'onCommandResult cmdMessage:' + JSON.stringify(cmdMessage));
    this.context.eventHub.emit('jPush_event', "onCommandResult:" + JSON.stringify(cmdMessage));
  }
}


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

        

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

        

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

        

              /**
     * 通知点击事件回调
       export class JMessage {
       msgId?: string //通知id
       title?: string //通知标题
       content?: string //通知内容
       extras?: Record<string, Object> //自定义数据
       }
     *
     * @param jMessage  
     */        
    onClickMessage(jMessage: JMessage)

        

            /**
   * 交互事件回调
   * @param cmdMessage
   * export class JCmdMessage {
   * public static CMD_PUSH_STOP = 2007 //通知停止 设置回调
   * public static CMD_PUSH_RESUME = 2006 //    通知恢复 设置回调
   *
   * cmd?: number  //操作事件，2007通知停止，2006恢复通知
   * errorCode?: number //0表示成功，其他为错误
   * msg?: string //内容信息
   * extra?: Record<string, Object>
   * }
   */
  onCommandResult(cmdMessage: JCmdMessage);

        

            /**
   * 自定义信息通知回调
   *  回调一：冷启动调用sdk初始化后回调之前还没有回调的信息
   *  回调二：app存活时会直接回调信息
   *  想要有自定义信息回调，还需查看集成指南的自定义信息集成配置方式
   * @param jCustomMessage
   *
   * export class JCustomMessage {
   *  msgId?: string //通知id
   *  title?: string //通知标题
   *  content?: string //通知内容
   *  contentType?: string //通知内容类型
   *  extras?: Record<string, Object> //通知自定义键值对
   *  ttl?: number //后台下发的信息过期时间，单位秒
   *  stime?: number //后台下发时间，毫秒
   * }
   */
  onCustomMessage(jCustomMessage: JCustomMessage)；

        

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

        

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

        

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

        

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

        

             /**
   * 在通知跳转页面UIAbility的onCreate、onNewWant中调用：传入want，通过上面的onClickMessage接口回调自定义数据
   *
   * @param want
   */
    setClickWant(want: Want): Promise<JMessage | 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:JMessage|undefined = await JPushInterface.setClickWant(want);
    hilog.info(0x0000, TAG, '%{public}s', 'setClickWant: '+JSON.stringify(j));
}

        

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

        

          JPushInterface.stopPush()

        

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

        

          JPushInterface.resumePush()

        

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

        

          let isPushStopped = JPushInterface.isPushStopped()

        

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

        

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

        

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

        

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

        

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

        

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

        

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

        

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

        

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

        

          JPushInterface.cleanTags(this.sequence++)

        

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

        

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

        

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

        

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

        

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

        

          JPushInterface.getAlias(this.sequence++)

        

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

        

          JPushInterface.deleteAlias(this.sequence++)

        

              /**
     * 设置手机号
     *
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性，推荐每次都用不同的数字序号。
     * @param mobileNumber 手机号
     */
    setMobileNumber(sequence: number, mobileNumber: string)

        

            JPushInterface.setMobileNumber(this.sequence++,"155xxxxxxxx)

        

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

        

            JPushInterface.setBadgeNumber(0)

        

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

        

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

const TAG: string = 'JPUSH-JLog-PushMessageAbility'
export default class PushMessageAbility extends UIAbility {
  onCreate(): void {
    try { // receiveMessage中的参数固定为BACKGROUND-------后台自定义信息接收
      pushService.receiveMessage('BACKGROUND', this, async (data: pushCommon.PushPayload) => {
        let jg = await JPushInterface.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 { JPushInterface } from '@jg/push';
import { pushCommon, pushService } from '@kit.PushKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

const TAG: string = 'JPUSH-JLog-PushMessageAbility'
export default class PushMessageAbility extends UIAbility {
  onCreate(): void {
    try {
      pushService.receiveMessage('VoIP', this, async (data) => {
        let jg = await JPushInterface.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 { JPushInterface } from '@jg/push';
import { pushCommon, pushService } from '@kit.PushKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

const TAG: string = 'JPUSH-JLog-PushMessageAbility'
export default class PushMessageAbility extends UIAbility {
  onCreate(): void {
    try { // receiveMessage中的参数固定为IM-------拓展通知接收
      pushService.receiveMessage('IM', this, async (data) => {
        let jg = await JPushInterface.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<JMessageExtra | undefined>

        

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

const TAG: string = 'JPUSH-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 jMessageExtra = await JPushInterface.receiveExtraDataMessage(this, remoteNotificationInfo);
    hilog.info(0x0000, TAG, 'onReceiveMessage jMessageExtra:' + JSON.stringify(jMessageExtra));
    // Return the replaced message content.
    return {}//如果要修改通知可以反回有数据通知
  }

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

        

              /**
     * @param applicationContext 上下文
     * @param enable 默认为true，false-不允许采集
     *
     */
    setListWifi(applicationContext: common.ApplicationContext, enable: boolean)

        

          JCollectControl.setListWifi(this.context.getApplicationContext(), false)

        

              /**
     * @param applicationContext 上下文
     * @param enable 默认为true，false-不允许采集
     *
     */
    setGPS(applicationContext: common.ApplicationContext, enable: boolean)

        

          JCollectControl.setGPS(this.context.getApplicationContext(), false)