# Cordova-Plugin API-Referenz

```txt title="example"
var pushwoosh = cordova.require("pushwoosh-cordova-plugin.PushNotification");

// Sollte vor pushwoosh.onDeviceReady aufgerufen werden
document.addEventListener('push-notification', function(event) {
	var notification = event.notification;
	// Push-Öffnung hier behandeln
});

// Initialisiert Pushwoosh. Dies löst alle ausstehenden Push-Benachrichtigungen beim Start aus.
pushwoosh.onDeviceReady({
	appid: "XXXXX-XXXXX",
	serviceName: "XXXX"
});

pushwoosh.registerDevice(
	function(status) {
		var pushToken = status.pushToken;
    	// Erfolgreiche Registrierung hier behandeln
  },
  function(status) {
    // Registrierungsfehler hier behandeln
  }
);
```

## onDeviceReady

```javascript
PushNotification.prototype.onDeviceReady = function( config )
```

_\[android, ios, wp8, windows]_\
Initialisiert das Pushwoosh-Plugin und löst eine Start-Push-Nachricht aus. Sollte bei jedem App-Start aufgerufen werden.

`config.appid` – Pushwoosh-Anwendungscode.

`config.serviceName` – MPNS-Dienstname für die wp8-Plattform.

```txt title="example"
// Initialisiert Pushwoosh mit appid: "PUSHWOOSH_APP_ID", serviceName: "WINDOWS_PHONE_SERVICE". Dies löst alle ausstehenden Push-Benachrichtigungen beim Start aus.
pushwoosh.onDeviceReady({
    appid : "XXXXX-XXXXX",
    serviceName: "XXXX"
});
```

## registerDevice

```javascript
PushNotification.prototype.registerDevice = function( success, fail )
```

_\[android, ios, wp8, windows]_\
Registriert das Gerät für Push-Benachrichtigungen und ruft ein Push-Token ab.

`success` – Erfolgs-Callback. Das Push-Token wird als „status.pushToken“-Parameter an diesen Callback übergeben.

`fail` – Fehler-Callback

```txt title="example"
pushwoosh.registerDevice(
    function(status) {
        alert("Registriert mit Push-Token: " + status.pushToken);
    },
    function(error) {
        alert("Registrierung fehlgeschlagen: " +  error);
    }
);
```

## unregisterDevice

```javascript
PushNotification.prototype.unregisterDevice = function(	success, fail	)
```

_\[android, ios, wp8, windows]_\
Meldet das Gerät vom Empfang von Push-Benachrichtigungen ab.

`success` – Erfolgs-Callback

`fail` – Fehler-Callback

## setTags

```javascript
PushNotification.prototype.setTags = function(	config, success, fail	)
```

_\[android, ios, wp8, windows]_\
Setzt Tags für das Gerät.

**Parameter**

`config` – Objekt mit benutzerdefinierten Geräte-Tags

`success` – Erfolgs-Callback. Das Push-Token wird als „status.pushToken“-Parameter an diesen Callback übergeben.

`fail` – Fehler-Callback

```txt title="example"
// setzt die Tags: „deviceName“ mit dem Wert „hello“ und „deviceId“ mit dem Wert 10
pushwoosh.setTags({deviceName:"hello", deviceId:10},
    function() {
        console.warn('setTags success');
    },
    function(error) {
        console.warn('setTags failed');
    }
);

// setzt Listen-Tags „MyTag“ mit den Werten (Array) „hello“, „world“
pushwoosh.setTags({"MyTag":["hello", "world"]});
```

## getTags

```javascript
PushNotification.prototype.getTags = function(	success, fail	)
```

_\[android, ios, wp8, windows]_\
Gibt die Tags für das Gerät zurück, einschließlich der Standard-Tags.

`success` – Erfolgs-Callback. Empfängt Tags als Parameter.

`fail` – Fehler-Callback

```javascript
pushwoosh.getTags(
    function(tags) {
        console.warn('Tags für das Gerät: ' + JSON.stringify(tags));
    },
    function(error) {
        console.warn('Fehler beim Abrufen der Tags: ' + JSON.stringify(error));
    }
);
```

