Despertar con la AlarmKit API

Despertar con la AlarmKit API

¡Rrrr-rrrrr-innng! Desde los temporizadores de cuenta regresiva de la app de recetas hasta las alarmas para despertar de la app de planificación de viajes, el marco AlarmKit en iOS y iPadOS 26 lleva los temporizadores y las alarmas a la pantalla de bloqueo, a Dynamic Island y mucho más. Aprende a crear y gestionar las alarmas de tu app, personalizar las Actividades en Vivo y ofrecer acciones de alerta personalizadas mediante el marco App Intents. Para aprovechar al máximo este video, te recomendamos ver primero "Meet ActivityKit" del WWDC23.

Capítulos
- 0:00 - Te damos la bienvenida
- 0:32 - Descripción general
- 1:39 - Autorización
- 3:06 - Creación
- 16:32 - Ciclo de vida
Recursos
Videos relacionados

WWDC25
- Conoce App Intents
WWDC23
- Meet ActivityKit
Hola, soy Anton, ingeniero del equipo de System Experience. En esta sesión, conocerás AlarmKit, una estructura que te permite crear alarmas en tu app. En este video, explicaré la experiencia que puedes crear con AlarmKit, luego analizaré cómo puedes obtener la autorización de tu app para usar esta estructura, cómo crear una alarma y cómo puedes administrar su ciclo de vida. Comenzaré con la experiencia. Una alarma es una alerta notable de cosas que pasan a una hora fija y predeterminada. Se basa en un cronograma o una cuenta atrás. Cuando se dispara, la alerta interrumpe el modo silencioso y el foco actual.
En la alerta, se presenta el título de la alarma personalizado y el nombre de la app. Las personas tienen la opción de detener la alerta o posponerla con un botón de posposición opcional.
La alarma puede tener un botón personalizado de acción definida por una app intent.
Las alarmas se admiten en otras experiencias del sistema, como StandBy y Apple Watch, si está emparejado con el iPhone al activarse la alarma.
Las alarmas admiten una IU de cuenta atrás personalizada por Actividades en vivo de la app. Esto se ve tanto en la pantalla de bloqueo como en Dynamic Island y En espera.
La gente opta por activar la funcionalidad de alarma en cada app del dispositivo. Ahora que sabes qué es una alarma, veamos qué debes hacer para permitir que las personas autoricen tu app a programar alarmas.
Antes de que la app pueda programar alarmas, las personas deberán dar su consentimiento. Puedes solicitar la autorización manualmente o se solicitará automáticamente cuando crees la primera alarma. En todo momento, se puede cambiar la autorización en la app Configuración. Configurarla es simple, solo agrega NSAlarmKitUsageDescription a la lista de información de la app explicando el caso de uso para presentar alarmas. Ofrece una explicación breve y descriptiva de cómo la app usará las alarmas, para que la gente pueda tomar la decisión. Para solicitar autorización manualmente, puedes usar la API requestAuthorization de AlarmManager. Si no se hizo una elección antes, se mostrará un mensaje con la descripción del uso.
Comprueba el estado de la autorización antes de programar la alarma consultándolo en la clase AlarmManager.
En este caso, si no está determinado, solicito autorización manualmente. Si tengo autorización, procedo a programar la alarma. Si se niega, es importante dejar claro en la interfaz de la app que la alarma no se programará. Ahora que conoces la configuración de autorización para alarmas, hablemos sobre cómo crear una. Para crear una alarma necesitas: duración de cuenta atrás, cronograma con fecha específica o patrón de recurrencia, configuración del aspecto, manejo de acciones personalizadas y sonido asociado.
Veamos la duración de la cuenta atrás. Una alarma puede tener un intervalo previo y posterior a la alerta. Al programar una alarma la primera vez, se mostrará la IU de cuenta atrás que aparecerá durante esta, previa a la alerta. Transcurrida la alerta anticipada, la alarma se activa y muestra la IU de alerta, personalizada con la configuración.
Si se pospone, la IU de cuenta atrás aparecerá nuevamente durante el intervalo posterior a la alerta.
Transcurrido el plazo, la alarma se activa de nuevo. Puede posponerse o descartarse.
Configuro un temporizador con duración de alerta anticipada de 10 minutos. Una vez que se activa y se repite, cuenta hacia atrás durante la alerta posterior de 5 minutos y se activa de nuevo. Al crear una alarma también puedes proporcionar un cronograma, ya sea fijo o relativo.
Un cronograma fijo determina una sola fecha futura para activar la alarma. Este cronograma es absoluto y no cambia con la zona horaria del dispositivo. Puse una alarma para que suene para la presentación de la WWDC. Creo componentes de fecha: 9 de junio a las 9:41 a. m. Aquí, uso esos componentes para crear la fecha.
Ahora, paso la fecha al cronograma de alarma con inicializador fijo. También, puedo determinar un cronograma relativo. Incluye la hora del día y el patrón de recurrencia semanal opcional. Este tipo contempla los cambios de zona horaria.
Aquí, configuro la alarma para que suene a las 7 a. m. todos los lunes, miércoles y viernes. Establezco la hora y los minutos para el tiempo y especifico la ocurrencia diaria.
Ahora que sabes cómo programar una alarma, pasemos a personalizar el aspecto de la alarma. Hay varios elementos que puedes personalizar. Quiero crear un temporizador de cocina en mi app y personalizar cómo aparece la alerta cuando suena. Comienzo por crear el botón de alerta usando la estructura AlarmButton. Me permite especificar el texto, su color y la imagen del sistema del botón.
Lo uso para definir el botón de parada, de título “Descartar”, y el color de texto, blanco.
También incluirá un símbolo SF, que se usará cuando se muestre la alerta en Dynamic Island.
Creo la presentación de alerta y configuro el título de alarma que indica la comida lista. Incluyo el botón de parada que creé. Luego, crearé los atributos de alarma. Piensa que es información necesaria para representar las presentaciones de alarma. Pasaré la presentación de alerta creada en el parámetro de presentación. Crearé la configuración de la alarma. Todas las partes son necesarias para programar una alarma: duración de cuenta atrás, cronograma y atributos incluidos. Pasaré los atributos a la configuración de la alarma.
Puse un botón para descartar en la presentación de alerta de alarma.
Si la alarma solo mostrará una alerta, esto es todo lo necesario para configurar el aspecto. Pero si deseas que tu alarma muestre una interfaz de cuenta atrás, hay algunos pasos más que debes seguir. Revisaré esos para mi alarma de cocina. Agregaré un botón de repetición para activar la cuenta atrás.
Creo el botón de repetición usando AlarmButton y establezco el título “repetir”. Especificaré un texto blanco y un ícono de repetición, que aparecerá cuando la alarma suene en Dynamic Island.
Cuando creo la presentación de alerta, incluyo el botón de repetición.
El parámetro de comportamiento secondaryButton determina si el botón secundario cambia la alarma al estado de cuenta atrás, como repetir temporizador o posponer alarma, o ejecutar una acción personalizada. Al tocar mi botón de repetición, quiero que la alerta pase a una cuenta atrás en este caso. Así que configuro secondaryButtonBehavior en cuenta atrás. Como antes, crearé los atributos de alarma con la presentación de alerta y luego la AlarmConfiguration que incluye esos atributos. Agregué un botón de repetición a mi alerta, que iniciará una cuenta atrás. Ahora, implemento una Actividad en vivo para mostrar la IU de cuenta atrás. Si la alarma admite la funcionalidad de cuenta atrás, la app debe implementarla por Actividad en vivo. Eso haré ahora. Crearé una cuenta atrás para informarme cuando la comida esté lista. Aparecerá en la pantalla de bloqueo, en Dynamic Island y En espera.
Si sabes cómo crear una Actividad en vivo, ya sabes cómo crear una interfaz personalizada para la cuenta atrás. Debes agregar la Actividad en vivo de cuenta atrás a la extensión del widget de tu app.
Si no tienes uno, ¡no te alarmes! Puedes comenzar viendo el video de la WWDC23 llamado “Conoce ActivityKit”. Luego, configura una ActivityConfiguration y especifica AlarmAttributes con tu tipo de metadatos.
Aquí, puedo configurar ActivityConfiguration y especificar que usará atributos de alarma y mis metadatos CookingData. Me enfocaré en la pantalla de bloqueo. La cuenta atrás puede estar en estado cuenta atrás o pausa. Ofreceré una vista correspondiente para cada uno de ellos.
Para hacerlo, verifico el modo actual de la alarma en el objeto de contexto y represento la vista adecuada.
Me encargo del estado de la cuenta atrás y ofrezco su vista. Me encargo del estado de pausa y ofrezco su vista. Ahora configuraré las regiones expandidas del aspecto de Dynamic Island. Contienen el título, la cuenta atrás y los botones. Configuré las vistas compactas y mínimas de Dynamic Island. Estas contendrán mi cuenta atrás y un ícono. Ya configurada la cuenta regresiva de Actividad en vivo básica, agregaré un ícono para indicar cómo se cocina la comida. Puedo dar esta información adicional en los metadatos. CookingData es una estructura que cumple con el protocolo AlarmMetadata. Defino una enumeración de cadena para especificar el método de cocción e incluyo freír y asar. Creo una propiedad para guardar el método de cocción. Ahora puedo usar los metadatos de CookingData. Al programar la alarma en la app, creo el objeto CookingData y especifico “freír” como método de cocción. Incluyo estos metadatos personalizados al crear atributos de alarma.
En Actividad en vivo, accederé al método en mis metadatos personalizados usando atributos de contexto.
Puedo usar el método de cocción para crear un ícono. Ahora, cuando se procesa la cuenta atrás, tiene el ícono de fritura que generé usando el método de cocción en mis metadatos. Lo uso en la pantalla de bloqueo y en Dynamic Island.
Configuré con éxito la cuenta atrás de alarma usando una Actividad en vivo. Creé un ícono personalizado para la cuenta atrás con metadatos de alarma.
Si la alarma admite la funcionalidad de cuenta atrás, el sistema garantizará que se muestre una IU de cuenta atrás. A veces, la Actividad en vivo no se puede mostrar, por ejemplo, después de reiniciar el dispositivo. En ese caso, puedes personalizar la presentación de la cuenta atrás en el sistema. Configuraré la presentación del sistema para la cuenta atrás de la alarma de cocina. Primero, definiré el botón de pausa usando la estructura AlarmButton. Y configuraré un ícono de sistema de pausa.
Crearé la presentación de cuenta atrás, incluiré el título que indica que está en preparación e incluiré el botón de pausa.
Ya que definí la presentación de la cuenta atrás, la incluiré como parte de los atributos de alarma. Como la alarma admite la funcionalidad de pausa, configuraré la presentación del sistema en pausa para la cuenta atrás. Cuando la cuenta atrás se detenga, quiero que se pueda reanudar. Primero, defino el botón Reanudar usando AlarmButton. Configuro un ícono de reproducción.
Luego, creo la presentación en pausa y establezco el título “Cocina en pausa”. También paso el botón Reanudar.
Ahora, puedo agregar la presentación en pausa a los atributos. Me encargué de presentaciones de alerta, cuenta atrás y sistema en pausa. Hablemos ahora sobre el color del tinte. Se usa en todas estas presentaciones y ayuda a las personas a asociar tu alarma con tu app. Lo paso a mis atributos de alarma. En la presentación de alerta, se usa para el color de relleno del botón secundario.
En la pantalla de bloqueo, se usa para teñir el símbolo en el botón secundario, el título de la alarma y la cuenta atrás. Se usa en Dynamic Island de forma similar. Ahora que conoces la configuración del aspecto de la alarma, pasemos a personalizar las acciones. AlarmKit te permite ejecutar tu propio código cuando alguien toca un botón de alarma. Puedes hacerlo con una app intent. Puedes ofrecer una app intent personalizada para el botón secundario o de parada. Crearé un botón secundario personalizado que ejecutará la app intent de abrir la app al tocarla. Para lograrlo, tendré que modificar el aspecto de la alerta. Primero, creo un botón abierto usando la estructura AlarmButton. Se titulará “Abrir”, el texto tendrá color blanco y un ícono de flecha en Dynamic Island.
Cuando creo la presentación de alerta, incluiré el botón abrir como botón secundario.
Como quiero que el botón ejecute una acción personalizada, cambiaré su comportamiento a personalizado.
Mi botón secundario personalizado está listo. Configuraré una acción usando una app intent para abrir mi app al tocar el botón. Esta es la app intent abierta a usar. Incluye el identificador de alarma por el cual se tocó el botón. También establece el indicador openAppWhenRun en true para indicar que la app se abra al ejecutar la intent. Una vez abierta la app, puedo realizar más tareas, como mostrar una vista detallada de la alarma con ese identificador. Usemos la intent que creé. Al programar la alarma, creo un identificador único para rastrear esa alarma después de su creación. Creo una instancia de la intent OpenInApp y paso el identificador único de la alarma.
Cuando creo la configuración de alarma, ahora incluyo la intent secundaria para indicar al sistema que esta es la intent a ejecutar al tocar el botón secundario.
Agregué un botón de apertura personalizado a la alerta, definí una app intent para abrir la app e indiqué al sistema que ejecute esa intent al tocar el botón. Ahora, hablemos un momento sobre cómo configurar el sonido de la alarma. Si no especificas un parámetro de sonido, se usará un sonido de sistema predeterminado. También puedes ofrecer un sonido personalizado. Ya que AlarmKit usa ActivityKit para la presentación de alarmas, puedes definir un sonido personalizado con AlertSound.
Especifica el nombre del archivo de sonido, que estará en el paquete principal o en la carpeta Biblioteca/Sonidos del contenedor de datos de la app. Una vez que hayas terminado de configurar la alarma, podrás administrarla en el sistema. Puedes hacerlo usando la clase AlarmManager. Luego de configurar la alarma, puedo programarla con el sistema. Puedo hacerlo usando el identificador único de alarma y la configuración que creé antes. Este identificador se usa para rastrear la alarma durante su ciclo de vida.
Tienes control total del ciclo de vida de la alarma. Puedes pasarlo a un estado de cuenta atrás, cancelarlo, detenerlo, pausarlo o reanudarlo.
Me gustaría dejarte algunas recomendaciones para usar AlarmKit. Las alarmas son ideales para cuentas atrás de intervalo específico o alertas recurrentes con un cronograma, como una alarma despertador. No reemplazan otras notificaciones importantes, como alertas críticas o notificaciones urgentes.
Intenta lograr claridad en tu presentación. Las alertas se muestran de forma destacada y es conveniente que sea fácil de comprender qué es la alarma y qué acciones puede realizar.
Si tu alarma admite una cuenta atrás, considera incluir los elementos clave de la cuenta atrás en Actividad en vivo. Esto incluye la duración restante, un botón descartar y un botón para pausar o reanudar. Hoy aprendiste a usar AlarmKit para crear alarmas y administrar su ciclo de vida en el sistema. Está todo listo para probarlo en tu app. Usa AlarmKit para configurar alarmas para los casos de uso. Crea experiencias personalizadas en la pantalla de bloqueo y en Dynamic Island con Actividades en vivo. Agrega acciones personalizadas con App Intents.
Se nos acabó el tiempo. ¡Gracias!

