SDK-API

              
                  /**
     * Debug-Log-Einstellung, Standardwert: false
     *
     * @param debug true für Debug, false für Nicht-Debug
     */
    setDebug(debug: boolean)

            

              
              EPushInterface.setDebug(true) // Debug aktivieren

            

              
                  /**
     * Appkey setzen
     *
     * @param appKey Appkey der Plattform
     */
    setAppKey(appKey: string)

            

              
              EPushInterface.setAppKey("IhrAppKey")

            

              
                  /**
     * Kanal konfigurieren
     *
     * @param channel Kanalname
     */
    setChannel(channel: string)

            

              
              EPushInterface.setChannel("Kanalname")

            

              
                  /**
     * Maximale Cache-Anzahl für benutzerdefinierte Backend-Informationen konfigurieren
     *
     * @param maxCacheCount Anzahl der zu cachenden Einträge
     */
    setCustomMessageMaxCacheCount(maxCacheCount: number)

            

              
              EPushInterface.setCustomMessageMaxCacheCount(2)

            

              
                  /**
     * Festlegen, ob die Berechtigungsanfrage für Benachrichtigungen vom Nutzer selbst ausgelöst wird
     * @param applicationContext App-Kontext
     * @param enable true: Sie rufen die Berechtigungsanfrage selbst auf, false: SDK ruft die Berechtigungsanfrage auf (Standard)
     */
    setUserRequestNotificationPermission(applicationContext: common.ApplicationContext, enable: boolean)

            

              
              // Sie rufen die Berechtigungsanfrage selbst auf
EPushInterface.setUserRequestNotificationPermission(this.context.getApplicationContext(), true)