## getPushToken

```javascript
PushNotification.prototype.getPushToken = function(	success	)
```

_\[android, ios, wp8, windows]_\
Gibt das Push-Token zurück, falls es verfügbar ist. Beachten Sie, dass das Token auch im Callback der registerDevice-Funktion zurückgegeben wird.

`success` – Erfolgs-Callback.

```javascript
pushwoosh.getPushToken(
    function(token) {
        console.warn('Push-Token: ' + token);
    }
);
```

## getPushwooshHWID

```javascript
PushNotification.prototype.getPushwooshHWID = function(	success	)
```

_\[android, ios, wp8, windows]_\
Gibt die Pushwoosh-HWID zurück, die für die Kommunikation mit der Pushwoosh-API verwendet wird.

`success` – getPushwooshHWID-Callback

```
pushwoosh.getPushwooshHWID(
    function(token) {
        console.warn('Pushwoosh-HWID: ' + token);
    }
);
```

## getRemoteNotificationStatus

```javascript
PushNotification.prototype.getRemoteNotificationStatus = function(	callback, error	)
```

_\[android, ios]_\
Gibt den detaillierten Status der Berechtigungen für Push-Benachrichtigungen zurück.

`callback` – Erfolgs-Callback. Empfängt ein Objekt mit den folgenden Eigenschaften:

```
{
  "enabled" : Flag, ob Benachrichtigungen aktiviert sind.
  "pushBadge" : Berechtigung für Badges erteilt. (nur iOS)
  "pushAlert" : Berechtigung für Alarme erteilt. (nur iOS)
  "pushSound" : Berechtigung für Töne erteilt. (nur iOS)
}
```

`error` — Fehler-Callback

## setApplicationIconBadgeNumber

```javascript
PushNotification.prototype.setApplicationIconBadgeNumber = function(	badgeNumber	)
```

_\[android, ios]_\
Setzt die Badge-Nummer des Anwendungssymbols.

`badgeNumber` – Badge-Nummer des Symbols

## getApplicationIconBadgeNumber

```javascript
PushNotification.prototype.getApplicationIconBadgeNumber = function(	callback	)
```

_\[android, ios]_\
Gibt die Badge-Nummer des Anwendungssymbols zurück.

`callback` – Erfolgs-Callback

```
pushwoosh.getApplicationIconBadgeNumber(function(badge){ alert(badge);} );
```

## addToApplicationIconBadgeNumber

```javascript
PushNotification.prototype.addToApplicationIconBadgeNumber = function( badgeNumber )
```

_\[android, ios]_\
Fügt einen Wert zur Badge des Anwendungssymbols hinzu.

`badgeNumber` — inkrementelle Badge-Nummer des Symbols

## getLaunchNotification

```javascript
PushNotification.prototype.getLaunchNotification = function(	callback	)
```

_\[android, ios]_\
Gibt die Payload der Push-Benachrichtigung zurück, wenn die App als Reaktion auf eine Push-Benachrichtigung gestartet wurde, andernfalls null.

`callback` – Erfolgs-Callback

## clearLaunchNotification

```javascript
PushNotification.prototype.clearLaunchNotification = function(	callback	)
```

_\[android, ios]_\
Löscht die Startbenachrichtigung. getLaunchNotification() gibt nach diesem Aufruf null zurück.

## setUserId

```javascript
PushNotification.prototype.setUserId = function(	userId	)
```

_\[android, ios]_\
Setzt die Benutzerkennung – eine Facebook-ID, einen Benutzernamen, eine E-Mail-Adresse oder eine andere Benutzer-ID. Dies ermöglicht den Abgleich von Daten und Events über mehrere Geräte eines Benutzers hinweg.

`userId` – Benutzerkennungs-String

## postEvent

```javascript
PushNotification.prototype.postEvent = function( event, attributes )
```

_\[android, ios]_\
Postet Events für In-App-Nachrichten. Dies kann die Anzeige von In-App-Nachrichten auslösen, wie im Pushwoosh Control Panel festgelegt.