// Check authorization status

import AlarmKit

func checkAuthorization() {

  switch AlarmManager.shared.authorizationState {
    case .notDetermined:
      // Manually request authorization
    case .authorized:
      // Proceed with scheduling
    case .denied:
      // Inform status is not authorized
  }
  
}

4:08 - Set up the countdown duration

// Set up the countdown duration

import AlarmKit

func scheduleAlarm() {

  /* ... */

  let countdownDuration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))

  /* ... */
}

4:40 - Set a fixed schedule

// Set a fixed schedule

import AlarmKit

func scheduleAlarm() {

  /* ... */

  let keynoteDateComponents = DateComponents(
    calendar: .current,
    year: 2025,
    month: 6,
    day: 9,
    hour: 9,
    minute: 41)
  let keynoteDate = Calendar.current.date(from: keynoteDateComponents)!
  let scheduleFixed = Alarm.Schedule.fixed(keynoteDate)

  /* ... */

}

5:13 - Set a relative schedule

// Set a relative schedule

import AlarmKit

func scheduleAlarm() {

  /* ... */

  let time = Alarm.Schedule.Relative.Time(hour: 7, minute: 0)
  let recurrence = Alarm.Schedule.Relative.Recurrence.weekly([
    .monday,
    .wednesday,
    .friday
  ])
  
  let schedule = Alarm.Schedule.Relative(time: time, repeats: recurrence)

  /* ... */

}

