# Modale Rich Media für iOS

Ab der Pushwoosh SDK-Version 6.7.5 haben Sie die Möglichkeit, **modale Rich Media** zu senden.

Wir führen neue **modale Rich Media** ein, die angepasst werden können. Die neuen modalen Rich Media blockieren den Bildschirm nicht vollständig und können an verschiedenen Stellen des Bildschirms positioniert werden (oben, unten und in der Mitte).

> Weitere Informationen zu Rich-Media-Seiten finden Sie in [unserem Leitfaden](/de/product/content/rich-media).

## Konfiguration

<Aside type="note">
 Standardmäßig unterstützt das Pushwoosh iOS SDK die Anzeige von Legacy-Rich-Media.
</Aside>

<Aside type="note">
Wenn Sie die Anzeige von modalen Rich Media als In-App-Nachrichten im Customer Journey Builder verwenden möchten, stellen Sie sicher, dass Sie den unten gezeigten Code implementiert haben. Weitere Details finden Sie in der [grundlegenden SDK-Integration](/de/developer/pushwoosh-sdk/ios-sdk/setting-up-pushwoosh-ios-sdk/basic-integration-guide/).
</Aside>

```swift
//for silent push notifications
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    Pushwoosh.configure.handlePushReceived(userInfo)
    completionHandler(.noData)
}
```

### Option 1: Info.plist-Konfiguration

Um die Anzeige von modalen Rich Media zu aktivieren, setzen Sie den Parameter `Pushwoosh_RICH_MEDIA_STYLE` in Ihrer **info.plist** und weisen Sie ihm den Wert `MODAL_RICH_MEDIA` zu.

**Info.plist**:
```xml
<key>Pushwoosh_RICH_MEDIA_STYLE</key>
<string>MODAL_RICH_MEDIA</string>
```

### Option 2: Programmatische Konfiguration (SDK 7.0.14+)

<Aside type="tip">
Verfügbar seit der Pushwoosh iOS SDK-Version **7.0.14**.
</Aside>

Sie können den Präsentationsstil für Rich Media auch programmatisch in Ihrer AppDelegate konfigurieren:

<Tabs>
<TabItem label="Swift">
```swift
func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

    // Set modal presentation style
    Pushwoosh.media.setRichMediaPresentationStyle(.modal)

    // Configure modal window appearance
    Pushwoosh.media.modalRichMedia.configure(
        position: .PWModalWindowPositionBottom,
        presentAnimation: .PWAnimationPresentFromBottom,
        dismissAnimation: .PWAnimationDismissDown
    )

    Pushwoosh.configure.registerForPushNotifications()
    return true
}
```
</TabItem>
<TabItem label="Objective-C">
```objective-c
- (BOOL)application:(UIApplication *)application
        didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    // Set modal presentation style
    [[Pushwoosh media] setRichMediaPresentationStyle:PWRichMediaPresentationStyleModal];

    // Configure modal window appearance
    [[[Pushwoosh media] modalRichMedia] configureWithPosition:PWModalWindowPositionBottom
                                             presentAnimation:PWAnimationPresentFromBottom
                                             dismissAnimation:PWAnimationDismissDown];

    [[Pushwoosh configure] registerForPushNotifications];
    return YES;
}
```
</TabItem>
</Tabs>

Standardmäßig werden modale Rich Media in der Mitte des Bildschirms mit einer Erscheinungsanimation von unten nach oben angezeigt.

<div style={{ display: "flex", justifyContent: "center" }}>
<video src="/ios-push-notifications-ios-modal-rich-media-1.webm" title="Beispiel" autoplay loop muted playsinline width="300" />
</div>

### Positionierung von modalen Rich Media

Modale Rich Media können an verschiedenen Stellen auf dem Bildschirm positioniert werden.

```objective-c
/**
 Enum, das die möglichen Positionen für die Anzeige eines modalen Fensters definiert.

 - `PWModalWindowPositionTop`: Das modale Fenster erscheint am oberen Bildschirmrand, innerhalb des sicheren Bereichs.
 - `PWModalWindowPositionCenter`: Das modale Fenster erscheint in der Mitte des Bildschirms, innerhalb des sicheren Bereichs.
 - `PWModalWindowPositionBottom`: Das modale Fenster erscheint am unteren Bildschirmrand, innerhalb des sicheren Bereichs.
 - `PWModalWindowPositionBottomSheet`: Das modale Fenster erscheint ganz unten am Bildschirmrand und ignoriert den sicheren Bereich.
 - `PWModalWindowPositionDefault`: Die Standardposition ist die Mitte des Bildschirms, innerhalb des sicheren Bereichs.
 */
typedef NS_ENUM(NSInteger, ModalWindowPosition) {
    PWModalWindowPositionTop,       // Erscheint am oberen Bildschirmrand (innerhalb des sicheren Bereichs)
    PWModalWindowPositionCenter,    // Erscheint in der Mitte des Bildschirms (innerhalb des sicheren Bereichs)
    PWModalWindowPositionBottom,    // Erscheint am unteren Bildschirmrand (innerhalb des sicheren Bereichs)
    PWModalWindowPositionBottomSheet, // Erscheint ganz unten am Bildschirmrand (ignoriert den sicheren Bereich)
    PWModalWindowPositionFullScreen, // Vollbild, ignoriert die Ränder des sicheren Bereichs
    PWModalWindowPositionDefault    // Standardposition (Mitte des Bildschirms, innerhalb des sicheren Bereichs)
};
```