`event` – auszulösendes Event

`attributes` – Objekt mit zusätzlichen Event-Attributen

```
pushwoosh.setUserId("XXXXXX");
pushwoosh.postEvent("buttonPressed", { "buttonNumber" : 4, "buttonLabel" : "banner" });
```

## createLocalNotification

```javascript
PushNotification.prototype.createLocalNotification = function( config, success, fail )
```

_\[android, ios]_\
Plant eine lokale Benachrichtigung.

`config.msg` – Benachrichtigungsnachricht

`config.seconds` – Benachrichtigungsverzögerung in Sekunden

`config.userData` – zusätzliche Daten, die in der Benachrichtigung übergeben werden

`success` – Erfolgs-Callback

`fail` – Fehler-Callback

```
pushwoosh.createLocalNotification({msg:"Your pumpkins are ready!", seconds:30, userData:{}})
```

## clearLocalNotification

```javascript
PushNotification.prototype.clearLocalNotification = function()
```

_\[android]_\
Löscht alle ausstehenden lokalen Benachrichtigungen, die von createLocalNotification erstellt wurden.

## clearNotificationCenter

```javascript
PushNotification.prototype.clearNotificationCenter = function()
```

_\[android]_\
Löscht alle Benachrichtigungen, die im Android Notification Center angezeigt werden.

## setMultiNotificationMode

```javascript
PushNotification.prototype.setMultiNotificationMode = function( success, fail )
```

_\[android]_\
Ermöglicht die Anzeige mehrerer Benachrichtigungen im Android Notification Center.

## setSingleNotificationMode

```javascript
PushNotification.prototype.setSingleNotificationMode = function(	success,
fail	)
```

_\[android]_\
Ermöglicht, dass nur die letzte Benachrichtigung im Android Notification Center angezeigt wird.

## setSoundType

```javascript
PushNotification.prototype.setSoundType = function( type, success, fail )
```

_\[android]_\
Legt den Standardton für eingehende Push-Benachrichtigungen fest.

`type` – Tontyp (0 – Standard, 1 – kein Ton, 2 – immer)

## setVibrateType

```javascript
PushNotification.prototype.setVibrateType = function(type, success, fail )
```

_\[android]_\
Legt den Standard-Vibrationsmodus für eingehende Push-Benachrichtigungen fest.

`type` – Vibrationstyp (0 – Standard, 1 – keine Vibration, 2 – immer)

## setLightScreenOnNotification

```javascript
PushNotification.prototype.setLightScreenOnNotification = function( on, success, fail )
```

_\[android]_\
Schaltet den Bildschirm ein, wenn eine Benachrichtigung eintrifft.

`on` – Aktivieren/Deaktivieren der Bildschirmentsperrung (standardmäßig deaktiviert)

## setEnableLED

```javascript
PushNotification.prototype.setEnableLED = function( on, success, fail )
```

_\[android]_\
Aktiviert das Blinken der LED, wenn eine Benachrichtigung eintrifft und das Display ausgeschaltet ist.

`on` – Aktivieren/Deaktivieren des LED-Blinkens (standardmäßig deaktiviert)

## setColorLED

```javascript
PushNotification.prototype.setColorLED = function( color, success, fail )
```

