# Personalizando o SDK do iOS

## Integração

*   [Deep linking](#deep-linking)
*   [Links Universais](#universal-links)
*   [Rastreamento de compras no aplicativo](#in-app-purchase-tracking)
*   [Notificações push de Geozones](#geozones-push-notifications)
*   [Criando uma fila de Rich Media](#creating-a-rich-media-queue)
*   [Reprodução automática de um vídeo enviado em uma Notificação Rica com force touch](#autoplay-a-video-sent-in-a-rich-notification-with-force-touch)
*   [Som de push personalizado](#custom-push-sound)
*   [Push Provisório do iOS](#ios-provisional-push)

### Deep linking

No seu arquivo **Info.plist**, adicione o array `URL types` com `URL Identifier` e `URL Scheme`.\
No exemplo abaixo, o `URL Scheme` é _com.pushwoosh_ e o `URL Identifier` é _promotion_.

<img src="/ios-push-notifications-customizing-ios-sdk-3.webp" alt=""/>

No seu arquivo App Delegate (geralmente AppDelegate.m para iOS 12 e inferior, ou SceneDelegate.m para iOS 13 e superior), adicione a função de delegate openURL apropriada, conforme descrito no exemplo abaixo. O exemplo verifica a página correta, analisa o valor "id" da URL e abre o PromoPageViewController em resposta.

```AppDelegate.swift```
<Tabs>
<TabItem label="Swift">
```swift
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
    let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
    let page = components?.host
    var promotionId: String?

    if page == "promotion" {
        return
    }

    let items = components?.queryItems ?? []

    for item in items {
        if item.name == "id" {
            promotionId = item.value
        }
    }

    //show PromoPageViewController
}
```
</TabItem>

<TabItem label="Objective-C">
```objective-c
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
    NSURLComponents *components = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:NO];
    NSString *page = components.host;
    NSString *promotionId = nil;

    //return if this is not a promotion deep link
    if(![page isEqualToString:@"promotion"])
        return NO;

    for(NSURLQueryItem *item in components.queryItems)
    {
        if([item.name isEqualToString:@"id"])
            promotionId = item.value;
    }

    PromoPageViewController *vc = [[PromoPageViewController alloc] init];
    vc.promotionId = promotionId
    [self presentViewController:vc animated:YES completion:nil];
}
```
</TabItem>
</Tabs>

```SceneDelegate.swift```
<Tabs>
<TabItem label="Swift">
```swift
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let urlContext = URLContexts.first else { return }
        
    let components = URLComponents(url: urlContext.url, resolvingAgainstBaseURL: false)
    let page = components?.host
    var promotionId: String?
        
    guard page == "promotion" else {
        return
    }
        
    let items = components?.queryItems ?? []
        
    for item in items {
        if item.name == "id" {
            promotionId = item.value
        }
    }
        
    //show PromoPageViewController
}
```
</TabItem>

<TabItem label="Objective-C">
```objective-c
- (void)scene:(UIWindowScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
    UIOpenURLContext *urlContext = URLContexts.anyObject;
    if (!urlContext) {
        return;
    }

    NSURLComponents *components = [NSURLComponents componentsWithURL:urlContext.URL resolvingAgainstBaseURL:NO];
    NSString *page = components.host;
    NSString *promotionId = nil;

    if (![page isEqualToString:@"promotion"]) {
        return;
    }

    for (NSURLQueryItem *item in components.queryItems) {
        if ([item.name isEqualToString:@"id"]) {
            promotionId = item.value;
        }
    }

    //show PromoPageViewController
}
```

</TabItem>
</Tabs>

### Links Universais

Os Links Universais permitem que os usuários abram seu aplicativo diretamente quando tocam em um link para o seu site. Diferente dos esquemas de URL personalizados, os Links Universais usam URLs `https://` padrão e fornecem uma experiência de usuário mais fluida.

<Aside type="note">
A partir da **versão 7.0.15 do SDK**, o SDK do iOS da Pushwoosh roteia automaticamente os Links Universais de notificações push para os manipuladores do seu aplicativo, em vez de abri-los no Safari.
</Aside>

#### Como funciona

Quando uma notificação push contém uma URL `https://` (no parâmetro "url" ou "l"), o SDK irá:

1.  Criar um `NSUserActivity` com a URL
2.  Chamar o manipulador de Links Universais do seu aplicativo (`scene:continueUserActivity:` ou `application:continueUserActivity:restorationHandler:`)
3.  Se o seu aplicativo não manipular a URL, ela será aberta no Safari como um fallback

#### Configuração

1.  **Configure os Domínios Associados no Xcode**

Adicione a capacidade de Domínios Associados ao seu aplicativo e adicione seu domínio:

```
applinks:yourdomain.com
```

2.  **Hospede o arquivo de Associação de Site de Aplicativo da Apple**

Crie um arquivo `apple-app-site-association` no seu servidor web em `https://yourdomain.com/.well-known/apple-app-site-association`:

```json
{
  "applinks": {
    "apps": [],
    "details": [
      {
        "appID": "TEAM_ID.com.your.bundleid",
        "paths": ["/path/*", "/promotion/*"]
      }
    ]
  }
}
```

Substitua `TEAM_ID` pelo seu ID de Equipe de Desenvolvedor da Apple e `com.your.bundleid` pelo identificador de pacote do seu aplicativo.

3.  **Implemente o manipulador de Links Universais**

```SceneDelegate.swift``` (iOS 13+)
<Tabs>
<TabItem label="Swift">
```swift
func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
          let url = userActivity.webpageURL else {
        return
    }

    // Handle the Universal Link URL
    let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
    let path = components?.path

    if path?.starts(with: "/promotion") == true {
        // Navigate to promotion screen
        let promotionId = components?.queryItems?.first(where: { $0.name == "id" })?.value
        // Show promotion with promotionId
    }
}
```
</TabItem>

<TabItem label="Objective-C">
```objective-c
- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity {
    if (![userActivity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb]) {
        return;
    }

    NSURL *url = userActivity.webpageURL;
    if (!url) {
        return;
    }

    // Handle the Universal Link URL
    NSURLComponents *components = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:NO];
    NSString *path = components.path;

    if ([path hasPrefix:@"/promotion"]) {
        // Navigate to promotion screen
        NSString *promotionId = nil;
        for (NSURLQueryItem *item in components.queryItems) {
            if ([item.name isEqualToString:@"id"]) {
                promotionId = item.value;
                break;
            }
        }
        // Show promotion with promotionId
    }
}
```
</TabItem>
</Tabs>

```AppDelegate.swift``` (iOS 12 e anterior, ou como fallback)
<Tabs>
<TabItem label="Swift">
```swift
func application(_ application: UIApplication,
                 continue userActivity: NSUserActivity,
                 restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
          let url = userActivity.webpageURL else {
        return false
    }

    // Handle the Universal Link URL
    let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
    let path = components?.path

    if path?.starts(with: "/promotion") == true {
        // Navigate to promotion screen
        return true
    }

    return false
}
```
</TabItem>

<TabItem label="Objective-C">
```objective-c
- (BOOL)application:(UIApplication *)application
        continueUserActivity:(NSUserActivity *)userActivity
          restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> *restorableObjects))restorationHandler {

    if (![userActivity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb]) {
        return NO;
    }

    NSURL *url = userActivity.webpageURL;
    if (!url) {
        return NO;
    }

    // Handle the Universal Link URL
    NSURLComponents *components = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:NO];
    NSString *path = components.path;

    if ([path hasPrefix:@"/promotion"]) {
        // Navigate to promotion screen
        return YES;
    }

    return NO;
}
```
</TabItem>
</Tabs>

#### Enviando push com Link Universal

Ao criar uma notificação push, use a URL do seu site no campo **Ação**:

```
https://yourdomain.com/promotion?id=123
```

O SDK roteará automaticamente esta URL para o seu manipulador de Links Universais, permitindo que você navegue o usuário para a tela apropriada em seu aplicativo.

<Aside type="tip">
Os Links Universais proporcionam uma melhor experiência do usuário do que os esquemas de URL personalizados porque funcionam mesmo que seu aplicativo não esteja instalado — o usuário será levado para o seu site.
</Aside>

### Rastreamento de compras no aplicativo

Por padrão, o rastreamento de compras no aplicativo está desativado. Se você deseja rastrear compras no aplicativo ao configurar [Customer Journeys](/pt/product/customer-journey/pushwoosh-journey-overview), defina a flag _Pushwoosh\_PURCHASE\_TRACKING\_ENABLED_ como _true_ no arquivo _info.plist_. Você pode encontrar uma lista de flags disponíveis na [tabela](/pt/developer/pushwoosh-sdk/ios-sdk/setting-up-pushwoosh-ios-sdk/advanced-integration-guide/#complete-list-of-infoplist-properties).

Se você deseja rastrear compras no aplicativo manualmente, pode usar o código abaixo.

No método de delegate `paymentQueue:updatedTransactions:`, chame o método `sendSKPaymentTransactions` do `PushManager`

<Tabs>
<TabItem label="Swift">
```swift
 func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
     // In-Apps Tracking Pushwoosh code here
     Pushwoosh.sharedInstance().sendSKPaymentTransactions(transactions)
     // the rest of the code, consume transactions, etc
 }
```
</TabItem>

<TabItem label="Objective-C">
```objective-c
- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions {

  [[PushNotificationManager pushManager] sendSKPaymentTransactions:transactions];

  //the rest of the code, consume transactions, etc
}
```
</TabItem>
</Tabs>

<img src="/ios-push-notifications-customizing-ios-sdk-4.webp" alt="InAppTrackingViewController.swift"/>

<LinkCard title="Exemplo" href="https://github.com/Pushwoosh/pushwoosh-quickstart-ios/blob/main/customizing/customizing/In-Apps%20Tracking/InAppTrackingViewController.swift" />

### Notificações push de Geozones

As notificações push de Geozones são encapsuladas em um framework separado **PushwooshGeozones**.

1.  Adicione o PushwooshGeozones.framework ao seu projeto

Para adicionar o PushwooshGeozones.framework ao seu projeto usando um gerenciador de dependências, coloque as seguintes linhas no seu `podfile` ou `cartfile`:

<Tabs>
  <TabItem value="podfile" label="Podfile">

  ```plaintext
  pod 'PushwooshXCFramework/Geozones'
  ```

  </TabItem>
  
  <TabItem value="carfile" label="Carfile">

  ```plaintext
  github "Pushwoosh/pushwoosh-ios-sdk"
  ```

  </TabItem>
  
  <TabItem value="swiftpm" label="SwiftPM">
  
  Se você quiser usar **PushwooshGeozones.xcframework**, insira a seguinte URL do Pacote:  
  [PushwooshGeozones-XCFramework](https://github.com/Pushwoosh/PushwooshGeozones-XCFramework)  

  </TabItem>
</Tabs>

Alternativamente, você pode simplesmente arrastar e soltar o framework em **Link Binaries With Libraries** nas **Build Phases** do seu projeto.

2.  Adicione as seguintes chaves ao seu Info.plist:

*   **NSLocationWhenInUseUsageDescription** – *(obrigatório)* para o aplicativo rastrear Geozones apenas enquanto estiver em primeiro plano.
*   **NSLocationAlwaysAndWhenInUseUsageDescription** – *(obrigatório)* para o aplicativo rastrear Geozones **tanto em primeiro plano quanto em segundo plano** e para mostrar um pop-up de diálogo de solicitação de permissão.
*   **NSLocationAlwaysUsageDescription** – *(opcional)* para o aplicativo rastrear Geozones **o tempo todo**; deve ser usado se seu aplicativo for direcionado para iOS 10 e versões anteriores.

```xml
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>for app to track Geozones in both conditions and to show a permission request dialog</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>for app to track Geozones only while running in the foreground</string>
```
![]()

<LinkCard title="Exemplo de Info.plist da Pushwoosh" href="https://github.com/Pushwoosh/pushwoosh-quickstart-ios/blob/main/customizing/customizingObjC/customizingObjC/Info.plist" />

3.  Importe o framework

<Tabs>
  <TabItem value="swift" label="Swift">

  ```swift
  import PushwooshGeozones
  ```

  </TabItem>
  
  <TabItem value="objective-c" label="Objective-C">

  ```objc
  #import <PushwooshGeozones/PWGeozonesManager.h>
  ```

  </TabItem>
</Tabs>

4.  Inicie o rastreamento de Geozones

<Tabs>
  <TabItem value="swift" label="Swift">

  ```swift
  PWGeozonesManager.shared()?.startLocationTracking()
  ```

  [Referência do GitHub](https://github.com/Pushwoosh/pushwoosh-quickstart-ios/blob/main/customizing/customizing/Geozones%20Push%20Notification/GeozonesViewController.swift)

  </TabItem>
  
  <TabItem value="objective-c" label="Objective-C">

  ```objc
  [[PWGeozonesManager sharedManager] startLocationTracking];
  ```

  [Referência do GitHub](https://github.com/Pushwoosh/pushwoosh-quickstart-ios/blob/main/customizing/customizingObjC/customizingObjC/Geozones%20Push%20Notification/PWGeozonesViewController.m)

  </TabItem>
</Tabs>

##### Exemplo
<Tabs>
  <TabItem value="swift" label="Exemplo em Swift">

  ```swift
  override func viewDidLoad() {
      super.viewDidLoad()

      // Start Geozones tracking when needed
      PWGeozonesManager.shared().startLocationTracking()
  }
  ```

  </TabItem>
  
  <TabItem value="objective-c" label="Exemplo em Objective-C">

  ```objc
  - (void)viewDidLoad {
      [super viewDidLoad];
      // Do any additional setup after loading the view.

      // Start Geozones tracking when needed
      [[PWGeozonesManager sharedManager] startLocationTracking];
  }
  ```

  </TabItem>
</Tabs>

### Criando uma fila de Rich Media

Caso haja várias páginas de Rich Media para exibir simultaneamente (por exemplo, eventos de gatilho para dois ou mais In-Apps ocorrem ao mesmo tempo, ou uma página de Rich Media já está sendo exibida no momento em que um evento de gatilho diferente ocorre), você pode configurar uma fila para a exibição de páginas de Rich Media. Para criar uma fila, siga os passos descritos abaixo.

1.  Crie uma classe que implemente PWRichMediaPresentingDelegate:

```objective-c
@interface ChainedRichMediaPresentingDelegate () <PWRichMediaPresentingDelegate>

@property (nonatomic) NSMutableArray *queue;

@property (nonatomic) BOOL inAppIsPresenting;

@end


@implementation ChainedRichMediaPresentingDelegate

- (instancetype)init {
    self = [super init];

    if (self) {
        _queue = [NSMutableArray new];
    }

    return self;
}

- (BOOL)richMediaManager:(PWRichMediaManager *)richMediaManager shouldPresentRichMedia:(PWRichMedia *)richMedia {
    [_queue addObject:richMedia];
    return !_inAppIsPresenting;
}

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

- (void)richMediaManager:(PWRichMediaManager *)richMediaManager didCloseRichMedia:(PWRichMedia *)richMedia {
    _inAppIsPresenting = NO;

    [_queue removeObject:richMedia];

    if (_queue.count) {
        [[PWRichMediaManager sharedManager] presentRichMedia:_queue.firstObject];
    }
}

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

@end
```

2.  Defina o delegate:

```objective-c
 [PWRichMediaManager sharedManager].delegate = [ChainedRichMediaPresentingDelegate new];
```

<Tabs>
<TabItem label="Swift (GitHub)">
<LinkCard title="Exemplo" href="https://github.com/Pushwoosh/pushwoosh-quickstart-ios/tree/main/customizing/customizing/Rich%20Media%20Queue" />
</TabItem>

<TabItem label="Objective-C (GitHub)">
<LinkCard title="Exemplo" href="https://github.com/Pushwoosh/pushwoosh-quickstart-ios/tree/main/customizing/customizingObjC/customizingObjC/Rich%20Media%20Queue" />
</TabItem>
</Tabs>

### Reprodução automática de um vídeo enviado em uma Notificação Rica com force touch

Para fazer com que um vídeo enviado como um [anexo de Notificação Rica](/pt/developer/pushwoosh-sdk/ios-sdk/ios-rich-notifications-integration/) seja reproduzido automaticamente quando a notificação é expandida sem qualquer interação do usuário, siga os passos abaixo:

1.  Adicione a Extensão de Conteúdo de Notificação ao seu projeto:

*   No Xcode, selecione File > New > Target.
*   Escolha Notification Content Extension.
*   Atribua um nome e complete a configuração.

<img src="/ios-push-notifications-customizing-ios-sdk-5.webp" alt="Extensão de Conteúdo de Notificação - Notificação Push Rica do iOS"/>

Se aparecer a mensagem "Ativar esquema", escolha Cancelar.

<img
  src="/ios-push-notifications-customizing-ios-sdk-6.webp"
  alt="Ativar Esquema de Conteúdo de Notificação"
  style={{ display: "block", margin: "0 auto", maxWidth: "40%", height: "auto" }}
  width="400"
/>

2.  Ajuste as propriedades e métodos na Extensão de Conteúdo da seguinte forma:

```
import UIKit
import UserNotifications
import UserNotificationsUI
import AVKit


class NotificationViewController: UIViewController, UNNotificationContentExtension {
    var playerController: AVPlayerViewController!
    @IBOutlet weak var playerBackgroundView: UIView!

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any required interface initialization here.
    }

    func didReceive(_ notification: UNNotification) {
        let attachment = notification.request.content.attachments.first

        playerController = AVPlayerViewController()
        // Set height programmatically
        // preferredContentSize.height = 250

        if let url = attachment?.url {
            setupVideoPlayer(url: url)
        } else {
            print("No valid URL...")
        }
    }

    private func setupVideoPlayer(url: URL) {
        guard let playerController = self.playerController else { return }
        let player = AVPlayer(url: url)
        playerController.player = player
        playerController.view.frame = self.playerBackgroundView.bounds
        playerBackgroundView.addSubview(playerController.view)
        addChild(playerController)
        playerController.didMove(toParent: self)
        player.play()
    }
```

3.  Incorpore uma UIView no MainInterface.storyboard:

<img src="/ios-push-notifications-customizing-ios-sdk-7.webp" alt="UIView no MainInterface.storyboard"/>

4.  Vincule o IBOutlet playerBackgroundView com a UIView que você acabou de adicionar:

<img src="/ios-push-notifications-customizing-ios-sdk-8.webp" alt="Vincule o IBOutlet playerBackgroundView com a UIView"/>

5.  Atualize o arquivo info.plist com a seguinte entrada:

```
UNNotificationExtensionUserInteractionEnabled = true
```

<img src="/ios-push-notifications-customizing-ios-sdk-9.webp" alt="UNNotificationExtensionUserInteractionEnabled = true"/>

Para anexar um vídeo à sua notificação, insira a URL de um vídeo no campo Anexo de Mídia no Painel de Controle:

<img src="/ios-push-notifications-customizing-ios-sdk-10.webp" alt="URL do vídeo no campo Anexo de Mídia no Painel de Controle da Pushwoosh"/>

Ao enviar uma notificação via solicitação da API [/createMessage](/pt/developer/api-reference/messages-api#createmessage), inclua a URL no parâmetro "ios\_attachment" e certifique-se de que a flag "mutable-content" esteja definida como \`1\`.

<Aside type="note">
Para testar o recurso de reprodução automática, você pode usar o seguinte vídeo de amostra: [Vídeo de Amostra Hello World](https://docs-assets.developer.apple.com/published/efa8e7a0a97cfab20bf0f4c307b9b121/Hello-World-overview.mp4).
</Aside>

<video src="/ios-push-notifications-customizing-ios-sdk-11.webm" title="Vídeo de Amostra Hello World" autoplay loop muted playsinline />

### Som de push personalizado

Para reproduzir um som personalizado ao receber uma notificação push, primeiro coloque o arquivo de áudio na pasta raiz do seu projeto.

<img
  src="/ios-push-notifications-customizing-ios-sdk-12.webp"
  alt=""
  style={{ display: "block", margin: "0 auto", maxWidth: "40%", height: "auto" }}
  width="400"
/>

Em seguida, especifique o nome do arquivo de som nos parâmetros do push – preencha o campo Som das [configurações específicas do iOS](/pt/product/messaging-channels/push-notifications/send-push-notifications/one-time-push#ios) da sua mensagem ou especifique o nome do arquivo como um valor para o parâmetro "ios\_sound" da [solicitação da API createMessage](/pt/developer/api-reference/messages-api/).

O arquivo de áudio para som personalizado do iOS deve estar em um dos seguintes formatos: **.aif**, **.caf**, **.wav**. **Certifique-se de especificar o formato no nome do arquivo; caso contrário, ele será ignorado pelo SDK do iOS da Pushwoosh.**

<Aside type="tip">
Considere as limitações da App Store sobre o tamanho do pacote ao adicionar o arquivo de som ao seu pacote.
</Aside>

### Push Provisório do iOS

<Aside>
Compatível com iOS 12 e posterior.
</Aside>

#### Como funciona

As notificações push provisórias aparecem silenciosamente na Central de Notificações do usuário, mas não na tela de bloqueio. Este tipo de push não precisa ser permitido explicitamente por um usuário: você pode começar a enviá-los assim que um usuário instalar e iniciar seu aplicativo.

No entanto, os usuários ainda podem se inscrever para receber suas notificações push proeminentes: ao abrir o Push Provisório, eles têm duas opções para escolher sua experiência – manter os pushes na Central de Notificações sem alertas e sons ou permitir que você envie pushes de forma proeminente para que apareçam na tela de bloqueio.

Os Pushes Provisórios são projetados para permitir que os usuários tomem decisões informadas sobre se gostariam de receber notificações do seu aplicativo. Como a solicitação de inscrição nativa da APN é mostrada aos usuários apenas uma vez e para se inscreverem mais tarde, eles devem ir para as configurações do sistema de seus telefones, e alguns usuários podem não se inscrever por não saberem o valor que recebem com seus pushes. Os Pushes Provisórios dão aos usuários esse entendimento: eles podem ver qual conteúdo você entrega em notificações push e decidir se precisam ser notificados sobre esse conteúdo de forma proeminente.

<Aside type="caution" title="Importante">
Por favor, note que os Pushes Provisórios, quando implementados, substituem o prompt nativo da APN, o que significa que os usuários não podem se inscrever para notificações proeminentes até que abram sua Central de Notificações e escolham receber os Pushes Provisórios como proeminentes.
</Aside>

#### Como implementar

1.  Integre o SDK do iOS da Pushwoosh seguindo o [guia](/pt/developer/pushwoosh-sdk/ios-sdk/setting-up-pushwoosh-ios-sdk/quick-start/).

2.  Adicione a seguinte string ao AppDelegate do seu projeto antes de chamar o método `registerForPushNotifications()`:

<Tabs>
<TabItem label="Swift">
```swift
if #available(iOS 12.0, *) {
    Pushwoosh.sharedInstance().additionalAuthorizationOptions = UNAuthorizationOptions.provisional
}
```

<LinkCard title="Exemplo" href="https://github.com/Pushwoosh/pushwoosh-quickstart-ios/blob/main/provisionalpush/provisionalpush/AppDelegate/AppDelegate.swift" />
</TabItem>

<TabItem label="Objective-C">
```objective-c
if (@available(iOS 12.0, *)) {
	[Pushwoosh sharedInstance].additionalAuthorizationOptions = UNAuthorizationOptionProvisional;
}
```

<LinkCard title="Exemplo" href="https://github.com/Pushwoosh/pushwoosh-quickstart-ios/blob/main/provisionalpush/provisionalpushObjC/provisionalpushObjC/AppDelegate/AppDelegate.m" />
</TabItem>
</Tabs>

É isso! Os usuários do aplicativo receberão mensagens diretamente na Central de Notificações assim que instalarem o aplicativo.

### Compartilhe seu feedback conosco

Seu feedback nos ajuda a criar uma experiência melhor, então adoraríamos ouvir de você se tiver algum problema durante o processo de integração do SDK. Se você enfrentar alguma dificuldade, não hesite em compartilhar suas opiniões conosco [através deste formulário](https://docs.google.com/forms/d/e/1FAIpQLSd_0b8jwn-V_JmoPLIxIFYbHACCQhrzidOZV3ELywoQPXRSxw/viewform).