Live Activities do iOS

Dica

Assista a um vídeo sobre as Live Activities do iOS

Vídeo do Youtube: Live Activities do iOS

As Live Activities exibem os dados mais atuais do seu aplicativo na Tela de Bloqueio do iPhone ou iPad e na Dynamic Island. Este recurso permite que os usuários vejam informações ao vivo rapidamente e realizem ações rápidas relacionadas às informações exibidas.

Aqui estão alguns exemplos de uso das Live Activities:

• Mostrar o status do pedido em um aplicativo de entrega;
• Fornecer uma contagem regressiva em tempo real em um aplicativo de treinamento;
• Mostrar informações de rastreamento em um aplicativo de táxi;
• Exibir estatísticas de jogos e placares atuais em um aplicativo de esportes;
• Fornecer previsões horárias em um aplicativo de previsão do tempo.

Você pode habilitar as Live Activities usando o SDK do Pushwoosh para iOS, conforme descrito abaixo. Para gerenciar as Live Activities e atualizar seu conteúdo, use o método /updateLiveActivity.

Configuração

Importante

As Live Activities no Pushwoosh suportam apenas a configuração baseada em token. A configuração baseada em certificado não é suportada.

Adicionar uma Widget Extension

1. Crie um novo target

Vá para File > New > Target e selecione Widget Extension.

2. Configuração da Widget Extension Por favor, insira um nome e certifique-se de selecionar Include Live Activity e clique em Finish.

Configuração do Info.plist

Encontre o arquivo Info.plist no target principal, insira a chave “Supports Live Activities” e defina seu valor como YES.

  <key>NSSupportsLiveActivities</key>
  <true/>

Habilitando live activities a partir do aplicativo

Para habilitar as Live Activities, adicione o código delas à sua extensão de widget existente ou crie uma nova se o seu aplicativo ainda não tiver uma. As Live Activities usam a funcionalidade do SwiftUI e do WidgetKit para sua interface de usuário. O ActivityKit lida com o ciclo de vida de cada Live Activity: sua API é usada para solicitar, atualizar e encerrar uma Live Activity e para receber notificações push do ActivityKit. Você pode aprender mais sobre as Live Activities na documentação da Apple.

1. Navegue até o arquivo ContentView do seu projeto no Xcode e crie um Button

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack(spacing: 20) {

            Button(action: {
                LiveActivityManager.shared.startActivity()
            }, label: {
                Text("Start Live Activity")
                    .foregroundColor(.white)
                    .padding()
                    .background(Color.blue)
                    .cornerRadius(10)
            })
        }
        .padding()
    }
}

#Preview {
    ContentView()
}

2. Crie um arquivo LiveActivityManager.swift para gerenciar as Live Activities

import Foundation
import ActivityKit
import UIKit
import PushwooshFramework
import PushwooshLiveActivities

class LiveActivityManager: NSObject, ObservableObject {
    public static let shared: LiveActivityManager = LiveActivityManager()

    private var currentActivity: Activity<FoodDeliveryAttributes>? = nil

    override init() {
        super.init()
    }

    func startActivity() {
        guard ActivityAuthorizationInfo().areActivitiesEnabled else {
            print("You can't start live activity.")
            return
        }
        do {
            let pushwooshData = PushwooshLiveActivityAttributeData(activityId: "activity_id")
            let atttribute = FoodDeliveryAttributes(orderNumber: "1234567", pushwoosh: pushwooshData)
            let initialState = FoodDeliveryAttributes.ContentState(
                status: "Preparing your meal",
                estimatedTime: "25 min",
                emoji: "👨‍🍳",
                pushwoosh: nil
            )
            let activity = try Activity<FoodDeliveryAttributes>.request(
                attributes: atttribute,
                content: .init(state:initialState , staleDate: nil),
                pushType: .token
            )
            self.currentActivity = activity

            Task {
                for await pushToken in activity.pushTokenUpdates {
                    let pushTokenString = pushToken.reduce("") {
                        $0 + String(format: "%02x", $1)
                    }
                    print("Activity:\(activity.id) push token: \(pushTokenString)")

                    // MARK: - Send Push Token to Pushwoosh
                    Pushwoosh.LiveActivities.startLiveActivity(
                        token: pushTokenString,
                        activityId: "activity_id"
                    )
                }
            }
        } catch {
            print("Start Activity Error: \(error.localizedDescription)")
        }
    }
}