Das folgende Beispiel zeigt eine modale Rich Media, die am oberen Bildschirmrand angezeigt wird.

<div style={{ display: "flex", justifyContent: "center" }}>
<video src="/ios-push-notifications-ios-modal-rich-media-2.webm" title="Beispiel" autoplay loop muted playsinline width="300" />
</div>

Die Erscheinungsanimationen für modale Rich Media umfassen:

```objective-c
typedef NS_ENUM(NSInteger, PresentModalWindowAnimation) {
    PWAnimationPresentFromBottom,
    PWAnimationPresentFromTop,
    PWAnimationPresentFromRight,
    PWAnimationPresentFromLeft,
    PWAnimationPresentNone
};
```

Die Schließanimationen für modale Rich Media umfassen:

```objective-c
typedef NS_ENUM(NSInteger, DismissModalWindowAnimation) {
    PWAnimationDismissDown,
    PWAnimationDismissUp,
    PWAnimationDismissLeft,
    PWAnimationDismissRight,
    PWAnimationCurveEaseInOut,
    PWAnimationDismissNone,

    /**
     * Die standardmäßige Schließanimation ist `PWAnimationCurveEaseInOut`
     */
    PWAnimationDismissDefault
};
```

Das folgende Beispiel zeigt die Anzeige einer modalen Rich Media am unteren Bildschirmrand mit einer Erscheinungsanimation von links nach rechts und einer Schließanimation nach rechts:

<div style={{ display: "flex", justifyContent: "center" }}>
<video src="/ios-push-notifications-ios-modal-rich-media-3.webm" title="Beispiel" autoplay loop muted playsinline width="300" />
</div>

### Zusätzliche Parameter für modale Rich Media

<Aside type="tip">
Die folgende API ist seit der Pushwoosh iOS SDK-Version **7.0.14** verfügbar.
</Aside>

Zusätzliche Parameter für die Anzeige von modalen Rich Media umfassen Optionen wie das Hinzufügen von haptischem Feedback vom Typ Vibration, das Aktivieren von Wischgesten und das Einstellen eines automatischen Schließ-Timers nach einer bestimmten Dauer.

<Tabs>
<TabItem label="Swift">
```swift
// Haptischer Feedback-Typ
Pushwoosh.media.modalRichMedia.setHapticFeedbackType(.PWHapticFeedbackLight)

// Wischrichtungen zum Schließen
Pushwoosh.media.modalRichMedia.setDismissSwipeDirections([
    NSNumber(value: DismissSwipeDirection.PWSwipeDismissDown.rawValue),
    NSNumber(value: DismissSwipeDirection.PWSwipeDismissUp.rawValue)
])

// Eckradius für Rich Media festlegen
let topCorners = PWCornerTypeTopLeft.rawValue | PWCornerTypeTopRight.rawValue
Pushwoosh.media.modalRichMedia.setCornerType(CornerType(rawValue: topCorners), withRadius: 16)

// Modale Rich Media nach N Sekunden schließen
Pushwoosh.media.modalRichMedia.closeAfter(3)
```
</TabItem>
<TabItem label="Objective-C">
```objective-c
// Haptischer Feedback-Typ
[[[Pushwoosh media] modalRichMedia] setHapticFeedbackType:PWHapticFeedbackLight];

// Wischrichtungen zum Schließen
[[[Pushwoosh media] modalRichMedia] setDismissSwipeDirections:@[
    @(PWSwipeDismissDown),
    @(PWSwipeDismissUp)
]];

// Eckradius für Rich Media festlegen
CornerType topCorners = PWCornerTypeTopLeft | PWCornerTypeTopRight;
[[[Pushwoosh media] modalRichMedia] setCornerType:topCorners withRadius:16.0];

// Modale Rich Media nach N Sekunden schließen
[[[Pushwoosh media] modalRichMedia] closeAfter:3.0];
```
</TabItem>
</Tabs>

**Haptische Feedback-Typen:**

```objective-c
typedef NS_ENUM(NSInteger, HapticFeedbackType) {
    PWHapticFeedbackLight,         // Leichtes Vibrationsfeedback
    PWHapticFeedbackMedium,        // Mittleres Vibrationsfeedback
    PWHapticFeedbackHard,          // Starkes Vibrationsfeedback
    PWHapticFeedbackNone           // Vibration ist aus (Standard)
};
```

**Wischrichtungen:**

```objective-c
typedef NS_ENUM(NSInteger, DismissSwipeDirection) {
    PWSwipeDismissDown,
    PWSwipeDismissUp,
    PWSwipeDismissLeft,
    PWSwipeDismissRight,
    PWSwipeDismissNone
};
```

## PWRichMediaPresentingDelegate

