> ## 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.
# Configuração de desenvolvedor para Live Activities
> Configure Live Activities do iOS com OneSignal para exibir atualizações em tempo real na tela de bloqueio e Dynamic Island.
Live Activities permitem que seu aplicativo iOS mostre atualizações em tempo real diretamente na tela de bloqueio e Dynamic Island. Ideal para rastreamento de entregas, placares esportivos ou atualizações transacionais sensíveis ao tempo, eles mantêm os usuários informados sem abrir o aplicativo.
Android tem um recurso semelhante chamado [Notificações Live do Android](./android-live-notifications).
## Requisitos
* Siga a [configuração do SDK iOS](./ios-sdk-setup) se estiver usando iOS nativo (Swift/Objective-C).
* Se estiver usando um SDK wrapper (React Native, Flutter, Unity, etc.) siga a [configuração do SDK Mobile](./mobile-sdk-setup) e depois a [Configuração do SDK de Live Activity multiplataforma](./cross-platform-live-activity-setup).
* OneSignal iOS SDK versão 5.2.0+ para suporte a **push-to-start** ([consulte as notas de lançamento](https://github.com/OneSignal/OneSignal-iOS-SDK/releases/tag/5.2.0)).
* OneSignal iOS SDK versão 5.2.15+ para **rastreamento de cliques** e **Entrega Confirmada**
* iOS 16.1+ e iPadOS 17+
* Use uma [chave APNs .p8](./ios-p8-token-based-connection-to-apns). A Apple não suporta certificados p12 com Live Activities.
* Xcode 14 ou superior
***
## Configuração
Estes passos orientam você na configuração de Live Activities rapidamente. Para mais detalhes e personalizações de design, consulte a [documentação de desenvolvedor de Live Activities da Apple](https://developer.apple.com/design/human-interface-guidelines/live-activities).
### 1. Adicionar uma Widget Extension
No Xcode, vá para **File > New > Target... > Widget Extension**.
Selecione e pressione **Next**.
Configure a Widget Extension fornecendo um nome (exemplo: `OneSignalWidget`) e garanta que **Include Live Activity** esteja selecionado. Então clique em **Finish**.
Clique em **Don't Activate** se solicitado para ativar o esquema.
### 2. Atualizar `Info.plist`
No `Info.plist` do seu destino principal, adicione a chave `Supports Live Activities` como **Boolean**, e defina para `YES`.
Se você defini-la programaticamente, deve ficar assim:
```xml info.plist theme={null}
NSSupportsLiveActivities
```
Ao atualizar Live Activities, você tem a opção de definir uma "prioridade" que a Apple usa para determinar quão urgente é a atualização. A Apple tem limites internos nos quais ela limitará requisições que usam a flag de alta prioridade com muita frequência.
Se seus casos de uso para Live Activities dependem de atualizações de alta prioridade mais frequentes, você pode adicionar a chave `NSSupportsLiveActivitiesFrequentUpdates` ao seu Info.plist como um tipo Boolean definido para YES conforme instruído na [Documentação de Desenvolvedor da Apple](https://developer.apple.com/documentation/activitykit/starting-and-updating-live-activities-with-activitykit-push-notifications#Determine-the-update-frequency). Os usuários verão um diálogo quando a Live Activity exceder seu orçamento de push, e se eles permitirem que a Live Activity continue, o orçamento será automaticamente aumentado para uma experiência do usuário sem problemas.
### 3. Adicionar SDK
Se você está usando um SDK wrapper (por exemplo, **Flutter**) com SPM habilitado, pode pular esta etapa. O pacote OneSignal já está resolvido e disponível para todos os destinos.
No seu destino Widget Extension, adicione o `OneSignalFramework` em **General > Frameworks, Libraries and Embedded Content**:
Encontre o nome do seu destino widget extension na lista de Targets do seu projeto. O nome do exemplo é `OneSignalWidgetExtension`.
Abra seu `Podfile` e adicione o seguinte código. Substitua `OneSignalWidgetExtension` pelo nome do seu destino widget extension.
```ruby Podfile theme={null}
target 'OneSignalWidgetExtension' do
use_frameworks!
pod 'OneSignal/OneSignal', '>= 5.0.0', '< 6.0'
end
```
```ruby Full Podfile example theme={null}
# Uncomment the next line to define a global platform for your project
# platform :ios, '9.0'
target 'Demo Momenta' do
# Comment the next line if you don't want to use dynamic frameworks
use_frameworks!
pod 'OneSignal/OneSignal', '>= 5.0.0', '< 6.0'
pod 'OneSignal/OneSignalInAppMessages', '>= 5.0.0', '< 6.0'
end
target 'OneSignalNotificationServiceExtension' do
use_frameworks!
pod 'OneSignal/OneSignal', '>= 5.0.0', '< 6.0'
end
target 'OneSignalWidgetExtension' do
use_frameworks!
pod 'OneSignal/OneSignal', '>= 5.0.0', '< 6.0'
end
```
Feche o Xcode e execute `pod repo update && pod install` para instalar o pod `OneSignalLiveActivities`.
Se você continuar vendo o erro "No such module 'OneSignalLiveActivities'" depois disso, você pode adicionar a dependência manualmente indo para seu **"Widget Extension Target" > General > Frameworks and Libraries > + icon**. Selecione o framework `OneSignalLiveActivities`:
### 4. Definir atributos e UI do widget
Abra o arquivo `your-nameLiveActivity.swift` (exemplo: `OneSignalWidgetLiveActivity.swift`) para definir as propriedades da estrutura e fazer alterações na UI do widget.
* `your-nameAttributes` descreve o conteúdo estático da sua Live Activity.
* `ContentState` descreve o conteúdo dinâmico da sua Live Activity.
Se você estiver seguindo o exemplo, copie e cole o código abaixo em seu arquivo `OneSignalWidgetLiveActivity.swift`.
```swift your-nameLiveActivity.swift theme={null}
import ActivityKit
import WidgetKit
import SwiftUI
// Import the OneSignalLiveActivities module
// If you get an error about the module not being found, return to step 3 and ensure you have added the OneSignalLiveActivities pod correctly.
import OneSignalLiveActivities
// Update to inherit from OneSignalLiveActivityAttributes
// This will be used in your API requests to start a Live Activity
struct OneSignalWidgetAttributes: OneSignalLiveActivityAttributes {
// Update to inherit from OneSignalLiveActivityContentState
public struct ContentState: OneSignalLiveActivityContentState {
// Dynamic stateful properties about your activity go here!
var emoji: String
// Add a reference to OneSignalLiveActivityContentStateData?
var onesignal: OneSignalLiveActivityContentStateData?
}
// Fixed non-changing properties about your activity go here!
var name: String
// Add a reference to OneSignalLiveActivityAttributeData
var onesignal: OneSignalLiveActivityAttributeData
}
struct OneSignalWidgetLiveActivity: Widget {
var body: some WidgetConfiguration {
// Update to use `for: the-name-of-your-attributes-struct`
// This will be used in your API requests to start a Live Activity
ActivityConfiguration(for: OneSignalWidgetAttributes.self) { context in
// Lock screen/banner UI goes here
// Update to show the attributes sent via the payload
VStack {
Text("Hello \(context.attributes.name) \(context.state.emoji)")
}
.activityBackgroundTint(Color.cyan)
.activitySystemActionForegroundColor(Color.black)
} dynamicIsland: { context in
DynamicIsland {
// Expanded UI goes here. Compose the expanded UI through
// various regions, like leading/trailing/center/bottom
DynamicIslandExpandedRegion(.leading) {
Text("Leading")
}
DynamicIslandExpandedRegion(.trailing) {
Text("Trailing")
}
DynamicIslandExpandedRegion(.bottom) {
Text("Bottom \(context.state.emoji)")
// more content
}
} compactLeading: {
Text("L")
} compactTrailing: {
Text("T \(context.state.emoji)")
} minimal: {
Text(context.state.emoji)
}
.widgetURL(URL(string: "http://www.apple.com"))
.keylineTint(Color.red)
}
}
}
```
### 5. Permitir associação ao destino principal
Esta etapa só é necessária ao usar atributos personalizados (por exemplo, `OneSignalWidgetAttributes`). Se você está usando `DefaultLiveActivityAttributes`, pule esta etapa — o tipo é fornecido pelo SDK do OneSignal e já está acessível a partir do destino principal do aplicativo.
Adicione seu destino de aplicativo principal à lista **Target Membership** no arquivo `your-nameLiveActivity.swift`. Isso é necessário para que o destino principal do aplicativo possa referenciar sua struct de atributos personalizados na chamada de configuração (Etapa 6).
No Xcode, abra o painel Inspector no lado direito da tela. Dentro de **Target Membership**, clique no botão **+** e selecione seu destino de aplicativo principal contendo o `ContentView` e seu código de inicialização do OneSignal.
### 6. Adicionar o método de configuração ao seu AppDelegate
Chame `OneSignal.LiveActivities.setup` em seu `AppDelegate`, após a inicialização do SDK OneSignal.
Substitua `OneSignalWidgetAttributes` pelo nome da sua estrutura de atributos de Live Activity.
```swift AppDelegate theme={null}
// Import the OneSignalLiveActivities module
import OneSignalLiveActivities
// This should be added after initializing the OneSignal SDK
if #available(iOS 16.1, *) {
OneSignal.LiveActivities.setup(OneSignalWidgetAttributes.self)
// If you have multiple Live Activities, you can add them here with the setup method
// OneSignal.LiveActivities.setup(LiveActivityWidgetAttributes-2.self)
}
```
Isso gerencia e relata atualizações usando sequências assíncronas do ActivityKit.
Se você também consumir qualquer uma das seguintes sequências diretamente em seu aplicativo, isso pode interferir no comportamento da Live Activity do OneSignal:
* activityStateUpdates
* pushTokenUpdates
* pushToStartTokenUpdates
* activityUpdates
***
## Iniciar uma Live Activity
Existem 2 opções para iniciar uma Live Activity em um dispositivo:
Envie uma [requisição da API Push To Start](/reference/start-live-activity). Certifique-se de que todos os nomes e IDs correspondam exatamente à configuração do seu widget (os parâmetros são sensíveis a maiúsculas e minúsculas). Se algo estiver faltando ou adicionado incorretamente, você pode encontrar problemas ao tentar lançar o widget.
Aqui está um exemplo de requisição que funcionará para o exemplo acima.
Substitua:
* `YOUR_APP_ID` pelo seu OneSignal App ID.
* `YOUR_APP_API_KEY` pela sua chave de API do OneSignal.
* `OneSignalWidgetAttributes` pelo nome da sua estrutura de Widget Attributes.
```curl curl theme={null}
curl --location 'https://api.onesignal.com/apps/YOUR_APP_ID/activities/activity/OneSignalWidgetAttributes' \
--header 'Authorization: key YOUR_APP_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"event": "start",
"activity_id": "push-to-start",
"included_segments": [
"Subscribed Users"
],
"event_attributes": {
"name": "World"
},
"event_updates": {
"emoji":"🤩"
},
"name": "Live Activities Test",
"contents": {
"en": "A push started this Live Activity"
},
"headings": {
"en": "Live Activity Started"
}
}'
```
Se você estiver seguindo o código de exemplo fornecido, você deve ver a Live Activity na tela de bloqueio do seu dispositivo.
Você iniciou com sucesso uma Live Activity com push-to-start!
Os usuários precisarão selecionar "Allow" para continuar recebendo atualizações.
Você pode fazer um usuário ativar uma Live Activity enquanto interage com seu aplicativo.
Por exemplo, quando um usuário tem um evento ativo acontecendo (eles fizeram um pedido, um jogo está em andamento, um evento está prestes a começar, etc.) e abre seu aplicativo, você pode exibir uma Live Activity automaticamente.
Neste exemplo usaremos um botão para iniciar a Live Activity manualmente.
```swift theme={null}
import SwiftUI
import ActivityKit
import OneSignalFramework
import OneSignalLiveActivities
struct ContentView: View {
@StateObject private var viewModel = LiveActivityViewModel()
var body: some View {
VStack {
Button("Start Live Activity") {
viewModel.startLiveActivity()
}
}
}
}
class LiveActivityViewModel: ObservableObject {
func startLiveActivity() {
let osAttributes = OneSignalLiveActivityAttributeData.create(activityId: "click-to-start")
let attributes = OneSignalWidgetAttributes(name: "OneSignal", onesignal: osAttributes)
let contentState = OneSignalWidgetAttributes.ContentState(emoji:"🤩", onesignal: nil)
do {
let activity = try Activity.request(
attributes: attributes,
contentState: contentState,
pushType: .token)
} catch {
print(error.localizedDescription)
}
}
}
```
Ao clicar no botão, ele lançará a Live Activity.
***
## Rastreamento de cliques em Live Activity
Rastreie quando os usuários tocam em suas Live Activities e Dynamic Islands implementando o rastreamento de cliques do OneSignal. Isso permite medir o engajamento e, opcionalmente, direcionar os usuários para conteúdo específico no seu app via deep link.
### Passo 1: Adicionar rastreamento de cliques ao seu widget
Adicione o modificador `.onesignalWidgetURL()` a qualquer componente de UI no seu widget Live Activity do qual você deseja rastrear cliques:
```swift theme={null}
import OneSignalLiveActivities
struct ExampleAppFirstWidget: Widget {
var body: some WidgetConfiguration {
ActivityConfiguration(for: ExampleAppFirstWidgetAttributes.self) { context in
VStack {
Spacer()
Text("Sample Text " + context.attributes.title).font(.headline)
// Other UI code
}
.onesignalWidgetURL(URL(string: "myapp://settings"), context: context)
// Pass nil if you don't need deep linking: .onesignalWidgetURL(nil, context: context)
} dynamicIsland: { context in
DynamicIsland {
DynamicIslandExpandedRegion(.leading) {
Text("Leading")
}
// Other Dynamic Island regions
} compactLeading: {
Text("L")
} compactTrailing: {
Text("T")
} minimal: {
Text("Min")
}
.onesignalWidgetURL(URL(string: "myapp://settings"), context: context)
// Optional: Track Dynamic Island clicks separately
}
}
}
```
**Considerações importantes:**
* Você pode passar uma URL para deep linking ou `nil` se quiser apenas rastreamento de cliques sem navegação
* A hierarquia de visualizações **não pode incluir** o modificador `.widgetURL()` da Apple se você estiver usando `.onesignalWidgetURL()`
* Aplique o modificador tanto à visualização principal da Live Activity quanto ao Dynamic Island se quiser rastrear cliques em ambos
### Passo 2: Tratar URLs no seu app
Adicione tratamento de URLs no seu app para rastrear cliques e direcionar os usuários adequadamente:
```swift theme={null}
import OneSignalLiveActivities
// AppDelegate example:
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
let originalURL = OneSignal.LiveActivities.trackClickAndReturnOriginal(url)
// Handle the original URL and navigate user
if let url = originalURL {
// Your custom URL routing logic
return handleDeepLink(url)
}
return false
}
// SceneDelegate example:
func scene(_ scene: UIScene, openURLContexts URLContexts: Set) {
guard let url = URLContexts.first?.url else { return }
let originalURL = OneSignal.LiveActivities.trackClickAndReturnOriginal(url)
if let url = originalURL {
// Your custom URL routing logic
handleDeepLink(url)
}
}
// SwiftUI example:
.onOpenURL { url in
let originalURL = OneSignal.LiveActivities.trackClickAndReturnOriginal(url)
if let url = originalURL {
// Your custom URL routing logic
handleDeepLink(url)
}
}
```
O método `trackClickAndReturnOriginal()` rastreia automaticamente o clique com o OneSignal e retorna a URL original que você especificou no widget para que seu app processe.
***
## Atualizar uma Live Activity
Use a [API Update Live Activity](/reference/update-live-activity-api) para atualizar widgets ativos.
Corresponda ao `activity_id` usado ao iniciar a atividade.
Este exemplo de requisição atualizará o widget push-to-start porque ele tem o `activity_id` intitulado `push-to-start` que definimos.
Para atualizar o widget click-to-start, atualize o caminho da requisição para usar `click-to-start` em vez de `push-to-start`.
```curl curl theme={null}
curl --location 'https://api.onesignal.com/apps/YOUR_APP_ID/live_activities/push-to-start/notifications' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'Authorization: key YOUR_API_KEY' \
--data '{
"event": "update",
"event_updates": {
"emoji": "😎"
},
"contents": {
"en": "A push updated this Live Activity"
},
"name": "Live Activity Updated"
}'
```
Você atualizou com sucesso uma Live Activity!
Confira a [API Update Live Activity](/reference/update-live-activity-api) para mais informações sobre atualização de uma Live Activity.
***
## Encerrar uma Live Activity
Usando a mesma [API Update Live Activity](/reference/update-live-activity-api), podemos encerrar uma Live Activity definindo `"event": "end"`.
```curl curl theme={null}
curl --location 'https://api.onesignal.com/apps/YOUR_APP_ID/live_activities/my_activity_id/notifications' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'Authorization: key YOUR_API_KEY' \
--data '{
"event": "end",
"event_updates": {
"emoji": "👋"
},
"contents": {
"en": "A push ended this Live Activity"
},
"name": "Live Activity Ended"
}'
```
Outras formas de uma Live Activity terminar:
* Use nosso método do SDK [`exit()`](./mobile-sdk-reference#exit).
* Usuário desliza manualmente a Live Activity para removê-la.
* Usuário revoga permissão para Live Activities em suas Configurações do iOS.
Você encerrou com sucesso a Live Activity e completou o exemplo!
***
## Melhores práticas e recomendações
### Considerações de design
* Siga as [Diretrizes de Interface Humana de Live Activities da Apple](https://developer.apple.com/design/human-interface-guidelines/live-activities).
* Priorize informações importantes para facilitar o entendimento em uma olhada rápida.
* Não adicione elementos ao seu aplicativo que chamem atenção para a Dynamic Island.
* Use margens e mantenha espaço entre elementos.
* Use uma cor forte para o fundo. Projete para os modos Light e Dark.
### Funcionalidade
* A Apple requer que cada [apresentação de Live Activity](https://developer.apple.com/documentation/activitykit/displaying-live-data-with-live-activities#Review-Live-Activity-presentations) seja suportada.
* [Compacta](https://developer.apple.com/design/human-interface-guidelines/live-activities#Compact-presentation)
* [Mínima](https://developer.apple.com/design/human-interface-guidelines/live-activities#Minimal-presentation)
* [Expandida](https://developer.apple.com/design/human-interface-guidelines/live-activities#Expanded-presentation)
* [Tela de Bloqueio](https://developer.apple.com/design/human-interface-guidelines/live-activities#The-Lock-Screen)
* Teste seus [deep links](https://developer.apple.com/design/human-interface-guidelines/live-activities#Offering-interactivity).
* Revise o guia da Apple sobre [Exibindo Dados Live com Live Activities](https://developer.apple.com/documentation/activitykit/displaying-live-data-with-live-activities).
* Evite exibir informações sensíveis em uma Live Activity.
### Definir uma mensagem de fallback
Se um usuário não conseguir receber uma atualização depois que uma Live Activity foi iniciada, abrir o app deve atualizar a atividade. Defina a [data de obsolescência](/reference/start-live-activity#body-stale-date) para um ponto no futuro após você esperar ter enviado a primeira atualização. Os usuários que não receberam a atualização verão a mensagem de fallback.
Você pode escutar o estado "stale" na sua UI de widget para mostrar uma mensagem de fallback:
```swift theme={null}
struct ptsLiveActivity: Widget {
var body: some WidgetConfiguration {
ActivityConfiguration(for: ptsAttributes.self) { context in
//This will flip to true after the stale date
let isStale = context.isStale
if !isStale{
VStack {
Text("\(context.attributes.name) \(context.state.emoji)")
.activityBackgroundTint(Color.cyan)
.activitySystemActionForegroundColor(Color.black)
}
} else {
//If the message is stale, we request the user clicks the widget to open the app
VStack {
Text("Something went wrong, please click to refresh")
}
}
// ... Rest of the widget UI
}
}
}
```
***
## FAQ
### Qual é o orçamento para atualizações de alta prioridade?
A Apple não fornece um limite fixo para atualizações de alta prioridade (`priority: 10`), mas eles aplicam um orçamento dinâmico no nível do sistema. Enviar muitas atualizações de alta prioridade em um curto período pode resultar em limitação, onde atualizações são atrasadas ou descartadas.
Para reduzir o risco de limitação:
* Use uma mistura de níveis de prioridade: A Apple recomenda usar tanto `priority: 5` (padrão) quanto `priority: 10` (alta) para equilíbrio.
* Reserve `priority: 10` apenas para atualizações sensíveis ao tempo ou críticas (por exemplo, mudanças de status de pedido, placares de jogos).
Se seu caso de uso requer atualizações frequentes:
* Adicione a chave `NSSupportsLiveActivitiesFrequentUpdates` ao arquivo `Info.plist` do seu aplicativo, definida como Boolean `YES`.
* Quando este orçamento é excedido, o iOS pode solicitar ao usuário que permita atualizações adicionais. Se o usuário concordar, a Apple expandirá automaticamente o limite de atualização permitido para manter uma experiência sem problemas.
Para mais detalhes, consulte a [Documentação de Desenvolvedor da Apple](https://developer.apple.com/documentation/activitykit/starting-and-updating-live-activities-with-activitykit-push-notifications#Determine-the-update-frequency).
### Posso ler atualizações de Live Activity do aplicativo principal?
Sim. Você pode observar atualizações para depuração ou sincronização de UI:
```swift theme={null}
Task {
for await content in activity.contentUpdates {
print("LA activity id: \(activity.id), content update: \(content.state)")
}
}
// Example output:
// LA activity id: EFE6D54D-F7E1-45EF-9514-4C2598F8DED2, content update: ContentState(message: "My message from payload")
```
Rastreie mudanças de ciclo de vida:
```swift theme={null}
Task {
for await state in activity.activityStateUpdates {
print("LA state update: \(state)")
//Se você quiser fazer algo baseado no estado, você usaria isso:
if state != ActivityState.active {
//Faça algo aqui
}
}
}
// Exemplo de saída 1 - LA encerrada, mas ainda visível
// LA state update: active
/* Estado pode ser igual a 4 valores possíveis no enum ActivityState
active, dismissed, ended, e stale
*/
```
### A API retornou um 400 com uma mensagem de erro dizendo que estou acima do limite de assinantes. O que fazer?
Se sua contagem de assinantes push for maior que os Assinantes Push do seu plano, por favor atualize sua conta para o próximo plano, ou entre em contato com `support@onesignal.com`. Para os detalhes de plano mais recentes, [veja aqui](https://onesignal.com/pricing).
### Como evito enviar tanto push quanto Live Activities?
Seu aplicativo pode já enviar uma série de Notificações Push, onde sua Live Activity projetada substitui a necessidade dessas Notificações Push. Por exemplo, se você envia atualizações de placar via Push, você poderia substituir isso através de uma Live Activity.
Para garantir que seus usuários não estejam recebendo muitas mensagens, recomendamos que, quando seu usuário opta por uma Live Activity, adicione uma data tag. Ao adicionar esta data tag, você pode excluir usuários com esta data tag de mensagens push que possam conter o mesmo conteúdo ou similar. Leia mais sobre [Tags](./add-user-data-tags) e [Segmentos](./segmentation).
***
## Solução de problemas
### Sem destinatários
Para que seus usuários sejam encontrados ao tentar iniciar ou atualizar uma Live Activity, você deve garantir que o tipo de atividade, widget e requisição cURL tenham valores correspondentes.
1. Verifique os parâmetros de caminho em sua requisição para garantir que você está enviando uma requisição formatada corretamente para o servidor. O App ID deve corresponder ao seu App ID usado no método `OneSignal.Initialize` e o tipo de atividade deve corresponder ao tipo que você definiu em seu arquivo de Live Activity.
2. No corpo da [requisição da API Push To Start](/reference/start-live-activity), você deve ter os seguintes parâmetros:
* `event`: `"start"`
* `event_updates`: Os dados dinâmicos que você definiu em sua estrutura sob o tipo de atividade e que são usados em seu widget. Garanta que o uso de maiúsculas/minúsculas e variáveis correspondam entre a requisição, o tipo e o widget.
* `event_attributes`: Dados estáticos seguem a mesma lógica que Event Updates e devem incluir todas as variáveis em uso, e devem corresponder em todas as partes da live activity e da requisição
* `activity_id`: Isso atribuirá um ID ao widget e é o que será usado para atualizar a atividade depois que ela for lançada no dispositivo do usuário.
* `name`: O Nome da Live Activity.
* `contents`: O conteúdo da mensagem necessário para enviar push.
* `headings`: O cabeçalho da mensagem necessário para enviar push.
* Um parâmetro de direcionamento como `included_segments`. [Opções disponíveis](/reference/create-message).
### Atividade enviada, mas não recebida
1. Garanta que a requisição está formatada corretamente. Se algum campo que é usado no Widget for omitido, a atividade pode não iniciar ou atualizar como esperado.
2. Em sua requisição da API, determine o nível de `priority` que você está definindo. Se você está definindo isso para `10` (prioridade mais alta), tente reduzir para `5` e teste novamente. A Apple limitará requisições sendo enviadas com muita frequência de acordo com seus próprios limites de taxa internos.
Se seu caso de uso depende de atualizações mais frequentes, adicione a chave `NSSupportsLiveActivitiesFrequentUpdates` ao seu Info.plist como um tipo Boolean definido para YES conforme instruído na [Documentação de Desenvolvedor da Apple](https://developer.apple.com/documentation/activitykit/starting-and-updating-live-activities-with-activitykit-push-notifications#Determine-the-update-frequency). O usuário verá um diálogo quando a Live Activity exceder seu orçamento de push, e se eles permitirem que a Live Activity continue, o orçamento será automaticamente aumentado para uma experiência do usuário sem problemas.
Precisa de ajuda?
Converse com nossa equipe de Suporte ou envie email para `support@onesignal.com`
Por favor inclua:
* Detalhes do problema que você está enfrentando e passos para reproduzir se disponível
* Seu OneSignal App ID
* O External ID ou Subscription ID se aplicável
* A URL para a mensagem que você testou no Dashboard OneSignal se aplicável
* Quaisquer [logs ou mensagens de erro](/docs/pt-BR/capturing-a-debug-log) relevantes
Estamos felizes em ajudar!
***