3. É isso, agora executamos o projeto e pressionamos o botão ‘Start Live Activity’. Em seguida, navegamos para a tela de bloqueio e vemos a Live Activity criada.

Iniciar uma Live Activity com uma notificação push remota

1. Para iniciar uma Live Activity via Notificação Push Remota, você precisa enviar o token pushToStartTokenUpdates para o Pushwoosh.

func getPushToStartToken() {
    if #available(iOS 17.2, *) {
        Task {
            for await data in Activity<LiveActivityAttributes>.pushToStartTokenUpdates {
                let token = data.map {String(format: "%02x", $0)}.joined()
                print("Activity PushToStart Token: \(token)")

                // Send `pushToStartTokenUpdates` token to Pushwoosh
                try await Pushwoosh.LiveActivities.sendPushToStartLiveActivity(token: token)
            }
        }
    }
}

2. Inicie uma Live Activity com uma Notificação Push Remota

Dica

Siga nossa referência da API do Pushwoosh para obter instruções e exemplos sobre como fazer uma solicitação para iniciar uma Live Activity remotamente.

Gerenciando Live Activities

O SDK do Pushwoosh para iOS fornece os seguintes métodos para trabalhar com as Live Activities:

// Send Live Activity Push To Start Token to Pushwoosh
static func sendPushToStartLiveActivity(token: String)
static func sendPushToStartLiveActivity(token: String, completion: @escaping (Error?) -> Void)

// Start Live Activity Methods with Activity ID
static func startLiveActivity(token: String, activityId: String)
static func startLiveActivity(token: String, activityId: String, completion: @escaping (Error?) -> Void)

// Stop Live Activity Methods
static func stopLiveActivity()
static func stopLiveActivity(completion: @escaping (Error?) -> Void)

static func stopLiveActivity(activityId: String)
static func stopLiveActivity(activityId: String, completion: @escaping (Error?) -> Void)

// Schedule a Live Activity to start at a future date (iOS 26.0+)
static func schedule<Attributes: PushwooshLiveActivityAttributes>(attributes: Attributes, contentState: Attributes.ContentState, at startDate: Date, alertTitle: String, alertBody: String) throws -> Activity<Attributes>

// Cancel a scheduled or running Live Activity by its Activity ID (iOS 16.2+)
static func cancel<Attributes: PushwooshLiveActivityAttributes>(_ activityType: Attributes.Type, activityId: String)

Você também pode atualizar as live activities por segmentos usando o parâmetro Activity ID. Ao criar uma atividade, você precisa passar um parâmetro Activity ID exclusivo no método, que será relevante para um segmento de usuário específico.

Por exemplo, N usuários se inscreveram no mesmo evento em uma live Activity. É necessário que o parâmetro Activity ID seja exclusivo para todos esses N usuários.

Quando terminar de trabalhar com uma Live Activity, use estes métodos:

static func stopLiveActivity()
static func stopLiveActivity(completion: @escaping (Error?) -> Void)

Nota

Você pode gerenciar as Live Activities do iOS através da API do Pushwoosh.

Agendando uma Live Activity para iniciar em uma data futura

Nota

Requer iOS 26.0+.

Em vez de iniciar uma Live Activity imediatamente, você pode agendá-la para iniciar em uma data futura. alertTitle e alertBody são mostrados ao usuário no alerta de notificação local disparado quando a atividade agendada realmente começa:

if #available(iOS 26.0, *) {
    let startDate = Date().addingTimeInterval(3600) // starts in 1 hour

    do {
        let activity = try Pushwoosh.LiveActivities.schedule(
            attributes: atttribute,
            contentState: initialState,
            at: startDate,
            alertTitle: "Game starting!",
            alertBody: "The match is about to begin"
        )
        self.currentActivity = activity
    } catch {
        print("Schedule Activity Error: \(error.localizedDescription)")
    }
}

startDate deve ser no futuro, caso contrário, a chamada lança uma exceção. Chame schedule na thread principal enquanto o aplicativo está em primeiro plano. Não há solicitação de agendamento para o Pushwoosh: o servidor fica sabendo da atividade assim que ela realmente começa e recebe seu token de push através do mesmo observador de token instalado pelo método setup() (veja abaixo).

Cancelando uma Live Activity pelo Activity ID

Nota

Requer iOS 16.2+.

Use cancel(_:activityId:) para cancelar uma Live Activity pelo seu Activity ID sem manter uma referência à instância da Activity:

