> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Extensões de Serviço Móvel

> Implemente as extensões de serviço de notificação iOS e Android em seu aplicativo.

As Extensões de Serviço de Notificação permitem que você intercepte e modifique notificações push antes de serem exibidas ao usuário. Isso habilita o manuseio de dados em segundo plano, estilos personalizados, anexos de rich media, entrega confirmada e opções de botões de ação.

<Note>
  Você pode acessar os dados em suas notificações push enviadas do OneSignal através da [classe OSNotification](./osnotification-payload)
</Note>

***

## Extensão de Serviço de Notificação do Android

Permite que você processe a notificação antes de ser mostrada ao usuário. Casos de uso comuns incluem:

* Receber dados em segundo plano com ou sem exibir uma notificação.
* Substituir configurações específicas de notificação dependendo da lógica do aplicativo do lado do cliente, como cor de destaque personalizada, padrão de vibração ou qualquer outra opção `NotificationCompat` disponível.

Para mais detalhes, consulte a [documentação do Android sobre as opções do NotificationCompat.](https://developer.android.com/reference/androidx/core/app/NotificationCompat)

### Passo 1: Criar uma classe para a extensão de serviço

Crie uma classe que implementa `INotificationServiceExtension` e implemente o método `onNotificationReceived`.

O parâmetro do método `onNotificationReceived` é `event` do tipo [INotificationReceivedEvent](https://github.com/OneSignal/OneSignal-Android-SDK/blob/25924dc3739fbe3ae64a73efc7b504449a18cdea/OneSignalSDK/onesignal/core/src/main/java/com/onesignal/notifications/INotificationReceivedEvent.kt#L46).

<CodeGroup>
  ```Java Java theme={null}
  package your.package.name

  import androidx.annotation.Keep;
  import com.onesignal.notifications.IActionButton;
  import com.onesignal.notifications.IDisplayableMutableNotification;
  import com.onesignal.notifications.INotificationReceivedEvent;
  import com.onesignal.notifications.INotificationServiceExtension;

  @Keep // Keep is required to prevent minification from renaming or removing your class
  public class NotificationServiceExtension implements INotificationServiceExtension {

       @Override
       public void onNotificationReceived(INotificationReceivedEvent event) {
          IDisplayableMutableNotification notification = event.getNotification();

          if (notification.getActionButtons() != null) {
             for (IActionButton button : notification.getActionButtons()) {
                // you can modify your action buttons here
             }
          }

       /* Add customizations here. See examples below for additional methods to modify the notification*/
       }
  }

  ```

  ```kotlin Kotlin theme={null}
  package your.package.name

  import androidx.annotation.Keep
  import com.onesignal.notifications.INotificationReceivedEvent
  import com.onesignal.notifications.INotificationServiceExtension

  @Keep
  class NotificationServiceExtension : INotificationServiceExtension {
      override fun onNotificationReceived(event: INotificationReceivedEvent) {
          val notification = event.notification
          val context = event.context

          notification.actionButtons?.forEach { button ->
              // Modify action buttons here
          }
      }
  }
  ```
</CodeGroup>

<Note>
  A anotação `@Keep` é necessária para evitar que o ProGuard ou o R8 renomeie ou remova sua classe durante a minificação.
</Note>

### Passo 2: Personalizar a notificação

Os exemplos a seguir mostram personalizações comuns que você pode implementar na classe de Extensão de Serviço de Notificação.

<Tabs>
  <Tab title="Impedir que a notificação seja exibida">
    Use `event.preventDefault()` para suprimir a exibição da notificação. Em seguida, você pode chamar `event.getNotification().display()` para exibi-la mais tarde, ou nunca chamá-la para descartá-la silenciosamente.

    <CodeGroup>
      ```Java Java theme={null}
      event.preventDefault();

      //Do some async work, then decide to show or dismiss
      new Thread(() -> {
          try {
              Thread.sleep(1000);
          } catch (InterruptedException ignored) {}

          //Manually show the notification
          event.getNotification().display();
      }).start();
      ```

      ```Kotlin Kotlin theme={null}
      event.preventDefault()

      //Do some async work, then decide to show or dismiss
      Thread{
          try {
              Thread.sleep(1000)
          } catch (ingored: InterruptedException) {}

          //Manually show the notification
          event.notification.display()
      }.start()

      ```
    </CodeGroup>

    <Warning>
      Chamar `event.preventDefault()` sem nunca chamar `display()` descartará a notificação silenciosamente. Se a intenção for suprimir permanentemente, isso é esperado. Para mais informações, consulte [Notificações duplicadas](./duplicated-notifications#android-notification-service-extension).
    </Warning>
  </Tab>

  <Tab title="Adicionar um campo personalizado">
    <CodeGroup>
      ```Java Java theme={null}
      String promoCode = notification.getAdditionalData() != null
          ? notification.getAdditionalData().optString("promo_code", null) 
          : null;

      if (promoCode != null) {
          String updatedBody = notification.getBody() + " Use code: " + promoCode;
          notification.setExtender(builder -> {
              builder.setContentText(updatedBody);
          });
      }
      ```

      ```Kotlin Kotlin theme={null}
      val promoCode = notification.additionalData?.optString("promo_code", null)

      promoCode?.let {
          val updatedBody = "${notification.body}\nUse code: $promoCode"
          notification.setExtender { builder ->
              builder.setContentText(updatedBody)
          }
      }

      ```
    </CodeGroup>
  </Tab>

  <Tab title="Alterar a cor e o ícone da notificação">
    <CodeGroup>
      ```Java Java theme={null}
      int iconResId = R.drawable.icon_default; 
      String type = notitifcation.getAdditionalData() != null
          ? notification.getAdditionalData().optString("type", "") 
          : "";

      switch (type) {
          case "sale":
              iconResId = R.drawable.icon_sale;
              break;
          case "reminder":
              iconResId = R.drawable.icon_reminder;
              break;
      }

      int finalIconResId = iconResId;
      notification.setExtender(builder -> {
          builder.setColor(0xFF0000FF).setSmallIcon(finalIconResId);
      });

      ```

      ```Kotlin Kotlin theme={null}
      val type = notification.additionalData?.optString("type", "") ?: ""

      val iconResId = when (type) {
      "sale" -> R.drawable.icon_sale
          "reminder" -> R.drawable.icon_reminder
          else -> R.drawable.icon_default
      }

      notification.setExtender { builder ->
          builder.setColor(0xFF0000FF).setSmallIcon(iconResId)
      }

      ```
    </CodeGroup>

    <Note>
      Os ícones referenciados aqui devem existir no diretório `res/drawable` do seu projeto Android.
    </Note>
  </Tab>
</Tabs>

### Passo 3: Adicionar a extensão de serviço ao seu `AndroidManifest.xml`

Adicione o nome da classe e o valor como `meta-data` dentro do arquivo `AndroidManifest.xml` na tag do aplicativo. Ignore quaisquer avisos de "não utilizado".

```XML XML theme={null}
<application>
  <meta-data
    android:name="com.onesignal.NotificationServiceExtension"
    android:value="com.onesignal.example.NotificationServiceExtension" />
</application>
```

Substitua `com.onesignal.example.NotificationServiceExtension` pelo nome totalmente qualificado da sua classe.

***

## Extensão de Serviço de Notificação do iOS

A [UNNotificationServiceExtension](https://developer.apple.com/reference/usernotifications/unnotificationserviceextension) permite que você modifique o conteúdo das notificações push antes de serem exibidas ao usuário e é necessária para outros recursos importantes como:

* [Imagens e Rich Media](./rich-media).
* [Entrega Confirmada](./confirmed-delivery)
* [Badges](./badges)
* [Botões de Ação](./action-buttons)
* [Aberturas Influenciadas com Firebase Analytics](./google-analytics-for-firebase)

Você provavelmente já configurou isso se seguiu nossas instruções de [configuração do SDK Móvel](./mobile-sdk-setup) para seu aplicativo, mas esta seção explicará como acessar os dados de payload de notificação do OneSignal e solucionar quaisquer problemas que você possa estar tendo.

### Obtendo o payload de push do iOS

O override `didReceive(_:withContentHandler:)` chama `OneSignalExtension.didReceiveNotificationExtensionRequest`, que passa o `bestAttemptContent` para o OneSignal antes de ser exibido ao usuário. Você pode ler ou modificar `bestAttemptContent` antes que esse método seja chamado.

Neste exemplo, enviamos uma notificação com os seguintes dados:

```json JSON theme={null}
{
  "app_id": "YOUR_APP_ID",
  "target_channel": "push",
  "headings": {"en": "The message title"},
  "contents": {"en": "The message contents"},
  "data":{
    "additional_data_key_1":"value_1",
    "additional_data_key_2":"value_2"
    },
  "include_subscription_ids": ["SUBSCRIPTION_ID_1"]
}
```

Acesse estes `data` adicionais dentro da OneSignalNotificationServiceExtension através da chave `a` dentro do dicionário `custom` de `userInfo`:

<CodeGroup>
  ```swift Swift theme={null}
  if let bestAttemptContent = bestAttemptContent {

      if let customData = bestAttemptContent.userInfo["custom"] as? [String: Any],
         let additionalData = customData["a"] as? [String: Any] {

          if let jsonData = try? JSONSerialization.data(withJSONObject: additionalData, options: .prettyPrinted),
             let jsonString = String(data: jsonData, encoding: .utf8) {
              print("The additionalData dictionary in JSON format:\n\(jsonString)")
          } else {
              print("Failed to convert additionalData to JSON format.")
          }
      }

      if let messageData = bestAttemptContent.userInfo["aps"] as? [String: Any],
         let apsData = messageData["alert"] as? [String: Any],
         let body = apsData["body"] as? String,
         let title = apsData["title"] as? String {
          print("The message contents is: \(body), message headings is: \(title)")
      } else {
          print("Unable to retrieve apsData")
      }

      OneSignalExtension.didReceiveNotificationExtensionRequest(self.receivedRequest,
                                                                with: bestAttemptContent,
                                                                withContentHandler: self.contentHandler)
  }
  ```

  ```objc Objective-C theme={null}
  if (bestAttemptContent) {
      NSDictionary *customData = bestAttemptContent.userInfo[@"custom"];
      if ([customData isKindOfClass:[NSDictionary class]]) {
          NSDictionary *additionalData = customData[@"a"];
          if ([additionalData isKindOfClass:[NSDictionary class]]) {
              NSError *error;
              NSData *jsonData = [NSJSONSerialization dataWithJSONObject:additionalData options:NSJSONWritingPrettyPrinted error:&error];
              if (jsonData) {
                  NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
                  NSLog(@"The additionalData dictionary in JSON format:\n%@", jsonString);
              } else {
                  NSLog(@"Failed to convert additionalData to JSON format: %@", error.localizedDescription);
              }
          }
      }

      NSDictionary *messageData = bestAttemptContent.userInfo[@"aps"];
      if ([messageData isKindOfClass:[NSDictionary class]]) {
          NSDictionary *apsData = messageData[@"alert"];
          if ([apsData isKindOfClass:[NSDictionary class]]) {
              NSString *body = apsData[@"body"];
              NSString *title = apsData[@"title"];
              if ([body isKindOfClass:[NSString class]] && [title isKindOfClass:[NSString class]]) {
                  NSLog(@"The message content is: %@, message heading is: %@", body, title);
              }
          } else {
              NSLog(@"Unable to retrieve apsData");
          }
      }

      [OneSignalExtension didReceiveNotificationExtensionRequest:self.receivedRequest
                                               withNotification:bestAttemptContent
                                                withContentHandler:self.contentHandler];
  }
  ```
</CodeGroup>

**Exemplo de saída do console:**

```
The additionalData dictionary in JSON format:
{
  "additional_data_key_1" : "value_1",
  "additional_data_key_2" : "value_2"
}
The message contents is: The message contents, message headings is: The message title
```

### Solução de problemas da Extensão de Serviço de Notificação do iOS

Este guia é para depurar problemas com Imagens, Botões de Ação ou Entregas Confirmadas que não aparecem em aplicativos móveis iOS.

#### Verifique suas Configurações do Xcode

Em **General > Targets**, certifique-se de que seu **main app target** e o target **OneSignalNotificationServiceExtension** tenham os mesmos e corretos:

* **Supported Destinations**
* **Minimum Deployment** (iOS 14.5 ou superior)

<Warning>
  Se você estiver usando Cocoapods, certifique-se de que eles correspondam ao seu target principal no Podfile para evitar erros de compilação.
</Warning>

<Frame caption="Exemplo de Main App Target no Xcode">
  <img src="https://mintcdn.com/onesignal/RWA35uTjv8voG5iC/images/mobile/main-app-target-general-settings.png?fit=max&auto=format&n=RWA35uTjv8voG5iC&q=85&s=eb9dd4d9dbec5f2b9f351ff168087557" alt="Xcode General tab showing Supported Destinations and Minimum Deployment for the main app target" width="2988" height="1824" data-path="images/mobile/main-app-target-general-settings.png" />
</Frame>

<Frame caption="Exemplo de Target OneSignalNotificationServiceExtension no Xcode">
  <img src="https://mintcdn.com/onesignal/x4RdPY-EcasyyQ-o/images/mobile/onesignal-notification-service-extension-target-general-settings.png?fit=max&auto=format&n=x4RdPY-EcasyyQ-o&q=85&s=ea6f697fda7b4a338bb7e3a4dac3856f" alt="Xcode General tab showing Supported Destinations and Minimum Deployment for the notification service extension target" width="2988" height="1824" data-path="images/mobile/onesignal-notification-service-extension-target-general-settings.png" />
</Frame>

Continuando na aba **OneSignalNotificationServiceExtension > Info**, expanda a chave `NSExtension`. Certifique-se de ver:

```XML XML theme={null}
 <dict>
   <key>NSExtensionPointIdentifier</key>
   <string>com.apple.usernotifications.service</string>
   <key>NSExtensionPrincipalClass</key>
   <string>$(PRODUCT_MODULE_NAME).NotificationService</string>
 </dict>
```

Exemplo:

<Frame caption="Exemplo da chave NSExtension na aba Info">
  <img src="https://mintcdn.com/onesignal/RWA35uTjv8voG5iC/images/mobile/onesignal-notification-service-extension-info-tab.png?fit=max&auto=format&n=RWA35uTjv8voG5iC&q=85&s=06e65f878427e94127ef7391903d583e" alt="Xcode Info tab showing the NSExtension dictionary with NSExtensionPointIdentifier and NSExtensionPrincipalClass keys" width="3282" height="1888" data-path="images/mobile/onesignal-notification-service-extension-info-tab.png" />
</Frame>

<Warning>
  Se estiver usando Objective-C, em vez de `$(PRODUCT_MODULE_NAME).NotificationService` use `NotificationService`.
</Warning>

#### Desative "Copy only when installing"

Selecione seu **main app target > Build Phases > Embed App Extensions**. Certifique-se de que "Copy only when installing" NÃO esteja marcado. Desmarque-o se estiver:

<Frame caption="Configurações de build phase do main app target">
  <img src="https://mintcdn.com/onesignal/RWA35uTjv8voG5iC/images/mobile/main-app-target-build-phases.png?fit=max&auto=format&n=RWA35uTjv8voG5iC&q=85&s=cd507862b8e5bb0934b6f6b082d0b26e" alt="Xcode Build Phases tab showing Embed App Extensions with Copy only when installing unchecked" width="3282" height="1888" data-path="images/mobile/main-app-target-build-phases.png" />
</Frame>

### Depurando a Extensão de Serviço de Notificação do iOS

Siga estas etapas para verificar se a Extensão de Serviço de Notificação está configurada corretamente.

#### 1. Atualizar o código OneSignalNotificationServiceExtension

Abra `NotificationService.m` ou `NotificationService.swift` e substitua todo o conteúdo do arquivo pelo código abaixo. Isso adiciona logs para ajudar a verificar se a extensão está sendo executada.

Substitua `YOUR_BUNDLE_ID` pelo seu Bundle ID real.

<CodeGroup>
  ```swift Swift theme={null}
  import UserNotifications
  import OneSignalExtension
  import os.log

  class NotificationService: UNNotificationServiceExtension {

      var contentHandler: ((UNNotificationContent) -> Void)?
      var receivedRequest: UNNotificationRequest!
      var bestAttemptContent: UNMutableNotificationContent?

      override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
          self.receivedRequest = request
          self.contentHandler = contentHandler
          self.bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)

          let userInfo = request.content.userInfo
          let custom = userInfo["custom"]
          print("Running NotificationServiceExtension: userInfo = \(userInfo.description)")
          print("Running NotificationServiceExtension: custom = \(custom.debugDescription)")
          os_log("%{public}@", log: OSLog(subsystem: "YOUR_BUNDLE_ID", category: "OneSignalNotificationServiceExtension"), type: OSLogType.debug, userInfo.debugDescription)

          if let bestAttemptContent = bestAttemptContent {
              print("Running NotificationServiceExtension")
              bestAttemptContent.body = "[Modified] " + bestAttemptContent.body

              OneSignalExtension.didReceiveNotificationExtensionRequest(self.receivedRequest, with: bestAttemptContent, withContentHandler: self.contentHandler)
          }
      }

      override func serviceExtensionTimeWillExpire() {
          if let contentHandler = contentHandler, let bestAttemptContent =  bestAttemptContent {
              OneSignalExtension.serviceExtensionTimeWillExpireRequest(self.receivedRequest, with: self.bestAttemptContent)
              contentHandler(bestAttemptContent)
          }
      }

  }

  ```

  ```objc Objective-C theme={null}
  #import <OneSignalExtension/OneSignalExtension.h>

  #import "NotificationService.h"

  @interface NotificationService ()

  @property (nonatomic, strong) void (^contentHandler)(UNNotificationContent *contentToDeliver);
  @property (nonatomic, strong) UNNotificationRequest *receivedRequest;
  @property (nonatomic, strong) UNMutableNotificationContent *bestAttemptContent;

  @end

  @implementation NotificationService

  - (void)didReceiveNotificationRequest:(UNNotificationRequest *)request withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
      self.receivedRequest = request;
      self.contentHandler = contentHandler;
      self.bestAttemptContent = [request.content mutableCopy];

      NSUserDefaults *userDefault = [[NSUserDefaults alloc] initWithSuiteName:@"group.YOUR_BUNDLE_ID.onesignal"];
      NSLog(@"NSE player_id: %@", [userDefault stringForKey:@"GT_PLAYER_ID"]);
      NSLog(@"NSE app_id: %@", [userDefault stringForKey:@"GT_APP_ID"]);

      NSLog(@"Running NotificationServiceExtension");
      self.bestAttemptContent.body = [@"[Modified] " stringByAppendingString:self.bestAttemptContent.body];

      [OneSignal.Debug setLogLevel:ONE_S_LL_VERBOSE];

      [OneSignalExtension didReceiveNotificationExtensionRequest:self.receivedRequest
                                                withNotification:self.bestAttemptContent
                                              withContentHandler:self.contentHandler];
  }

  - (void)serviceExtensionTimeWillExpire {
      [OneSignalExtension serviceExtensionTimeWillExpireRequest:self.receivedRequest
                                               withNotification:self.bestAttemptContent];

      self.contentHandler(self.bestAttemptContent);
  }

  @end
  ```
</CodeGroup>

<Note>
  Os tipos de log de depuração precisam ser habilitados no Console via **Action > Include Debug Messages**.
</Note>

#### 2. Alterar seu Active Scheme

Defina seu Active Scheme para `OneSignalNotificationServiceExtension`.

<Frame caption="Seleção de active scheme no Xcode">
  <img src="https://mintcdn.com/onesignal/x4RdPY-EcasyyQ-o/images/mobile/xcode-active-scheme-selection.png?fit=max&auto=format&n=x4RdPY-EcasyyQ-o&q=85&s=27407135e39bc606a02e005efd3a56ff" alt="Xcode toolbar showing the active scheme dropdown set to OneSignalNotificationServiceExtension" width="3282" height="1888" data-path="images/mobile/xcode-active-scheme-selection.png" />
</Frame>

#### 3. Compilar e executar o projeto

Compile e execute o projeto no Xcode em um dispositivo real.

#### 4. Abrir o Console

No Xcode, selecione **Window > Devices and Simulators**.

<Frame caption="Janela Devices and Simulators do Xcode">
  <img src="https://mintcdn.com/onesignal/x4RdPY-EcasyyQ-o/images/mobile/xcode-devices-and-simulators-selection.png?fit=max&auto=format&n=x4RdPY-EcasyyQ-o&q=85&s=2bc1305ee0fd45087f33a078a7aeaffb" alt="Xcode menu showing the Window dropdown with Devices and Simulators selected" width="2518" height="1374" data-path="images/mobile/xcode-devices-and-simulators-selection.png" />
</Frame>

Você deve ver seu dispositivo conectado. Selecione **Open Console**.

<Frame caption="Botão de acesso ao console do dispositivo">
  <img src="https://mintcdn.com/onesignal/x4RdPY-EcasyyQ-o/images/mobile/xcode-device-console-access-button.png?fit=max&auto=format&n=x4RdPY-EcasyyQ-o&q=85&s=7ffa64afd28d452e200241ad4751c102" alt="Xcode Devices window showing the Open Console button for a connected device" width="2304" height="1624" data-path="images/mobile/xcode-device-console-access-button.png" />
</Frame>

#### 5. Verificar o Console

No Console:

1. Selecione **Action > Include Debug Messages**
2. Procure por `OneSignalNotificationServiceExtension` como a CATEGORY
3. Selecione **Start**

<Frame caption="Configuração de depuração do console">
  <img src="https://mintcdn.com/onesignal/x4RdPY-EcasyyQ-o/images/mobile/xcode-console-debugging-configuration.png?fit=max&auto=format&n=x4RdPY-EcasyyQ-o&q=85&s=82593a0287811e6b787cee686ab7196d" alt="macOS Console app showing the category filter and Start button for debugging the notification service extension" width="3368" height="1232" data-path="images/mobile/xcode-console-debugging-configuration.png" />
</Frame>

Envie para este dispositivo uma notificação com uma mensagem (use a propriedade `contents` se estiver enviando pela API [Criar notificação](/reference/push-notification)). Neste exemplo, o payload é:

```curl cURL theme={null}
curl --request POST \
 --url 'https://api.onesignal.com/notifications' \
 --header 'Authorization: Key YOUR_API_KEY' \
 --header 'accept: application/json' \
 --header 'content-type: application/json' \
 --data '
{
"app_id": "YOUR_APP_ID",
"target_channel": "push",
"headings": {"en": "The message title"},
"contents": {"en": "The message contents"},
"data":{"additional_data_key_1":"value_1","additional_data_key_2":"value_2"},
"include_subscription_ids": [
"SUBSCRIPTION_ID_1"
]
}'
```

Você deve ver uma mensagem registrada com o aplicativo em execução e sem execução.

<Frame caption="Exemplo de saída de depuração do console">
  <img src="https://mintcdn.com/onesignal/x4RdPY-EcasyyQ-o/images/mobile/xcode-console-debug-output.png?fit=max&auto=format&n=x4RdPY-EcasyyQ-o&q=85&s=d93e3fc36610941e1c01b83abc0234b3" alt="macOS Console app showing debug log output from the OneSignalNotificationServiceExtension" width="3604" height="1776" data-path="images/mobile/xcode-console-debug-output.png" />
</Frame>

Se você não vir uma mensagem, remova o OneSignal do seu aplicativo e siga a [Configuração do SDK Móvel](./mobile-sdk-setup) novamente para verificar a integração.

## FAQ

**Por que minha extensão de serviço de notificação não está sendo executada no iOS?**

A extensão só é executada quando `mutable-content` está definido no payload da notificação. O OneSignal define isso automaticamente para notificações com anexos ou botões de ação. Verifique se as configurações do Xcode correspondem ao [guia de solução de problemas](#troubleshooting-the-ios-notification-service-extension).

**Posso impedir que uma notificação seja exibida no Android?**

Sim. Chame `event.preventDefault()` para suprimir a exibição. Em seguida, chame `event.getNotification().display()` para exibi-la mais tarde, ou nunca chame para descartá-la silenciosamente. Consulte [Notificações duplicadas](./duplicated-notifications#android-notification-service-extension) para mais informações.

**Preciso da anotação @Keep no Android?**

Sim. Ela evita que o ProGuard ou o R8 renomeie ou remova sua classe que implementa `INotificationServiceExtension` durante a minificação.

## Páginas relacionadas

<Columns cols={2}>
  <Card title="Configuração do SDK Móvel" icon="mobile" href="./mobile-sdk-setup">
    Instale e configure o SDK do OneSignal para iOS e Android.
  </Card>

  <Card title="Imagens e rich media" icon="image" href="./rich-media">
    Anexe imagens, GIFs e vídeos a notificações push.
  </Card>

  <Card title="Entrega confirmada" icon="check" href="./confirmed-delivery">
    Rastreie a entrega confirmada de notificações para dispositivos.
  </Card>

  <Card title="Notificações duplicadas" icon="clone" href="./duplicated-notifications">
    Solucione notificações push duplicadas em todas as plataformas.
  </Card>
</Columns>