5:43 - Set up alert appearance with dismiss button

// Set up alert appearance with dismiss button

import AlarmKit

func scheduleAlarm() async throws {
    typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<CookingData>
    
    let id = UUID()
    let duration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))
    
    let stopButton = AlarmButton(
        text: "Dismiss",
        textColor: .white,
        systemImageName: "stop.circle")
    
    let alertPresentation = AlarmPresentation.Alert(
        title: "Food Ready!",
        stopButton: stopButton)
    
    let attributes = AlarmAttributes<CookingData>(
        presentation: AlarmPresentation(
            alert: alertPresentation),
        tintColor: Color.green)
    
    let alarmConfiguration = AlarmConfiguration(
        countdownDuration: duration,
        attributes: attributes)
    
    try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)
}

7:17 - Set up alert appearance with repeat button

// Set up alert appearance with repeat button

import AlarmKit

func scheduleAlarm() async throws {
    typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<CookingData>
    
    let id = UUID()
    let duration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))
    
    let stopButton = AlarmButton(
        text: "Dismiss",
        textColor: .white,
        systemImageName: "stop.circle")
    
    let repeatButton = AlarmButton(
        text: "Repeat",
        textColor: .white,
        systemImageName: "repeat.circle")
    
    let alertPresentation = AlarmPresentation.Alert(
        title: "Food Ready!",
        stopButton: stopButton,
        secondaryButton: repeatButton,
        secondaryButtonBehavior: .countdown)
    
    let attributes = AlarmAttributes<CookingData>(
        presentation: AlarmPresentation(alert: alertPresentation),
        tintColor: Color.green)
    
    let alarmConfiguration = AlarmConfiguration(
        countdownDuration: duration,
        attributes: attributes)
    
    try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)
}