if #available(iOS 16.2, *) {
    Pushwoosh.LiveActivities.cancel(FoodDeliveryAttributes.self, activityId: "activity_id")
}

cancel encerra a atividade no dispositivo imediatamente e notifica o servidor do Pushwoosh. Isso difere de stopLiveActivity(activityId:), que apenas notifica o servidor e não encerra a atividade no dispositivo diretamente. cancel também funciona para uma Live Activity que foi agendada com schedule mas ainda não começou — ela é cancelada antes mesmo de começar.

Método Setup().

O Pushwoosh simplifica a transferência de IDs de atividade introduzindo a função PushwooshLiveActivities.setup, que lida com todo o ciclo de vida de uma Live Activity dentro do aplicativo. Esta função ouve automaticamente as atualizações de token pushToStart e pushToUpdate. Ao usar este método, o aplicativo não precisa mais rastrear manualmente o início das Live Activities ou gerenciar as atualizações de token para as atualizações de atividade.

Recomendamos usar este método porque ele lida com todo o gerenciamento de tokens do nosso lado, reduzindo a quantidade de código que você precisa manter do seu lado. Isso simplifica a integração e garante uma experiência mais suave e eficiente para o seu aplicativo.

No AppDelegate, certifique-se de importar PushwooshFramework e PushwooshLiveActivities e chamar o método setup do módulo Pushwoosh.LiveActivities.

AppDelegate.swift

if #available(iOS 16.1, *) {
    Pushwoosh.LiveActivities.setup(FoodDeliveryAttributes.self)
}

FoodDeliveryAttributes

import WidgetKit
import SwiftUI
import ActivityKit
import PushwooshFramework
import PushwooshLiveActivities

struct FoodDeliveryAttributes: PushwooshLiveActivityAttributes {
    public struct ContentState: PushwooshLiveActivityContentState {
        var status: String
        var estimatedTime: String
        var emoji: String
        var pushwoosh: PushwooshLiveActivityContentStateData?
    }

    var orderNumber: String
    var pushwoosh: PushwooshLiveActivityAttributeData
}

FoodDeliveryAttributes: Esta estrutura está em conformidade com o protocolo PushwooshLiveActivityAttributes. É usada para definir os atributos de uma live activity dentro do aplicativo.

Nota

Você pode gerenciar as Live Activities e atualizar seu conteúdo usando o método /updateLiveActivity da API do Pushwoosh. Para mais informações, por favor, leia este guia

Guia de migração

A partir da versão 6.8.0 do SDK do Pushwoosh para iOS, atualizamos a estrutura do SDK. Os métodos das Live Activities agora são acessados através do módulo PushwooshLiveActivities.

Se você estava usando uma versão do SDK do Pushwoosh para iOS anterior à 6.8.0 e estava chamando os métodos listados abaixo, e desde então atualizou para a versão 6.8.0 ou posterior, por favor, observe as seguintes mudanças:

static func setup<Attributes: PushwooshLiveActivityAttributes>(_ activityType: Attributes.Type)
static func defaultSetup()
static func defaultStart(_ activityId: String, attributes: [String: Any], content: [String: Any])

Agora, para acessar esses métodos, você deve usar o módulo LiveActivity.

import PushwooshFramework
import PushwooshLiveActivities

Pushwoosh.LiveActivities.setup(FoodDeliveryAttributes.self)
Pushwoosh.LiveActivities.defaultSetup()
Pushwoosh.LiveActivities.defaultStart("activity_id",
                            attributes: ["key_attribute": "value_attribute"],
                            content: ["key_content": "value_content"])

Também mantivemos o suporte para os métodos através de Pushwoosh.sharedInstance(), conforme listado abaixo, mas observe que esses métodos serão descontinuados em versões futuras.

// Send Live Activity Push To Start Token to Pushwoosh
static func sendPushToStartLiveActivity(token: String)
static func sendPushToStartLiveActivity(token: String, completion: @escaping (Error?) -> Void)

// Start Live Activity Methods with Activity ID
static func startLiveActivity(token: String, activityId: String)
static func startLiveActivity(token: String, activityId: String, completion: @escaping (Error?) -> Void)

// Stop Live Activity Methods
static func stopLiveActivity()
static func stopLiveActivity(completion: @escaping (Error?) -> Void)

static func stopLiveActivity(activityId: String)
static func stopLiveActivity(activityId: String, completion: @escaping (Error?) -> Void)