# Enviar dados personalizados

Este guia ajudará você a entender melhor como passar dados personalizados para seus aplicativos no payload da notificação push, para que seu aplicativo possa reagir a esses pushes e executar várias ações de acordo.

As maneiras como você lida com dados personalizados podem variar de acordo com seus objetivos de negócio. Neste artigo, mostraremos alguns exemplos básicos de análise de dados personalizados e execução de ações simples:

* alterar a cor de fundo do aplicativo;
* abrir uma página personalizada em seu aplicativo.


## Pré-requisitos

Este guia abrange o desenvolvimento nativo para iOS. Presume-se que você tenha um aplicativo de exemplo para iOS configurado e recebendo notificações push conforme o [guia de Iniciação Rápida para iOS](/pt/developer/pushwoosh-sdk/ios-sdk/setting-up-pushwoosh-ios-sdk/quick-start/).

No `AppDelegate`, na função `didFinishLaunchingWithOptions`, usaremos `self.viewController` como um delegate para o processamento de notificações push:



```swift
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   Pushwoosh.sharedInstance().delegate = self.viewController
   Pushwoosh.sharedInstance().registerForPushNotifications()

   if let launchOptions = launchOptions {
       Pushwoosh.sharedInstance().handlePushReceived(launchOptions)
   }
   return true
}
```

Nosso `ViewController` implementa o protocolo `PWMessagingDelegate`:


```swift
extension ViewController: PWMessagingDelegate
```

E, portanto, possui a função `onMessageOpened` que lida com as notificações push recebidas:


```swift
// User pressed on the push notification
func pushwoosh(_ pushwoosh: Pushwoosh, onMessageOpened message: PWMessage) {}
```

## Abrindo outro ViewController e alterando a cor de fundo

Agora estamos obtendo `customData` do payload do push. Por exemplo, vamos alterar a cor de fundo da view e a porcentagem de desconto. Assumimos que os dados personalizados conterão os itens `“r”`, `“g”`, `“b”` e `"d"` em formato de objeto JSON, da seguinte forma:

```swift
guard let customDataJson = message.customData,
      let redString = customDataJson["r"] as? String,
      let greenString = customDataJson["g"] as? String,
      let blueString = customDataJson["b"] as? String,
      let discount = customDataJson["d"] as? String else {
    return
}
setViewBackgroundColor(red: redString, green: greenString, blue: blueString, discount: discount)
```

Usaremos a seguinte função para abrir um novo ViewController e definir a cor de fundo e a porcentagem de desconto:

```swift
func setViewBackgroundColor(red: String, green: String, blue: String, discount: String) {
    let red = CGFloat((red as NSString).floatValue)
    let green = CGFloat((green as NSString).floatValue)
    let blue = CGFloat((blue as NSString).floatValue)

    let color = UIColor(red: red / 255.0, green: green / 255.0, blue: blue / 255.0, alpha: 1)

    if let topController = UIApplication.shared.topMostController() {
        let storyboard = UIStoryboard(name: "Main", bundle: nil)
        if let customViewController = storyboard.instantiateViewController(withIdentifier: "custom_page") as? CustomPageViewController {
            customViewController.discount = discount
            customViewController.bgColor = color
            topController.present(customViewController, animated: true, completion: nil)
        }
    }
}
```

Vamos testar nosso exemplo. Navegue até a Jornada Pushwoosh e adicione um **elemento Push** à tela. Em seguida, clique em **Criar novo conteúdo**. No formulário de conteúdo Push que se abre, insira qualquer texto de notificação push.

<img src="/messaging-channels-using-custom-data-1.webp" alt="Formulário de criação de notificação push no Painel de Controle da Pushwoosh com campo de texto e botão para dados personalizados"/>

Em seguida, ative a opção `Send custom data`. Insira o JSON no campo Custom data.