9:15 - Create a Live Activity for a countdown

// Create a Live Activity for a countdown

import AlarmKit
import ActivityKit
import WidgetKit

struct AlarmLiveActivity: Widget {

  var body: some WidgetConfiguration {
    ActivityConfiguration(for: AlarmAttributes<CookingData>.self) { context in

      switch context.state.mode {
      case .countdown:
        countdownView(context)
      case .paused:
        pausedView(context)
      case .alert:
        alertView(context)
      }

    } dynamicIsland: { context in 

      DynamicIsland {
        DynamicIslandExpandedRegion(.leading) {
          leadingView(context)
        }
        DynamicIslandExpandedRegion(.trailing) {
          trailingView(context)
        }
      } compactLeading: {
        compactLeadingView(context)
      } compactTrailing: {
        compactTrailingView(context)
      } minimal: {
        minimalView(context)
      }

    }
  }
}

10:26 - Create custom metadata for the Live Activity

// Create custom metadata for the Live Activity

import AlarmKit

struct CookingData: AlarmMetadata {
  let method: Method
    
  init(method: Method) {
    self.method = method
  }
    
  enum Method: String, Codable {
    case frying = "frying.pan"
    case grilling = "flame"
  }
}

10:43 - Provide custom metadata to the Live Activity

// Provide custom metadata to the Live Activity