// SDK ruft die Berechtigungsanfrage auf (Standard)
EPushInterface.setUserRequestNotificationPermission(this.context.getApplicationContext(), false)

            

              
                 /**
   * Push-Service aktivieren
   * @param context Kontext
   */
    init(context: common.UIAbilityContext | common.AbilityStageContext)

            

              
              EPushInterface.init(this.context)

            

              
                  /**
     * Gibt die registrierte rid zurück
     *
     */
    getRegistrationId(): string

            

              
              let rid = EPushInterface.getRegistrationId()

            

              
                  /**
     * Token löschen
     */
    clearToken()

            

              
              EPushInterface.clearToken()

            

              
                  /**
     * Callback-Ereignisse und Daten empfangen
     *
     * @param callBackMsg 
     */
    setCallBackMsg(callBackMsg: CallBackMsg)

            

              
              class MyCallBackMsg extends CallBackMsg {
  context: common.ApplicationContext

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

  /**
   * Gibt nach erfolgreicher Registrierung die RID zurück
   * @param registrationId Gibt nach erfolgreicher Registrierung die RID zurück
   */
  onRegister(registrationId: string): void {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onRegister registrationId:' + registrationId);
    this.context.eventHub.emit('jPush_event', "registrationId:" + registrationId);
  }

  /**
   * Callback für die Anmeldung über die dauerhafte Verbindung
   * @param isConnected true: erfolgreich, false: fehlgeschlagen
   */
  onConnected(isConnected: boolean): void {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onConnected isConnected:' + isConnected);
    this.context.eventHub.emit('jPush_event', "isConnected:" + isConnected);
  }

  /**
   * Callback für Tag-Operationen
   * @param eTagMessage
   * export class ETagMessage {
   * sequence?: number //Vorgangs-ID; muss global eindeutig sein
   * code?: number //0: erfolgreich; ETagMessage.CODE_TIME_OUT: Zeitüberschreitung
   * op?: string
   * tags?: string[] //Zugehörige Daten
   * curr?: number //Aktuelle Datenseite; beginnt bei 1
   * total?: number //Gesamtzahl der Datenseiten
   * msg?: string
   * validated?:boolean //checkTagBindState prüft, ob das Tag vorhanden ist
   * }
   */
  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));
  }

  /**
   * Callback für Alias-Operationen
   * @param eAliasMessage
   * export class EAliasMessage {
   * sequence?: number //Vorgangs-ID; muss global eindeutig sein
   * code?: number //0: erfolgreich; EAliasMessage.CODE_TIME_OUT: Zeitüberschreitung
   * op?: string
   * alias?: string //Zugehörige Daten
   * 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));
  }

  /**
   * Callback für Benachrichtigungsklicks
   * @param eMessage
   *
   * export class EMessage {
   * msgId?: string //Benachrichtigungs-ID
   * title?: string //Benachrichtigungstitel
   * content?: string//Benachrichtigungsinhalt
   * extras?: Record<string, Object>//Benutzerdefinierte Daten
   * channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal（Unterstützt ab 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));
  }

  /**
   * Callback für eingegangene Benachrichtigungen (nur über den EngageLab-Kanal; Benachrichtigungen über den HarmonyOS-Systemkanal verarbeitet das Gerät ohne Callback)
   * Unterstützt ab EPush HarmonyOS SDK v1.0.0
   * @param eMessage
   *
   * export class EMessage {
   * msgId?: string //Benachrichtigungs-ID
   * title?: string //Benachrichtigungstitel
   * content?: string//Benachrichtigungsinhalt
   * extras?: Record<string, Object>//Benutzerdefinierte Daten
   * channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal（Hier ist tatsächlich nur der Wert 1 möglich）
   * }
   */
  onArrivedMessage(eMessage: EMessage) {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onArrivedMessage eMessage:' + JSON.stringify(eMessage));
    this.context.eventHub.emit('jPush_event', "onArrivedMessage:" + JSON.stringify(eMessage));
  }

  /**
   * Callback bei Unterdrückung einer Benachrichtigung im Vordergrund
   * Unterstützt ab EPush HarmonyOS SDK v1.0.0
   * @param eMessage
   *
   * export class EMessage {
   * msgId?: string //Benachrichtigungs-ID
   * title?: string //Benachrichtigungstitel
   * content?: string//Benachrichtigungsinhalt
   * extras?: Record<string, Object>//Benutzerdefinierte Daten
   * channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal
   * }
   */
  onUnShowMessage(eMessage: EMessage) {
    hilog.info(0x0000, 'testTag', '%{public}s', 'onUnShowMessage eMessage:' + JSON.stringify(eMessage));
    this.context.eventHub.emit('jPush_event', "onUnShowMessage:" + JSON.stringify(eMessage));
  }

   /**
   * Callback für benutzerdefinierte Nachrichten
   *  Callback 1: Nach einem Kaltstart und der SDK-Initialisierung werden bisher nicht gemeldete Nachrichten übergeben.
   *  Callback 2: Bei laufender App werden Nachrichten direkt übergeben.
   *  Für Callbacks zu benutzerdefinierten Nachrichten über Herstellerkanäle beachten Sie customMessageBackgroundData oder die Konfiguration benutzerdefinierter Nachrichten in der Integrationsanleitung.
   * @param eCustomMessage
   *
   * export class ECustomMessage {
   *  msgId?: string //Benachrichtigungs-ID
   *  title?: string //Benachrichtigungstitel
   *  content?: string //Benachrichtigungsinhalt
   *  contentType?: string //Inhaltstyp der Benachrichtigung
   *  extras?: Record<string, Object> //Benutzerdefinierte Schlüssel-Wert-Paare der Benachrichtigung
   *  ttl?: number //Ablaufzeit der serverseitig gesendeten Nachricht in Sekunden
   *  stime?: number //Serverseitiger Sendezeitpunkt in Millisekunden
   *  channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal（Unterstützt ab 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));
  }

  /**
   * Callback für erweiterte Benachrichtigungsnachrichten
   * Für erweiterte Nachrichten über Herstellerkanäle beachten Sie extraMessageBackgroundData, receiveExtraDataMessage oder die Konfiguration erweiterter Benachrichtigungsnachrichten in der Integrationsanleitung.
   *
   * @param eMessageExtra
   *
   * export class EMessageExtra {
   * msgId?: string //Benachrichtigungs-ID
   * title?: string //Benachrichtigungstitel
   * content?: string//Benachrichtigungsinhalt
   * extras?: Record<string, Object>//Benutzerdefinierte Daten
   * extraData?: string//Benutzerdefinierte Daten der erweiterten Benachrichtigungsnachricht
   * }
   */
  onEMessageExtra(eme: EMessageExtra) {
    hilog.info(0x0000, TAG, '%{public}s', 'onEMessageExtra eme:' + JSON.stringify(eme));
    this.context.eventHub.emit('jPush_event', "onEMessageExtra:" + JSON.stringify(eme));
  }

  /**
   * Callback für VoIP-Anrufnachrichten
   * Für VoIP-Callbacks über Herstellerkanäle beachten Sie voIPMessageBackgroundData oder die Konfiguration von VoIP-Push-Nachrichten in der Integrationsanleitung.
   *
   * export class EMessageVoIP {
   * msgId?: string //Benachrichtigungs-ID
   * extraData?: string //Benutzerdefinierte VoIP-Daten
   }
   * @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 //Vorgangstyp
   * errorCode?: number //Statuscode
   * msg?: string //Inhalt
   * 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))

            

              
                  /**
     * Callback für das Registrierungsergebnis
     *
     * @param registrationId  rid
     */
    onRegister(registrationId: string)

            

              
                  /**
     * Ob die dauerhafte Verbindung hergestellt wurde
     *
     * Nach Aktivierung des Push-Dienstes wird eine dauerhafte Verbindung aufgebaut. Diese Methode wird bei Erfolg und Fehlschlag aufgerufen.
     *
     * @param isConnected  Ob die dauerhafte Verbindung hergestellt wurde: true = erfolgreich; false = fehlgeschlagen
     */
    onConnected(isConnected: boolean)

            

              
                  /**
     * Callback für Benachrichtigungsklicks
       export class EMessage {
       msgId?: string //Benachrichtigungs-ID
       title?: string //Benachrichtigungstitel
       content?: string //Benachrichtigungsinhalt
       extras?: Record<string, Object> //Benutzerdefinierte Daten
       channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal（Unterstützt ab EPush HarmonyOS SDK v1.0.0）
       }
     *
     * @param eMessage
     */
    onClickMessage(eMessage: EMessage)

            

              
                  /**
     * Callback für eingegangene Benachrichtigungen
       export class EMessage {
       msgId?: string //Benachrichtigungs-ID
       title?: string //Benachrichtigungstitel
       content?: string //Benachrichtigungsinhalt
       extras?: Record<string, Object> //Benutzerdefinierte Daten
       channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal（Hier ist tatsächlich nur der Wert 1 möglich）
       }
     *
     * @param eMessage
     */
    onArrivedMessage(eMessage: EMessage)

            

              
                  /**
     * Callback bei Unterdrückung einer Benachrichtigung im Vordergrund
       export class EMessage {
       msgId?: string //Benachrichtigungs-ID
       title?: string //Benachrichtigungstitel
       content?: string //Benachrichtigungsinhalt
       extras?: Record<string, Object> //Benutzerdefinierte Daten
       channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal
       }
     *
     * @param eMessage
     */
    onUnShowMessage(eMessage: EMessage)

            

              
                /**
   * Callback für Interaktionsereignisse
   * @param cmdMessage
   * export class ECmdMessage {
   * public static readonly CMD_TOKEN = 10000 //	Callback für die Token-Registrierung（Unterstützt ab EPush HarmonyOS SDK v1.0.0）
   *
   * cmd?: number  //Vorgangsereignis
   * errorCode?: number //0 bedeutet Erfolg; andere Werte bedeuten Fehler
   * msg?: string //Inhalt
   * extra?: Record<string, Object>
   * }
   */
  onCommandResult(cmdMessage: ECmdMessage);

            

              
                /**
   * Callback für benutzerdefinierte Nachrichten
   *  Callback 1: Nach einem Kaltstart und der SDK-Initialisierung werden bisher nicht gemeldete Nachrichten übergeben.
   *  Callback 2: Bei laufender App werden Nachrichten direkt übergeben.
   *  Beachten Sie zusätzlich die Konfiguration benutzerdefinierter Nachrichten in der Integrationsanleitung.
   * @param eCustomMessage
   *
   * export class ECustomMessage {
   *  msgId?: string //Benachrichtigungs-ID
   *  title?: string //Benachrichtigungstitel
   *  content?: string //Benachrichtigungsinhalt
   *  contentType?: string //Inhaltstyp der Benachrichtigung
   *  extras?: Record<string, Object> //Benutzerdefinierte Schlüssel-Wert-Paare der Benachrichtigung
   *  ttl?: number //Ablaufzeit der serverseitig gesendeten Nachricht in Sekunden
   *  stime?: number //Serverseitiger Sendezeitpunkt in Millisekunden
   *  channel?: number //Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal（Unterstützt ab EPush HarmonyOS SDK v1.0.0）
   * }
   */
  onCustomMessage(eCustomMessage: ECustomMessage)；

            

              
                /**
   * Callback für erweiterte Benachrichtigungsnachrichten
   * @param eMessageExtra
   *
   * export class EMessageExtra {
   * msgId?: string //Benachrichtigungs-ID
   * title?: string //Benachrichtigungstitel
   * content?: string//Benachrichtigungsinhalt
   * extras?: Record<string, Object>//Benutzerdefinierte Daten
   * extraData?: string//Benutzerdefinierte Daten der erweiterten Benachrichtigungsnachricht
   * }
   */
  onEMessageExtra(eme: EMessageExtra);

            

              
                 /**
   * Callback für VoIP-Anrufnachrichten
   * export class EMessageVoIP {
   * msgId?: string //Benachrichtigungs-ID
   * extraData?: string //Benutzerdefinierte VoIP-Daten
   }
   * @param emVoIP
   */
  onEMessageVoIP(emVoIP: EMessageVoIP)；

            

              
                 /**
    * Callback für Tag-Operationen
      export class ETagMessage {
      sequence?: number //Vorgangs-ID; muss global eindeutig sein
      code?: number //0: erfolgreich; ETagMessage.CODE_TIME_OUT: Zeitüberschreitung
      op?: string
      tags?: string[] //Zugehörige Daten
      curr?: number //Aktuelle Datenseite; beginnt bei 1
      total?: number //Gesamtzahl der Datenseiten
      msg?: string
      }
    *
    * @param eTagMessage
   */
  onTagOperatorResult(eTagMessage: ETagMessage)

            

              
                /**
   * Callback für Alias-Operationen
     export class EAliasMessage {
      sequence?: number //Vorgangs-ID; muss global eindeutig sein
      code?: number //0: erfolgreich; EAliasMessage.CODE_TIME_OUT: Zeitüberschreitung
      op?: string
      alias?: string //Zugehörige Daten
      curr?: number
      total?: number
      msg?: string
     }
   *
   * @param eAliasMessage
   */
  onAliasOperatorResult(eAliasMessage: EAliasMessage)

            

              
                 /**
   * In onCreate und onNewWant der Ziel-UIAbility aufrufen und want sowie context übergeben. Benutzerdefinierte Daten werden über onClickMessage zurückgegeben.
   *
   * @param want want aus der UIAbility
   * @param context Anwendungskontext: this.context in UIAbility, context in AbilityStage
   */
    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));
}

            

              
                  /**
     * Benachrichtigungsstatus abfragen
     *
     */
    isPushStopped(): boolean | undefined

            

              
              let isPushStopped = EPushInterface.isPushStopped()

            

              
              turnOffPush(context: common.UIAbilityContext | common.AbilityStageContext): Promise<EPushResult>

            

              
              const result = await EPushInterface.turnOffPush(this.context)