Como decidimos que nosso formato de dados personalizados seria um objeto JSON com os valores `“r”`, `“g”`, `“b”`, precisamos usar o campo `“custom data”` no Painel de Controle e preenchê-lo com o objeto JSON `{"r":"30", "g":"144", "b":"255", "d":"25"}`:


<img src="/messaging-channels-using-custom-data-2.webp" alt="Campo de dados personalizados no formulário de notificação push mostrando um objeto JSON com valores de cor RGB e parâmetro de desconto"/>

Ao tocar na notificação push, o `CustomPageViewController` é aberto, a cor de fundo é definida e o desconto é aplicado:

<img src="/messaging-channels-using-custom-data-3.webp" alt="View controller de página personalizada exibido com cor de fundo e porcentagem de desconto aplicadas a partir dos dados personalizados da notificação push"/>

Código do CustomPageViewController:

```swift
class CustomPageViewController: UIViewController {

    var bgColor: UIColor?
    var discount: String?

    @IBOutlet weak var titleLabel: UILabel!

    override func viewDidLoad() {
        super.viewDidLoad()

        self.view.backgroundColor = self.bgColor

        if self.discount != nil {
            self.titleLabel?.text = "ONLY TODAY GET \(self.discount!)% DISCOUNT!"
        }
    }

    func showPromoPage(discount: String) {
        let vc = CustomPageViewController()
        vc.bgColor = self.view.backgroundColor
        vc.discount = discount
        vc.modalTransitionStyle = UIModalTransitionStyle.crossDissolve

        if self.presentedViewController != nil {
            self.dismiss(animated: true, completion: {
                self.present(vc, animated: true, completion: nil)
            })
        } else {
            self.present(vc, animated: true, completion: nil)
        }
    }

    @IBAction func closeButtonAction(_ sender: Any) {
        self.dismiss(animated: true)
    }
}
```

Assumimos que o valor do desconto virá como o parâmetro `"d"` no JSON do payload da notificação push. Como os payloads de notificação push são limitados em tamanho, é preferível usar nomes curtos para os parâmetros.

```swift
guard let customDataJson = message.customData,
      let redString = customDataJson["r"] as? String,
      let greenString = customDataJson["g"] as? String,
      let blueString = customDataJson["b"] as? String,
      let discount = customDataJson["d"] as? String else {
    return
}
```

Você pode escrever código para inicializar e abrir diferentes View Controllers dependendo dos parâmetros que você passa no payload da notificação push.


## Abrindo o view controller de teste A/B

Vamos considerar outro caso de uso para dados personalizados em uma notificação push. Por exemplo, precisamos abrir um view controller para um segmento de usuários e outro view controller para um segmento de usuários diferente. Simplificando, podemos usar dados personalizados para testes A/B em seu aplicativo.

Vamos criar dois view controllers. Um controlador (A) será aberto com um valor de desconto, e o segundo controlador (B) será aberto com um parâmetro de desconto diferente.

Agora vamos escrever o código que abrirá o view controller apropriado com base no payload da notificação push:

```swift
func pushwoosh(_ pushwoosh: Pushwoosh, onMessageOpened message: PWMessage) {
    // MARK: - A/B Testing via Custom Data
    guard let customDataJson = message.customData,
          let viewController = customDataJson["vc"] as? String else {
        return
    }

    if viewController == "A" {
        setControllerA()
    } else if viewController == "B" {
        setControllerB()
    }
}

func setControllerA() {
    if let topController = UIApplication.shared.topMostController() {
        let storyboard = UIStoryboard(name: "Main", bundle: nil)
        if let customViewController = storyboard.instantiateViewController(withIdentifier: "a_vc") as? AViewController {
            customViewController.discountA = "50"
            topController.present(customViewController, animated: true, completion: nil)
        }
    }
}

func setControllerB() {
    if let topController = UIApplication.shared.topMostController() {
        let storyboard = UIStoryboard(name: "Main", bundle: nil)
        if let customViewController = storyboard.instantiateViewController(withIdentifier: "b_vc") as? BViewController {
            customViewController.discountB = "100"
            topController.present(customViewController, animated: true, completion: nil)
        }
    }
}
```
Adicione seu JSON ao campo Custom data.
```
{
  "vc": "A"
}

// Choose your Custom Data (A or B)

{
  "vc": "B"
}
```