_\[android]_\
Legt die LED-Farbe fest. In Verbindung mit [setEnableLED](#setenableled) verwenden.

`color` – LED-Farbe im ARGB-Integer-Format

## getPushHistory

```javascript
PushNotification.prototype.getPushHistory = function(	success	)
```

_\[android]_\
Gibt ein Array der empfangenen Push-Benachrichtigungen zurück.

`success` – Erfolgs-Callback

```
pushwoosh.getPushHistory(function(pushHistory) {
    if(pushHistory.length == 0)
        alert("kein Push-Verlauf");
    else
        alert(JSON.stringify(pushHistory));
});

pushwoosh.clearPushHistory();
```

## clearPushHistory

```javascript
PushNotification.prototype.clearPushHistory = function()
```

_\[android]_\
Löscht den Push-Verlauf.

## cancelAllLocalNotifications

```javascript
PushNotification.prototype.cancelAllLocalNotifications = function( callback )
```

_\[ios]_\
Löscht alle lokalen Benachrichtigungen aus der Benachrichtigungszentrale.

## presentInboxUI

_\[android, ios]_\
Öffnet den [Inbox](/de/developer/guides/message-inbox/mobile-message-inbox)-Bildschirm.

```javascript
PushNotification.prototype.presentInboxUI = function()
```

## setCommunicationEnabled

Eine binäre Methode, die die gesamte Kommunikation mit Pushwoosh aktiviert/deaktiviert. Der boolesche Wert **false** meldet das Gerät vom Empfang von Push-Benachrichtigungen ab und stoppt den Download von In-App-Nachrichten. Der Wert **true** kehrt den Effekt um.

```javascript
PushNotification.prototype.setCommunicationEnabled = function(enable, success, fail)
```

## removeAllDeviceData

Entfernt alle Daten über das Gerät.

```javascript
PushNotification.prototype.removeAllDeviceData = function()
```

## push-receive

_\[android, ios]_\
Ereignis für den Empfang von Push-Benachrichtigungen. Wird ausgelöst, wenn die Anwendung eine Push-Benachrichtigung im Vorder- oder Hintergrund empfängt. Geschlossene Anwendungen empfangen dieses Ereignis nicht.

**Ereigniseigenschaften**

`message` – (`string`) Nachricht der Push-Benachrichtigung

`userdata` – (`object`/`array`) Benutzerdefinierte Daten der Push-Benachrichtigung

`onStart` – (`boolean`) Ist eine Startbenachrichtigung

`foreground` – (`boolean`) Wird die Benachrichtigung im Vordergrund empfangen

`android` – (`object`) Android-spezifische Benachrichtigungs-Payload

`ios` – (`object`) iOS-spezifische Benachrichtigungs-Payload

`windows` – (`object`) Windows-spezifische Benachrichtigungs-Payload

```
document.addEventListener('push-receive',
	function(event) {
		var userData = event.notification.userdata;

		if (typeof(userData) != "undefined") {
			// benutzerdefinierte Benachrichtigungsdaten behandeln
			console.warn('Benutzerdaten: ' + JSON.stringify(userData));
		}
	}
);
```

## Vordergrund-Benachrichtigungen

Standardmäßig zeigt das Pushwoosh-Plugin keine Benachrichtigungen im Vordergrund an und löst automatisch das `push-receive`-Ereignis aus. Siehe die [Anleitung zur Plugin-Anpassung](/de/developer/pushwoosh-sdk/cross-platform-frameworks/cordova/customizing-cordova-plugin/), um dieses Verhalten zu steuern.

### push-notification

_\[android, ios, wp8, windows]_\
Ereignis zur Annahme von Push-Benachrichtigungen. Es wird ausgelöst, wenn der Benutzer auf die Push-Benachrichtigung tippt.

```
document.addEventListener('push-notification',
	function(event) {
		var message = event.notification.message;
		var userData = event.notification.userdata;

		if (typeof(userData) != "undefined") {
			console.warn('Benutzerdaten: ' + JSON.stringify(userData));
		}
	}
);
```

**Ereigniseigenschaften**

Gleich wie bei [push-receive](#push-receive)

### additionalAuthorizationOptions

_\[nur ios]_\
Bietet _z_usätzliche [Autorisierungsoptionen für Benachrichtigungen](https://developer.apple.com/documentation/usernotifications/unauthorizationoptions?language=objc). Sollte vor dem Aufruf von **registerDevice** aufgerufen werden.

```
pushwoosh.additionalAuthorizationOptions({ 
	"UNAuthorizationOptionCriticalAlert" : 1,
	"UNAuthorizationOptionProvisional": 0 // Setzen Sie 0 oder geben Sie die Option nicht an, wenn Sie sie nicht zu Ihrer App hinzufügen möchten. 
});
```