Rich media modal para iOS

A partir da versão 6.7.5 do SDK da Pushwoosh, você tem a capacidade de enviar Rich Media Modal.

Estamos introduzindo o novo Rich Media Modal, que pode ser personalizado. O novo Rich Media Modal não bloqueia completamente a tela e pode ser posicionado em diferentes partes da tela (topo, inferior e centro).

Para mais informações sobre páginas de Rich Media, por favor, consulte nosso guia.

Configuração

//para notificações push silenciosas
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    Pushwoosh.sharedInstance().handlePushReceived(userInfo)
    completionHandler(.noData)
}

Para habilitar a exibição de Rich Media Modal, defina o parâmetro Pushwoosh_RICH_MEDIA_STYLE em seu info.plist e atribua a ele o valor MODAL_RICH_MEDIA.

Info.plist:

<key>Pushwoosh_RICH_MEDIA_STYLE</key>
<string>MODAL_RICH_MEDIA</string>

Por padrão, o Rich Media Modal será exibido no centro da tela com uma animação de aparecimento de baixo para cima.

Para configurar a exibição do Rich Media Modal (posição na tela, animação de exibição, animação de fechamento), você precisa usar o seguinte método:

// Configuração do Rich Media Modal
PWModalWindowConfiguration.shared().configureModalWindow(with: .PWModalWindowPositionCenter,
                                                                 present: .PWAnimationPresentFromBottom,
                                                                 dismiss: .PWAnimationDismissUp)

O Rich Media Modal pode ser posicionado em três locais: topo, inferior ou centro.

/**
 Enum que define as posições possíveis para exibir uma janela modal.

 - `PWModalWindowPositionTop`: A janela modal aparece no topo da tela, dentro da área segura.
 - `PWModalWindowPositionCenter`: A janela modal aparece no centro da tela, dentro da área segura.
 - `PWModalWindowPositionBottom`: A janela modal aparece na parte inferior da tela, dentro da área segura.
 - `PWModalWindowPositionBottomSheet`: A janela modal aparece na parte inferior da tela, ignorando a área segura.
 - `PWModalWindowPositionDefault`: A posição padrão é o centro da tela, dentro da área segura.
 */
typedef NS_ENUM(NSInteger, ModalWindowPosition) {
    PWModalWindowPositionTop,       // Aparece no topo da tela (dentro da área segura)
    PWModalWindowPositionCenter,    // Aparece no centro da tela (dentro da área segura)
    PWModalWindowPositionBottom,    // Aparece na parte inferior da tela (dentro da área segura)
    PWModalWindowPositionBottomSheet, // Aparece na parte inferior da tela (ignora a área segura)
    PWModalWindowPositionFullScreen, // Tela cheia, ignora as margens da área segura
    PWModalWindowPositionDefault    // Posição padrão (centro da tela, dentro da área segura)
};

O exemplo abaixo mostra um Rich Media Modal exibido no topo da tela.

As animações de exibição do Rich Media Modal incluem:

typedef NS_ENUM(NSInteger, PresentModalWindowAnimation) {
    PWAnimationPresentFromBottom,
    PWAnimationPresentFromTop,
    PWAnimationPresentFromRight,
    PWAnimationPresentFromLeft,
    PWAnimationPresentNone
};

As animações de fechamento do Rich Media Modal incluem:

typedef NS_ENUM(NSInteger, DismissModalWindowAnimation) {
    PWAnimationDismissDown,
    PWAnimationDismissUp,
    PWAnimationDismissLeft,
    PWAnimationDismissRight,
    PWAnimationCurveEaseInOut,
    PWAnimationDismissNone,

    /**
     * A animação de fechamento padrão é `PWAnimationCurveEaseInOut`
     */
    PWAnimationDismissDefault
};

O exemplo abaixo demonstra a exibição de um Rich Media Modal na parte inferior da tela com uma animação de exibição da esquerda para a direita e uma animação de fechamento para a direita:

Parâmetros adicionais para a exibição do Rich Media Modal incluem opções como adicionar feedback tátil do tipo vibração, habilitar gestos de deslizar e definir um temporizador de fechamento automático após uma duração especificada.

// Tipo de Feedback Tátil
PWModalWindowConfiguration.shared().setPresent(.PWHapticFeedbackLight)

/**
enum HapticFeedbackType

typedef NS_ENUM(NSInteger, HapticFeedbackType) {
    PWHapticFeedbackLight,         // Feedback de vibração leve
    PWHapticFeedbackMedium,        // Feedback de vibração médio
    PWHapticFeedbackHard,          // Feedback de vibração forte

    /**
     * A vibração está desativada por padrão.
     */
    PWHapticFeedbackNone
};
*/

// Direções de deslize
let directions: [NSNumber] = [
    NSNumber(value: DismissSwipeDirection.PWSwipeDismissDown.rawValue),
    NSNumber(value: DismissSwipeDirection.PWSwipeDismissUp.rawValue)
]
PWModalWindowConfiguration.shared().setDismissSwipeDirections(directions)

/**
typedef NS_ENUM(NSInteger, DismissSwipeDirection) {
    PWSwipeDismissDown,
    PWSwipeDismissUp,
    PWSwipeDismissLeft,
    PWSwipeDismissRight,
    PWSwipeDismissNone
};
*/

// Definir o raio do canto do Rich Media
PWModalWindowConfiguration.shared().setCornerType([.PWCornerTypeTopLeft, .PWCornerTypeBottomRight], withRadius: 30.0)

// Fechar Rich Media Modal após N segundos
PWModalWindowConfiguration.shared().closeModalWindow(after: 3)

PWRichMediaPresentingDelegate

Para gerenciar a fila de rich media modais, você precisa implementar os métodos de delegate do PWRichMediaPresentingDelegate. Ao usar esta funcionalidade, os rich media modais são apresentados sequencialmente, e o próximo não será exibido até que o usuário feche o atual. Assim que o usuário fechar o rich media apresentado, o próximo, que fazia parte de uma notificação push diferente, será mostrado.

Para implementar esta funcionalidade, use o código fornecido abaixo:

import UIKit
import PushwooshFramework

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        PWRichMediaManager.shared().delegate = ChainedRichMediaPresentingDelegate.init(queue: [], inApp: false)
    }
}

class ChainedRichMediaPresentingDelegate: NSObject, PWRichMediaPresentingDelegate {

    var queue: [PWRichMedia]
    var inAppIsPresenting: Bool

    init(queue: [PWRichMedia], inApp: Bool) {
        self.queue = queue
        self.inAppIsPresenting = inApp
        super.init() // pode ser omitido neste exemplo, pois acontecerá automaticamente.
    }

    convenience override init() {
        self.init(queue: [], inApp: false)
    }

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

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

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

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

        if ((queue.count) != 0) {
            PWModalWindowConfiguration.shared().presentModalWindow(queue.first!)
        }
    }

    func richMediaManager(_ richMediaManager: PWRichMediaManager!, presentingDidFailFor richMedia: PWRichMedia!, withError error: Error!) {
        self.richMediaManager(richMediaManager, didClose: richMedia)
    }
}

Rich media modal para iOS

Configuração

Posicionamento do Rich Media Modal

Parâmetros adicionais para Rich Media Modal

PWRichMediaPresentingDelegate