import AlarmKit

func scheduleAlarm() async throws {
    typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<CookingData>
    
    let id = UUID()
    let duration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))
    let customMetadata = CookingData(method: .frying)
    
    let stopButton = AlarmButton(
        text: "Dismiss",
        textColor: .white,
        systemImageName: "stop.circle")
    
    let repeatButton = AlarmButton(
        text: "Repeat",
        textColor: .white,
        systemImageName: "repeat.circle")
    
    let alertPresentation = AlarmPresentation.Alert(
        title: "Food Ready!",
        stopButton: stopButton,
        secondaryButton: repeatButton,
        secondaryButtonBehavior: .countdown)
    
    let attributes = AlarmAttributes<CookingData>(
        presentation: AlarmPresentation(alert: alertPresentation),
        metadata: customMetadata,
        tintColor: Color.green)
    
    let alarmConfiguration = AlarmConfiguration(
        countdownDuration: duration,
        attributes: attributes)
    
    try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)
}

11:01 - Use custom metadata in the Live Activity

// Use custom metadata in the Live Activity

import AlarmKit
import ActivityKit
import WidgetKit

struct AlarmLiveActivity: Widget {

  var body: some WidgetConfiguration { /* ... */ }

  func alarmIcon(context: ActivityViewContext<AlarmAttributes<CookingData>>) -> some View {
    let method = context.attributes.metadata?.method ?? .grilling
    return Image(systemName: method.rawValue)
  }

}