Dependendo dos dados personalizados que você enviou no payload do push, seja `'vc': 'A'` ou `'vc': 'B'`, um segmento de usuários abrirá um controlador, enquanto outro segmento de usuários abrirá um controlador diferente.

#### View Controller "A"

<img src="/messaging-channels-using-custom-data-4.webp" alt="View Controller A exibindo valor de desconto para o segmento de teste A/B"/>

#### View Controller "B"

<img src="/messaging-channels-using-custom-data-5.webp" alt="View Controller B exibindo valor de desconto diferente para o segmento de teste A/B"/>

## Alterando o ícone do aplicativo via notificação push

Outro exemplo de como podemos usar notificações push no iOS é para alterar o ícone do aplicativo.

Primeiro, vamos adicionar três ícones diferentes aos assets. Um será usado como o ícone padrão do aplicativo, enquanto os outros dois mudarão com base nos dados personalizados na notificação push.

<img src="/messaging-channels-using-custom-data-6.webp" alt="Catálogo de assets do Xcode mostrando três ícones de aplicativo diferentes para troca dinâmica de ícones"/>

Para habilitar ícones de aplicativo alternativos em seu aplicativo iOS, você precisa adicionar a configuração necessária no arquivo `Info.plist`. Aqui estão os passos para fazer isso:

```xml
<key>CFBundleIcons</key>
<dict>
    <key>CFBundleAlternateIcons</key>
    <dict>
        <key>AppIcon-2</key>
        <dict>
            <key>CFBundleIconFiles</key>
            <array>
                <string>Icon-2</string>
            </array>
            <key>UIPrerenderedIcon</key>
            <true/>
        </dict>
        <key>AppIcon-3</key>
        <dict>
            <key>CFBundleIconFiles</key>
            <array>
                <string>Icon-3</string>
            </array>
            <key>UIPrerenderedIcon</key>
            <true/>
        </dict>
    </dict>
    <key>CFBundlePrimaryIcon</key>
    <dict>
        <key>CFBundleIconFiles</key>
        <array>
            <string>Icon-1</string>
        </array>
        <key>UIPrerenderedIcon</key>
        <true/>
    </dict>
</dict>
```

No callback `pushwoosh(_ pushwoosh: Pushwoosh, onMessageOpened message: PWMessage)`, você pode adicionar o código para alterar o ícone do aplicativo com base nos dados personalizados recebidos na notificação push. Veja como você pode implementar isso:

```swift
func pushwoosh(_ pushwoosh: Pushwoosh, onMessageOpened message: PWMessage) {
    // MARK: - Change the app icon dynamically
    guard let customDataJson = message.customData,
          let appIcon = customDataJson["i"] as? String else {
              return
          }

    UIApplication.shared.setAlternateIconName(appIcon) { error in
        if let error = error {
            print(error.localizedDescription)
        } else {
            print("Success!")
        }
    }
}
```
Adicione o código JSON:
```
{
  "i": "AppIcon-2"
}
```

<img src="/messaging-channels-using-custom-data-7.webp" alt="Campo de dados personalizados no formulário de notificação push com objeto JSON especificando o nome do ícone de aplicativo alternativo"/>

Ao tocar na notificação push, o sistema solicitará que você altere o ícone do aplicativo no dispositivo.

<img src="/messaging-channels-using-custom-data-8.webp" alt="Caixa de diálogo do sistema iOS pedindo permissão ao usuário para alterar o ícone do aplicativo no dispositivo"/>


Você pode encontrar o projeto que utiliza dados personalizados no [GitHub](https://github.com/Pushwoosh/pushwoosh-quickstart-ios/tree/main/customdata/newdemo).