console.info(`turnOffPush code: ${result.code}, message: ${result.msg}`)

            

              
              turnOnPush(
  context: common.UIAbilityContext | common.AbilityStageContext,
  appKey: string
): void

            

              
              EPushInterface.turnOnPush(this.context, "your_app_key")

            

              
                  /**
     * Push-Benachrichtigungen stoppen
     *
     */
    stopPush()

            

              
              EPushInterface.stopPush()

            

              
                  /**
     * Push-Benachrichtigungen wieder aufnehmen
     *
     */
    resumePush()

            

              
              EPushInterface.resumePush()

            

              
                  /**
     * Fügt die angegebenen Tags hinzu; vorhandene Tags bleiben bestehen
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     * @param tags     Tag-Array: höchstens 40 Byte pro Tag, 1000 Tags und insgesamt 5000 Byte pro Vorgang
     */
    addTags(sequence: number, tags: string[])

            

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

            

              
                  /**
     * Löscht die angegebenen Tags
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     * @param tags     Tag-Array: höchstens 40 Byte pro Tag, 1000 Tags und insgesamt 5000 Byte pro Vorgang
     */
    deleteTags(sequence: number, tags: string[])

            

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

            

              
                  /**
     * Ersetzt die Tags; zuvor hinzugefügte Tags werden gelöscht
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     * @param tags     Tag-Array: höchstens 40 Byte pro Tag, 1000 Tags und insgesamt 5000 Byte pro Vorgang
     */
    setTags(sequence: number, tags: string[])

            

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

            

              
                  /**
     * Fragt das angegebene Tag ab
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     * @param tag      Tag, höchstens 40 Byte lang
     */
    checkTagBindState(sequence: number, tag: string)

            

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

            

              
                  /**
     * Löscht alle Tags
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     */
    cleanTags(sequence: number)

            

              
              EPushInterface.cleanTags(this.sequence++)

            

              
                  /**
     * Fragt alle Tags ab
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     * @param curr  Abzufragende Seite; beginnt bei 1
     */
    getTags(sequence: number, curr: number)

            

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

            

              
                  /**
     * Alias setzen
     *
     * Verwenden Sie innerhalb einer App unterschiedliche Aliase für unterschiedliche Nutzer, um sie möglichst eindeutig identifizieren zu können.
     *
     * Ein Alias ist nicht auf einen einzigen Nutzer beschränkt
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     * @param alias    Gültige Zeichen: Buchstaben (Groß-/Kleinschreibung beachten), Ziffern, Unterstriche, chinesische Zeichen und @!#$&*+=.|. Höchstens 40 Byte in UTF-8.
     *
     */
    setAlias(sequence: number, alias: string)

            

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

            

              
                  /**
     * Alias abrufen
     *
     * Verwenden Sie innerhalb einer App unterschiedliche Aliase für unterschiedliche Nutzer, um sie möglichst eindeutig identifizieren zu können.
     *
     * Ein Alias ist nicht auf einen einzigen Nutzer beschränkt
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     */
    getAlias(sequence: number)

            

              
              EPushInterface.getAlias(this.sequence++)

            

              
                  /**
     * Alias löschen
     *
     * Verwenden Sie innerhalb einer App unterschiedliche Aliase für unterschiedliche Nutzer, um sie möglichst eindeutig identifizieren zu können.
     *
     * Ein Alias ist nicht auf einen einzigen Nutzer beschränkt
     *
     * @param sequence Benutzerdefinierte eindeutige Sequenznummer, die mit dem Ergebnis zurückgegeben wird
     */
    deleteAlias(sequence: number)

            

              
              EPushInterface.deleteAlias(this.sequence++)

            

              
                  /**
     * TCP SSL konfigurieren
     * @param b true: SSL-Verschlüsselung verwenden; false: keine SSL-Verschlüsselung
     */
    setTcpSSl(b: boolean)

            

              
              EPushInterface.setTcpSSl(true) // SSL-Verschlüsselung aktivieren

            

              
                  /**
     * Heartbeat-Intervall der dauerhaften Verbindung festlegen
     * @param heartbeatTime Sekunden, Bereich [30,290]
     */
    setHeartbeatTime(heartbeatTime: number)

            

              
              EPushInterface.setHeartbeatTime(60) // Heartbeat-Intervall auf 60 Sekunden setzen

            

              
                  /**
     * Badge-Wert festlegen
     *
     * @param badgeNumber Badge-Wert
     */
    setBadgeNumber(badgeNumber: number)

            

              
                EPushInterface.setBadgeNumber(0)

            

              
                  /**
     * Integration benutzerdefinierter Nachrichten
     * Benutzerdefinierte Hintergrundnachrichten empfangen
     * @param data BACKGROUND-Nachricht
     */
    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 muss BACKGROUND-Daten enthalten: benutzerdefinierte Hintergrundnachrichten
      pushService.receiveMessage('BACKGROUND', this, async (data: pushCommon.PushPayload) => {
        let jg = await EPushInterface.customMessageBackgroundData(data)
        if (jg) { //true bedeutet, dass die Verarbeitung abgeschlossen ist
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'BACKGROUND fail:'+JSON.stringify(e));
    }
}

            

              
                  /**
     * Integration von VoIP-Anrufnachrichten
     * VoIP-Anrufnachrichten empfangen
     * @param data VoIP-Nachricht
     */
    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 bedeutet, dass die Verarbeitung abgeschlossen ist
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'VoIP fail:'+JSON.stringify(e));
    }
  }


}

            

              
                  /**
     * Integration erweiterter Benachrichtigungsnachrichten
     * Erweiterte Benachrichtigungsnachrichten empfangen
     * @param data IM-Nachricht
     */
    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 muss IM-Daten enthalten: erweiterte Benachrichtigungsnachrichten
      pushService.receiveMessage('IM', this, async (data) => {
        let jg = await EPushInterface.extraMessageBackgroundData(data)
        if (jg) { //true bedeutet, dass die Verarbeitung abgeschlossen ist
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'IM fail:'+JSON.stringify(e));
    }
}

            

              
                  /**
     * Integration erweiterter Benachrichtigungsnachrichten
     * Erweiterte Benachrichtigungsnachrichten empfangen
     * @param rNEAbility Zugehörige RemoteNotificationExtensionAbility
     * @param data Daten von 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 {}//Zum Ändern der Benachrichtigung können Daten zurückgegeben werden
  }

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

            

              
                  /**
     * Integration der Unterdrückung im Vordergrund
     * Daten für die Unterdrückung im Vordergrund empfangen
     * @param data Nachrichtendaten für die Unterdrückung im Vordergrund
     */
    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 bedeutet, dass die Verarbeitung abgeschlossen ist
          return
        }
      });
    } catch (e) {
      hilog.info(0x0000, TAG, '%{public}s', 'DEFAULT fail:'+JSON.stringify(e));
    }
  }
}

            

              
                  /**
     * Benachrichtigung anhand der Benachrichtigungs-ID löschen
     * @param id Benachrichtigungs-ID
     */
    clearNotification(id: number)

            

              
              EPushInterface.clearNotification(notificationId)

            

              
                  /**
     * Benachrichtigung anhand der Nachrichten-ID löschen
     * @param msgId Nachrichten-ID
     */
    clearNotificationByMsgId(msgId: string)

            

              
              EPushInterface.clearNotificationByMsgId("your_message_id")

            

              
                  /**
     * Alle Benachrichtigungen löschen
     */
    clearNotificationAll()

            

              
              EPushInterface.clearNotificationAll()

            

              
                  /**
     * Anzeige einer benutzerdefinierten Nachricht melden
     * @param channel Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal
     * @param msgId Nachrichten-ID
     */
    reportCustomDisplay(channel: number, msgId: string)

            

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

            

              
                  /**
     * Klick auf eine benutzerdefinierte Nachricht melden
     * @param channel Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal
     * @param msgId Nachrichten-ID
     */
    reportCustomClick(channel: number, msgId: string)

            

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

            

              
                  /**
     * Anzeige einer Benachrichtigung melden
     * @param channel Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal
     * @param msgId Nachrichten-ID
     */
    reportNotificationDisplay(channel: number, msgId: string)

            

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

            

              
                  /**
     * Klick auf eine Benachrichtigung melden
     * @param channel Herkunftskanal: 0 = Herstellerkanal, 1 = EngageLab-Kanal
     * @param msgId Nachrichten-ID
     */
    reportNotificationClick(channel: number, msgId: string)

            

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