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

# App de ejemplo: deep links y clics en notificaciones

> Cómo la app de ejemplo Clean Beans lleva un push tocado a la pantalla correcta, gestiona los botones de acción y la opción de posponer, y se abre desde Universal Links.

Esta página forma parte de [App de ejemplo: una integración completa de OneSignal](https://documentation.onesignal.com/docs/es/example-full-integration-overview.md), que sigue una app real de principio a fin. La app es **Clean Beans**, un turno de limpieza para hogares compartidos, creada con Expo (React Native) y un backend de Supabase.

Una notificación solo es útil si al tocarla te lleva al lugar correcto. Clean Beans gestiona cuatro formas de entrar en la app: un push tocado, un botón tocado en un push, un enlace con esquema personalizado y un enlace web normal.

## Enrutar un push tocado \\

Cada push lleva un campo `data.type`. La app escucha los toques, lee el tipo y abre la pantalla correspondiente.

```typescript app/_layout.tsx theme={null}
OneSignal.Notifications.addEventListener('click', (event: NotificationClickEvent) => {
  const data = event.notification.additionalData as Record<string, string> | undefined;
  if (!data?.type) return;

  // Mark inbox message as read (best-effort, fire-and-forget)
  const notificationId = event.notification.notificationId;
  if (notificationId) {
    supabase
      .from('inbox_messages')
      .update({ read: true })
      .eq('onesignal_message_id', notificationId)
      .then();
  }

  // Small delay to let the app finish initialising if cold-launched
  setTimeout(() => {
    // A tap on an action button ("Snooze 1h", "Send kudos", ...) carries an
    // actionId. A tap on the notification itself does not.
    const action = handlePushAction(event.result.actionId, data);
    if (action.handled) {
      if (action.route) router.push(action.route as any);
      return;
    }

    switch (data.type) {
      case 'daily_digest':
      case 'upcoming_cleaning':
      case 'overdue_reminder':
      case 'reengagement':
        router.push('/(tabs)/clean');
        break;
      case 'session_completed':
      case 'kudos':
        router.push('/activity');
        break;
      case 'join_approved':
      case 'member_lapsed':
        router.push('/household');
        break;
      default:
        break;
    }
  }, 500);
});
```

| `data.type` | Abre |
| - | - |
| `daily_digest`, `overdue_reminder`, `upcoming_cleaning` | La pestaña Clean |
| `session_completed`, `kudos` | El feed de actividad |
| `join_approved`, `member_lapsed` | La pantalla del hogar |
| `reengagement` | La pestaña Clean |

Dos de esos tipos proceden de Journeys, que esta guía no trata. `reengagement` se establece en los push de un Journey de recuperación creado en el panel. `member_lapsed` es un push para los propietarios y administradores de un hogar, que el backend envía cuando ese Journey informa de que un miembro ha dejado de limpiar. Se enrutan aquí como cualquier otro push.

> [!TIP]
>
> Enrutar según un tipo que tú controlas es más robusto que analizar una URL. Si una pantalla cambia de sitio, modificas una sola instrucción `switch` y todos los push enviados antes del cambio siguen abriéndose correctamente.

## Botones de acción: más de una cosa que tocar \\

Un push puede llevar botones. Los push de tareas ofrecen **Start cleaning** y **Snooze 1h**, y el push "un compañero de casa ha terminado de limpiar" ofrece **Send kudos**. Las personas muestran los botones expandiendo la notificación, lo que en iOS es una pulsación larga.

![Una notificación push expandida con los botones Start cleaning y Snooze 1h](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-action-buttons.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=0a850d439deea8f483c8dfe532fb8e93)

Un recordatorio expandido con sus dos botones de acción.

El backend añade los botones a la solicitud. Cada uno tiene un `id` y una etiqueta.

```typescript supabase/functions/_shared/buttons.ts theme={null}
export const TASK_BUTTONS = [
  { id: ACTION_START_CLEANING, text: 'Start cleaning' },
  { id: ACTION_SNOOZE, text: 'Snooze 1h' },
];
```

Tocar un botón abre la app, y el listener de clics mostrado arriba recibe el `id` del botón como `event.result.actionId`. Un toque en la propia notificación no tiene `actionId`. La app comprueba primero si hay un botón y, si no, recurre al enrutamiento normal.

```typescript src/lib/pushActions.ts theme={null}
export function handlePushAction(actionId: string | undefined, data: PushData): ActionOutcome {
  if (!actionId) return { handled: false };

  // Record which button was tapped. As a custom event it can branch a
  // Journey (Wait Until this event) or feed a Conversion Metric.
  OneSignal.User.trackEvent('push_action_clicked', {
    action_id: actionId,
    notification_type: data?.type ?? 'unknown',
  });

  switch (actionId) {
    case ACTION_START_CLEANING:
      return { handled: true, route: '/(tabs)/clean' };

    case ACTION_SNOOZE:
      snoozeReminder();
      return { handled: true, route: null };

    case ACTION_SEND_KUDOS:
      sendKudosFromPush(data);
      return { handled: true, route: '/activity' };

    default:
      return { handled: false };
  }
}
```

**Posponer** necesita el backend, porque la app no puede enviar un push. Llama a una función que programa otro recordatorio con `send_after`. OneSignal retiene el mensaje hasta ese momento, así que nada tiene que seguir ejecutándose durante una hora.

```typescript supabase/functions/snooze-reminder/index.ts theme={null}
const sendAt = new Date(Date.now() + SNOOZE_MINUTES * 60_000);

const onesignalPayload = {
  app_id: ONESIGNAL_APP_ID,
  include_aliases: { external_id: [user.id] },
  target_channel: 'push',
  // OneSignal holds the message and delivers it at this time
  send_after: sendAt.toISOString(),
  // ...
};
```

> [!NOTE]
>
> Cada toque en un botón también se registra como evento personalizado, `push_action_clicked`. Un Journey no puede ramificarse directamente según un botón, pero puede esperar este evento y ramificarse según su propiedad `action_id`.

> [!NOTE]
>
> Tocar un botón abre la app de forma predeterminada. Gestionar un toque sin abrir la app requiere código nativo: una categoría de notificación en iOS y una notification service extension en Android.

## Reescribir los enlaces entrantes \\

Los enlaces desde fuera de la app usan rutas cortas como `/clean`. El hook de native intent de Expo Router las reescribe a las rutas reales de la app antes de que se produzca la navegación, así que nada fuera de la app necesita saber cómo están organizadas las pantallas.

```typescript app/+native-intent.tsx theme={null}
const PATH_REWRITES: Record<string, string> = {
  // Tab screens — simplified path → grouped route
  '/clean': '/(tabs)/clean',
  '/tasks': '/(tabs)/tasks',
  '/rota': '/(tabs)/rota',
  '/settings': '/(tabs)/settings',
  '/dashboard': '/(tabs)',

  // Standalone screens
  '/streaks': '/streaks',
  '/activity': '/activity',

  // Convenience aliases
  '/join': '/join-household',
  '/notifications': '/notification-settings',
};

export function redirectSystemPath({
  path,
  initial,
}: {
  path: string;
  initial: boolean;
}): string {
  try {
    // Parse the incoming URL to extract path and query string
    const url = new URL(path, 'cleaning-rota://app');
    const pathname = url.pathname || '/';
    const search = url.search || '';

    // Check for a rewrite match (exact path without query string)
    const rewritten = PATH_REWRITES[pathname];
    if (rewritten) {
      return rewritten + search;
    }

    // Universal Link / App Link with no rewrite: hand the router just the
    // path, not the full https URL
    if (url.protocol === 'https:' || url.protocol === 'http:') {
      return pathname + search;
    }

    // No rewrite needed — pass through as-is
    return path;
  } catch {
    // Never crash in this function — fall back to home screen
    return '/(tabs)';
  }
}
```

## Abrir la app desde enlaces web normales \\

Un esquema personalizado como `cleaning-rota://` solo funciona si la app está instalada, y muchas apps se niegan a hacerlo pulsable. Los Universal Links en iOS y los App Links en Android resuelven esto. Son enlaces `https://` normales que abren la app cuando está instalada y el sitio web cuando no lo está. Eso los convierte en la opción adecuada para los enlaces en emails, SMS y mensajes compartidos.

Configurarlos requiere una declaración en cada lado: la app indica a qué dominio pertenece y el sitio web indica qué app puede abrir sus enlaces.

**1. Declarar el dominio en la app**

```json app.json theme={null}
{
  "expo": {
    "ios": {
      "associatedDomains": ["applinks:cleanbeansapp.com"]
    },
    "android": {
      "intentFilters": [
        {
          "action": "VIEW",
          "autoVerify": true,
          "data": [
            { "scheme": "https", "host": "cleanbeansapp.com", "pathPrefix": "/join" },
            { "scheme": "https", "host": "cleanbeansapp.com", "pathPrefix": "/clean" }
          ],
          "category": ["BROWSABLE", "DEFAULT"]
        }
      ]
    }
  }
}
```

**2. Publicar el archivo de asociación de Apple**

Alójalo en `/.well-known/apple-app-site-association`, por HTTPS, servido como JSON. El ID de la app es tu Apple Team ID seguido del identificador del bundle.

```json website/.well-known/apple-app-site-association theme={null}
{
  "applinks": {
    "details": [
      {
        "appIDs": ["YOUR_TEAM_ID.com.onesignal.cleaningapp"],
        "components": [
          { "/": "/join", "comment": "Opens /join in the Clean Beans app" },
          { "/": "/clean", "comment": "Opens /clean in the Clean Beans app" }
        ]
      }
    ]
  }
}
```

**3. Publicar el archivo de asociación de Android**

Alójalo en `/.well-known/assetlinks.json`. La huella digital procede del certificado de firma de tu app. Con EAS, ejecuta `eas credentials -p android` para encontrarla.

```json website/.well-known/assetlinks.json theme={null}
[
  {
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
      "namespace": "android_app",
      "package_name": "com.onesignal.cleaningapp",
      "sha256_cert_fingerprints": ["YOUR_SHA256_FINGERPRINT"]
    }
  }
]
```

**4. Usar el enlace**

La pantalla del hogar comparte un enlace de invitación. Al tocarlo se abre la pantalla de unión con el código ya rellenado.

```typescript app/household.tsx theme={null}
message: `Join my household "${activeHousehold.name}" on Clean Beans! Tap https://cleanbeansapp.com/join?code=${encodeURIComponent(activeHousehold.inviteCode)} or use invite code: ${activeHousehold.inviteCode}`,
```

```typescript app/join-household.tsx theme={null}
const params = useLocalSearchParams<{ code?: string }>();
const [code, setCode] = useState(typeof params.code === 'string' ? params.code : '');
```

> [!NOTE]
>
> Clean Beans solo reclama las rutas que la app puede mostrar. La página de inicio queda al margen, así que el sitio de marketing se sigue abriendo en el navegador. iOS lee el archivo de asociación cuando se instala o actualiza la app, así que publica el archivo antes de lanzar la compilación.

> [card] [Deep linking](https://documentation.onesignal.com/docs/es/deep-linking.md)
>
> Cómo gestiona OneSignal las URL en cada plataforma.

> [card] [Payload de la notificación](https://documentation.onesignal.com/docs/es/osnotification-payload.md)
>
> Todos los campos disponibles en el listener de clics.

> [card] [Botones de acción](https://documentation.onesignal.com/docs/es/action-buttons.md)
>
> Límites de cada plataforma, iconos y gestión de toques.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.