12:03 - Set up the system countdown appearance

// Set up the system countdown appearance

import AlarmKit

func scheduleAlarm() async throws {
  typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<CookingData>
    
  let id = UUID()
  let duration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))
  let customMetadata = CookingData(method: .frying)

  let stopButton = AlarmButton(
    text: "Dismiss",
    textColor: .white,
    systemImageName: "stop.circle")

  let repeatButton = AlarmButton(
    text: "Repeat",
    textColor: .white,
    systemImageName: "repeat.circle")

  let alertPresentation = AlarmPresentation.Alert(
    title: "Food Ready!",
    stopButton: stopButton,
    secondaryButton: repeatButton,
    secondaryButtonBehavior: .countdown)

  let pauseButton = AlarmButton(
    text: "Pause",
    textColor: .green,
    systemImageName: "pause")

  let countdownPresentation = AlarmPresentation.Countdown(
    title: "Cooking",
    pauseButton: pauseButton)

  let attributes = AlarmAttributes<CookingData>(
    presentation: AlarmPresentation(
      alert: alertPresentation,
      countdown: countdownPresentation),
    metadata: customMetadata,
    tintColor: Color.green)

  let alarmConfiguration = AlarmConfiguration(
    countdownDuration: duration,
    attributes: attributes)

  try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)
  
}

12:43 - Set up the system paused appearance

// Set up the system paused appearance

import AlarmKit

func scheduleAlarm() async throws {
  typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<CookingData>
    
  let id = UUID()
  let duration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))
  let customMetadata = CookingData(method: .frying)

  let stopButton = AlarmButton(
    text: "Dismiss",
    textColor: .white,
    systemImageName: "stop.circle")

  let repeatButton = AlarmButton(
    text: "Repeat",
    textColor: .white,
    systemImageName: "repeat.circle")

  let alertPresentation = AlarmPresentation.Alert(
    title: "Food Ready!",
    stopButton: stopButton,
    secondaryButton: repeatButton,
    secondaryButtonBehavior: .countdown)

  let pauseButton = AlarmButton(
    text: "Pause",
    textColor: .green,
    systemImageName: "pause")

  let countdownPresentation = AlarmPresentation.Countdown(
    title: "Cooking",
    pauseButton: pauseButton)

  let resumeButton = AlarmButton(
    text: "Resume",
    textColor: .green,
    systemImageName: "play")

  let pausedPresentation = AlarmPresentation.Paused(
    title: "Paused",
    resumeButton: resumeButton)

  let attributes = AlarmAttributes<CookingData>(
    presentation: AlarmPresentation(
      alert: alertPresentation,
      countdown: countdownPresentation,
      paused: pausedPresentation),
    metadata: customMetadata,
    tintColor: Color.green)

  let alarmConfiguration = AlarmConfiguration(
    countdownDuration: duration,
    attributes: attributes)

  try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)
  
}

14:09 - Add a custom button

// Add a custom button

import AlarmKit
import AppIntents