<Aside type="tip">
Die Delegate-API über `Pushwoosh.media.modalRichMedia.delegate` ist seit der SDK-Version **7.0.14** verfügbar.
</Aside>

Um die Warteschlange der modalen Rich Media zu verwalten, müssen Sie die Delegate-Methoden von `PWRichMediaPresentingDelegate` implementieren.
Bei Verwendung dieser Funktionalität werden modale Rich Media nacheinander präsentiert, und die nächste wird erst angezeigt, wenn der Benutzer die aktuelle schließt. Sobald der Benutzer die präsentierte Rich Media schließt, wird die nächste, die Teil einer anderen Push-Benachrichtigung war, angezeigt.

<Tabs>
<TabItem label="Swift">
```swift
import UIKit
import PushwooshFramework

@main
class AppDelegate: UIResponder, UIApplicationDelegate, PWRichMediaPresentingDelegate {

    var richMediaQueue: [PWRichMedia] = []
    var isPresenting = false

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        // Modale Rich Media konfigurieren
        Pushwoosh.media.setRichMediaPresentationStyle(.modal)
        Pushwoosh.media.modalRichMedia.configure(
            position: .PWModalWindowPositionBottom,
            presentAnimation: .PWAnimationPresentFromBottom,
            dismissAnimation: .PWAnimationDismissDown
        )

        // Delegate festlegen
        Pushwoosh.media.modalRichMedia.delegate = self

        Pushwoosh.configure.registerForPushNotifications()
        return true
    }

    // MARK: - PWRichMediaPresentingDelegate

    func richMediaManager(_ richMediaManager: PWRichMediaManager, shouldPresent richMedia: PWRichMedia) -> Bool {
        if !richMediaQueue.contains(where: { $0 === richMedia }) {
            richMediaQueue.append(richMedia)
        }
        return !isPresenting
    }

    func richMediaManager(_ richMediaManager: PWRichMediaManager, didPresent richMedia: PWRichMedia) {
        isPresenting = true
    }

    func richMediaManager(_ richMediaManager: PWRichMediaManager, didClose richMedia: PWRichMedia) {
        isPresenting = false

        if let idx = richMediaQueue.firstIndex(where: { $0 === richMedia }) {
            richMediaQueue.remove(at: idx)
        }

        // Nächste Rich Media in der Warteschlange präsentieren
        if let nextRichMedia = richMediaQueue.first {
            Pushwoosh.media.modalRichMedia.present(nextRichMedia)
        }
    }

    func richMediaManager(_ richMediaManager: PWRichMediaManager, presentingDidFailFor richMedia: PWRichMedia, withError error: Error) {
        richMediaManager(richMediaManager, didClose: richMedia)
    }
}
```
</TabItem>
<TabItem label="Objective-C">
```objective-c
#import "AppDelegate.h"
#import <PushwooshFramework/PushwooshFramework.h>

@interface AppDelegate () <PWRichMediaPresentingDelegate>

@property (nonatomic, strong) NSMutableArray<PWRichMedia *> *richMediaQueue;
@property (nonatomic, assign) BOOL isPresenting;

@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application
        didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    self.richMediaQueue = [NSMutableArray array];
    self.isPresenting = NO;

    // Modale Rich Media konfigurieren
    [[Pushwoosh media] setRichMediaPresentationStyle:PWRichMediaPresentationStyleModal];
    [[[Pushwoosh media] modalRichMedia] configureWithPosition:PWModalWindowPositionBottom
                                             presentAnimation:PWAnimationPresentFromBottom
                                             dismissAnimation:PWAnimationDismissDown];

    // Delegate festlegen
    [[[Pushwoosh media] modalRichMedia] setDelegate:self];

    [[Pushwoosh configure] registerForPushNotifications];
    return YES;
}

#pragma mark - PWRichMediaPresentingDelegate

- (BOOL)richMediaManager:(PWRichMediaManager *)richMediaManager shouldPresentRichMedia:(PWRichMedia *)richMedia {
    if (![self.richMediaQueue containsObject:richMedia]) {
        [self.richMediaQueue addObject:richMedia];
    }
    return !self.isPresenting;
}

- (void)richMediaManager:(PWRichMediaManager *)richMediaManager didPresentRichMedia:(PWRichMedia *)richMedia {
    self.isPresenting = YES;
}

- (void)richMediaManager:(PWRichMediaManager *)richMediaManager didCloseRichMedia:(PWRichMedia *)richMedia {
    self.isPresenting = NO;

    [self.richMediaQueue removeObject:richMedia];

    // Nächste Rich Media in der Warteschlange präsentieren
    if (self.richMediaQueue.count > 0) {
        [[[Pushwoosh media] modalRichMedia] presentRichMedia:self.richMediaQueue.firstObject];
    }
}

- (void)richMediaManager:(PWRichMediaManager *)richMediaManager presentingDidFailForRichMedia:(PWRichMedia *)richMedia withError:(NSError *)error {
    [self richMediaManager:richMediaManager didCloseRichMedia:richMedia];
}

@end
```
</TabItem>
</Tabs>