> ## 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.

# Extensiones de servicio móvil

> Implementa las extensiones de servicio de notificaciones de iOS y Android en tu aplicación.

Las extensiones de servicio de notificaciones te permiten interceptar y modificar notificaciones push antes de que se muestren al usuario. Esto habilita el manejo de datos en segundo plano, estilos personalizados, archivos adjuntos de medios enriquecidos, entrega confirmada y opciones de botones de acción.

<Note>
  Puedes acceder a los datos de tus notificaciones push enviadas desde OneSignal a través de la [clase OSNotification](./osnotification-payload)
</Note>

***

## Extensión de servicio de notificaciones de Android

Te permite procesar la notificación antes de que se muestre al usuario. Los casos de uso más comunes incluyen:

* Recibir datos en segundo plano con o sin mostrar una notificación.
* Anular configuraciones específicas de notificación según la lógica del lado del cliente, como el color de énfasis personalizado, el patrón de vibración u otras opciones de `NotificationCompat` disponibles.

Para más detalles, consulta la [documentación de Android sobre las opciones de NotificationCompat.](https://developer.android.com/reference/androidx/core/app/NotificationCompat)

### Paso 1: Crear una clase para la extensión de servicio

Crea una clase que implemente `INotificationServiceExtension` e implementa el método `onNotificationReceived`.

El parámetro del método `onNotificationReceived` es `event` de 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>
  La anotación `@Keep` es necesaria para evitar que ProGuard o R8 renombre o elimine tu clase durante la minificación.
</Note>

### Paso 2: Personalizar la notificación

Los siguientes ejemplos muestran personalizaciones comunes que puedes implementar en la clase de extensión de servicio de notificaciones.

<Tabs>
  <Tab title="Impedir que se muestre la notificación">
    Usa `event.preventDefault()` para suprimir la visualización de la notificación. Luego puedes llamar a `event.getNotification().display()` para mostrarla más tarde, o no llamarla nunca para descartarla 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>
      Llamar a `event.preventDefault()` sin llamar nunca a `display()` descartará la notificación silenciosamente. Para más información, consulta [Notificaciones duplicadas](./duplicated-notifications#android-notification-service-extension).
    </Warning>
  </Tab>

  <Tab title="Agregar un 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="Cambiar el color y el ícono de la notificación">
    <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>
      Los íconos referenciados aquí deben existir en el directorio `res/drawable` de tu proyecto Android.
    </Note>
  </Tab>
</Tabs>

### Paso 3: Agregar la extensión de servicio a tu `AndroidManifest.xml`

Agrega el nombre de la clase y el valor como `meta-data` dentro del archivo `AndroidManifest.xml` en la etiqueta de la aplicación. Ignora cualquier advertencia de "no utilizado".

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

Reemplaza `com.onesignal.example.NotificationServiceExtension` con el nombre completamente calificado de tu clase.

***

## Extensión de servicio de notificaciones de iOS

La [UNNotificationServiceExtension](https://developer.apple.com/reference/usernotifications/unnotificationserviceextension) te permite modificar el contenido de las notificaciones push antes de que se muestren al usuario y es necesaria para otras funciones importantes como:

* [Imágenes y medios enriquecidos](./rich-media).
* [Entrega confirmada](./confirmed-delivery)
* [Badges](./badges)
* [Botones de acción](./action-buttons)
* [Aperturas influenciadas con Firebase Analytics](./google-analytics-for-firebase)

Probablemente ya lo configuraste si seguiste nuestras instrucciones de [configuración del SDK móvil](./mobile-sdk-setup) para tu aplicación, pero esta sección explicará cómo acceder a los datos del payload de notificación de OneSignal y solucionar cualquier problema que puedas tener.

### Obtener el payload push de iOS

La anulación de `didReceive(_:withContentHandler:)` llama a `OneSignalExtension.didReceiveNotificationExtensionRequest`, que pasa el `bestAttemptContent` a OneSignal antes de que se muestre al usuario. Puedes leer o modificar `bestAttemptContent` antes de que se llame a ese método.

En este ejemplo, enviamos una notificación con los siguientes datos:

```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"]
}
```

Accede a estos `data` adicionales dentro de la OneSignalNotificationServiceExtension a través de la clave `a` dentro del diccionario `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>

**Ejemplo de salida en consola:**

```
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
```

### Solución de problemas de la extensión de servicio de notificaciones de iOS

Esta guía es para depurar problemas con imágenes, botones de acción o entregas confirmadas que no aparecen en aplicaciones móviles de iOS.

#### Verifica tu configuración de Xcode

En **General > Targets**, asegúrate de que tu **target de aplicación principal** y el target **OneSignalNotificationServiceExtension** tengan los mismos valores correctos de:

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

<Warning>
  Si usas Cocoapods, asegúrate de que coincidan con tu target principal en el Podfile para evitar errores de compilación.
</Warning>

<Frame caption="Ejemplo de target de aplicación principal en 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="Ejemplo de target OneSignalNotificationServiceExtension en 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 en la pestaña **OneSignalNotificationServiceExtension > Info**, expande la clave `NSExtension`. Asegúrate 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>
```

Ejemplo:

<Frame caption="Ejemplo de clave NSExtension en la pestaña 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>
  Si usas Objective-C, en lugar de `$(PRODUCT_MODULE_NAME).NotificationService` usa `NotificationService`.
</Warning>

#### Desactiva "Copy only when installing"

Selecciona tu **target de aplicación principal > Build Phases > Embed App Extensions**. Asegúrate de que "Copy only when installing" NO esté marcado. Desmárcalo si lo está:

<Frame caption="Configuración de fases de compilación del target de aplicación principal">
  <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>

### Depuración de la extensión de servicio de notificaciones de iOS

Sigue estos pasos para verificar que la extensión de servicio de notificaciones esté configurada correctamente.

#### 1. Actualizar el código OneSignalNotificationServiceExtension

Abre `NotificationService.m` o `NotificationService.swift` y reemplaza todo el contenido del archivo con el código a continuación. Esto agrega registros para ayudar a verificar que la extensión se está ejecutando.

Reemplaza `YOUR_BUNDLE_ID` con tu 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>
  Los tipos de registro de depuración deben habilitarse en la Consola mediante **Action > Include Debug Messages**.
</Note>

#### 2. Cambiar tu esquema activo

Establece tu esquema activo en `OneSignalNotificationServiceExtension`.

<Frame caption="Selección del esquema activo en 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 y ejecutar el proyecto

Compila y ejecuta el proyecto en Xcode en un dispositivo real.

#### 4. Abrir la consola

En Xcode, selecciona **Window > Devices and Simulators**.

<Frame caption="Ventana Devices and Simulators de 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>

Deberías ver tu dispositivo conectado. Selecciona **Open Console**.

<Frame caption="Botón de acceso a la consola del 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 la consola

En la consola:

1. Selecciona **Action > Include Debug Messages**
2. Busca `OneSignalNotificationServiceExtension` como CATEGORY
3. Selecciona **Start**

<Frame caption="Configuración de depuración de la consola">
  <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>

Envía a este dispositivo una notificación con un mensaje (usa la propiedad `contents` si envías desde la API [Crear notificación](/reference/push-notification)). En este ejemplo, el payload es:

```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"
]
}'
```

Deberías ver un mensaje registrado con la aplicación en ejecución y sin ejecución.

<Frame caption="Ejemplo de salida de depuración de la consola">
  <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>

Si no ves un mensaje, elimina OneSignal de tu aplicación y sigue la [Configuración del SDK móvil](./mobile-sdk-setup) nuevamente para verificar la integración.

## Preguntas frecuentes

**¿Por qué no se ejecuta mi extensión de servicio de notificaciones en iOS?**

La extensión solo se ejecuta cuando `mutable-content` está configurado en el payload de la notificación. OneSignal lo configura automáticamente para notificaciones con archivos adjuntos o botones de acción. Verifica que tu configuración de Xcode coincida con la [sección de solución de problemas](#troubleshooting-the-ios-notification-service-extension).

**¿Puedo evitar que se muestre una notificación en Android?**

Sí. Llama a `event.preventDefault()` para suprimir la visualización. Luego llama a `event.getNotification().display()` para mostrarla más tarde, o no la llames nunca para descartarla silenciosamente. Consulta [Notificaciones duplicadas](./duplicated-notifications#android-notification-service-extension) para más información.

**¿Necesito la anotación @Keep en Android?**

Sí. Evita que ProGuard o R8 renombre o elimine tu clase que implementa `INotificationServiceExtension` durante la minificación.

## Páginas relacionadas

<Columns cols={2}>
  <Card title="Configuración del SDK móvil" icon="mobile" href="./mobile-sdk-setup">
    Instala y configura el SDK de OneSignal para iOS y Android.
  </Card>

  <Card title="Imágenes y medios enriquecidos" icon="image" href="./rich-media">
    Adjunta imágenes, GIFs y videos a las notificaciones push.
  </Card>

  <Card title="Entrega confirmada" icon="check" href="./confirmed-delivery">
    Rastrea la entrega confirmada de notificaciones a dispositivos.
  </Card>

  <Card title="Notificaciones duplicadas" icon="clone" href="./duplicated-notifications">
    Soluciona notificaciones push duplicadas en todas las plataformas.
  </Card>
</Columns>