func scheduleAlarm() async throws {
  typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<CookingData>
    
  let id = UUID()
  let duration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))
  let customMetadata = CookingData(method: .frying)
  let secondaryIntent = OpenInApp(alarmID: id.uuidString)

  let stopButton = AlarmButton(
    text: "Dismiss",
    textColor: .white,
    systemImageName: "stop.circle")

  let openButton = AlarmButton(
    text: "Open",
    textColor: .white,
    systemImageName: "arrow.right.circle.fill")

  let alertPresentation = AlarmPresentation.Alert(
    title: "Food Ready!",
    stopButton: stopButton,
    secondaryButton: openButton,
    secondaryButtonBehavior: .custom)

  let pauseButton = AlarmButton(
    text: "Pause",
    textColor: .green,
    systemImageName: "pause")

  let countdownPresentation = AlarmPresentation.Countdown(
    title: "Cooking",
    pauseButton: pauseButton)

  let resumeButton = AlarmButton(
    text: "Resume",
    textColor: .green,
    systemImageName: "play")

  let pausedPresentation = AlarmPresentation.Paused(
    title: "Paused",
    resumeButton: resumeButton)

  let attributes = AlarmAttributes<CookingData>(
    presentation: AlarmPresentation(
      alert: alertPresentation,
      countdown: countdownPresentation,
      paused: pausedPresentation),
    metadata: customMetadata,
    tintColor: Color.green)

  let alarmConfiguration = AlarmConfiguration(
    countdownDuration: duration,
    attributes: attributes,
    secondaryIntent: secondaryIntent)

  try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)
  
}

public struct OpenInApp: LiveActivityIntent {
    public func perform() async throws -> some IntentResult { .result() }
    
    public static var title: LocalizedStringResource = "Open App"
    public static var description = IntentDescription("Opens the Sample app")
    public static var openAppWhenRun = true
    
    @Parameter(title: "alarmID")
    public var alarmID: String
    
    public init(alarmID: String) {
        self.alarmID = alarmID
    }
    
    public init() {
        self.alarmID = ""
    }
}

16:10 - Add a custom sound

// Add a custom sound

import AlarmKit
import AppIntents

func scheduleAlarm() async throws {
  typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<CookingData>
  
  let id = UUID()
  let duration = Alarm.CountdownDuration(preAlert: (10 * 60), postAlert: (5 * 60))
  let customMetadata = CookingData(method: .frying)
  let secondaryIntent = OpenInApp(alarmID: id.uuidString)

  let stopButton = AlarmButton(
    text: "Dismiss",
    textColor: .white,
    systemImageName: "stop.circle")

  let openButton = AlarmButton(
    text: "Open",
    textColor: .white,
    systemImageName: "arrow.right.circle.fill")

  let alertPresentation = AlarmPresentation.Alert(
    title: "Food Ready!",
    stopButton: stopButton,
    secondaryButton: openButton,
    secondaryButtonBehavior: .custom)

  let pauseButton = AlarmButton(
    text: "Pause",
    textColor: .green,
    systemImageName: "pause")

  let countdownPresentation = AlarmPresentation.Countdown(
    title: "Cooking",
    pauseButton: pauseButton)

  let resumeButton = AlarmButton(
    text: "Resume",
    textColor: .green,
    systemImageName: "play")

  let pausedPresentation = AlarmPresentation.Paused(
    title: "Paused",
    resumeButton: resumeButton)

  let attributes = AlarmAttributes<CookingData>(
    presentation: AlarmPresentation(
      alert: alertPresentation,
      countdown: countdownPresentation,
      paused: pausedPresentation),
    metadata: customMetadata,
    tintColor: Color.green)

  let sound = AlertConfiguration.AlertSound.named("Chime")

  let alarmConfiguration = AlarmConfiguration(
    countdownDuration: duration,
    attributes: attributes,
    secondaryIntent: secondaryIntent,
    sound: sound)

  try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)
  
}

public struct OpenInApp: LiveActivityIntent {
    public func perform() async throws -> some IntentResult { .result() }
    
    public static var title: LocalizedStringResource = "Open App"
    public static var description = IntentDescription("Opens the Sample app")
    public static var openAppWhenRun = true
    
    @Parameter(title: "alarmID")
    public var alarmID: String
    
    public init(alarmID: String) {
        self.alarmID = alarmID
    }
    
    public init() {
        self.alarmID = ""
    }
}

- 0:00 - Te damos la bienvenida
- AlarmKit es una nueva estructura que puedes usar para crear temporizadores y alarmas. Aprende sobre la experiencia, cómo obtener autorización, crear alarmas y administrar su ciclo de vida.
- 0:32 - Descripción general
- Las alarmas son alertas programadas que interrumpen el modo silencioso y muestran un título personalizado y el nombre de la app. También pueden mostrar una cuenta regresiva. Las personas pueden detener o posponer la alarma, o interactuar con botones personalizados. Las alarmas son visibles en la pantalla de bloqueo, Dynamic Island, En Espera y el Apple Watch, y las personas deben aceptarlas por app.
- 1:39 - Autorización
- Para habilitar la programación de alarmas en una app, las personas deben autorizarla. Esto se puede hacer automáticamente al crear la primera alarma, o manualmente a través de la API requestAuthorization de AlarmManager. Debes agregar NSAlarmKitUsageDescription a Info.plist para explicar cómo se usan las alarmas. Las personas pueden cambiar el estado de autorización en Configuración. Antes de programar una alarma, la app puede verificar el estado de la autorización; si se deniega, debes informar a las personas que no se programará.
- 3:06 - Creación
- La creación de una alarma implica varios componentes clave. Primero, se puede configurar con una duración de cuenta regresiva, que puede incluir un intervalo de prealerta y otro de posalerta. Cuando la alarma está programada con una cuenta regresiva, esta se muestra en una IU mientras dura la prealerta. Una vez transcurrido este tiempo, la alarma se dispara, y muestra una IU de alerta personalizada. Si se pospone, la IU de cuenta regresiva reaparecerá durante el intervalo posalerta antes de activarse de nuevo.. Para las alarmas se pueden usar un programa fijo o uno relativo. Un programa fijo especifica una única fecha y hora futuras, mientras que un programa relativo permite una hora diaria con un patrón de recurrencia semanal opcional, lo que garantiza que la alarma se ajuste correctamente a los cambios de zona horaria. Además de programar, también puedes personalizar la apariencia de la alarma. Esto incluye la creación y configuración de botones de alerta, como el botón Descartar, y la configuración del título de la alarma. Para las alarmas con función de cuenta regresiva, también puedes agregar un botón Repetir. Luego se definen la presentación y los atributos de la alerta para especificar cómo se ve y se comporta la alarma cuando se activa. Si una alarma incluye una función de cuenta regresiva, debes implementar una actividad en vivo para mostrar la IU de cuenta regresiva en la pantalla de bloqueo, Dynamic Island y En Espera. Esto implica crear una IU personalizada para la cuenta regresiva y configurar una ActivityConfiguration con los atributos de alarma adecuados. La Actividad en Vivo puede mostrar diferentes vistas dependiendo de si la cuenta regresiva está activa o en pausa, lo que proporciona una experiencia de usuario perfecta en distintos estados del dispositivo. El ejemplo introduce metadatos personalizados para pasar información adicional a la Actividad en Vivo. Estos metadatos incluyen una enumeración personalizada, que permite que la alarma muestre un ícono basado en el valor de la enumeración tanto en la pantalla de bloqueo como en Dynamic Island durante la cuenta regresiva. La sesión describe cómo crear App Intents personalizados para ejecutar código específico cuando se tocan botones, como al abrir la app. También describe cómo configurar el sonido de la alarma, lo que permite elegir un sonido personalizado o usar el sonido predeterminado del sistema.
- 16:32 - Ciclo de vida
- AlarmKit permite crear, programar y administrar alarmas usando la clase AlarmManager. Las alarmas se pueden configurar, rastrear a través de identificadores únicos y colocar en varios estados (cuenta regresiva, pausa, detenida, etc.). Las mejores prácticas incluyen el uso de alarmas para cuentas regresivas y alertas recurrentes, garantizar una presentación clara de la alerta e incluir toda la información y las acciones esenciales en la actividad en vivo de la cuenta regresiva.

Capítulos

Recursos

Videos relacionados

WWDC25

WWDC23