---
metadata:
- name: generator
content: Diplodoc Platform v5.52.0
alternate:
- https://ads.yandex.com/helpcenter/en/dev/ios/app-open-ad.md
- https://ads.yandex.com/helpcenter/pt/dev/ios/app-open-ad.md
- https://ads.yandex.com/helpcenter/ru/dev/ios/app-open-ad.md
- https://ads.yandex.com/helpcenter/zh/dev/ios/app-open-ad.md
- href: pt/dev/ios/app-open-ad.md
type: text/markdown
title: Markdown version
- href: llms.txt
type: text/markdown
title: llms.txt
---
> **Documentation Index:** Fetch the complete configuration index at https://ads.yandex.com/helpcenter/pt/llms.txt
# Anúncios App Open
Os anúncios de abertura de aplicativos são um formato de anúncio especial para monetizar as telas de carregamento do seu app. Esses anúncios podem ser fechados a qualquer momento e são projetados para serem veiculados quando os usuários colocam seu aplicativo em primeiro plano, seja na inicialização ou quando retornam a ele do segundo plano.
Este guia abrange o processo de integração de anúncios exibidos ao abrir um aplicativo iOS. Além de exemplos de código e instruções, contém recomendações específicas aos formatos e links para recursos adicionais.
{% note alert %}
Os anúncios de abertura de aplicativos só podem ser colocados em aplicativos com orientação vertical. Os anúncios não serão exibidos em orientação horizontal.
{% endnote %}
## Layout
Os anúncios App Open incluem um botão **Go to the app** para que os usuários saibam que estão no seu aplicativo e possam fechar o anúncio. Veja um exemplo de como um anúncio se parece:
## Pré-requisito {#pre}
1. Siga os passos de integração do SDK descritos em [Início rápido](../../../en/dev/ios/quick-start.md).
2. [Inicialize](../../../en/dev/ios/quick-start.md#init) seu SDK de anúncios com antecedência.
3. Confirme se você está utilizando a última versão do [Yandex Mobile Ads SDK](../../../en/dev/platforms.md). Se você estiver usando mediação, confirme se também está utilizando a última versão da [compilação unificada](../../../en/dev/platforms.md).
### Termos e definições
* **Inicialização a frio** é a inicialização de um aplicativo que não está na RAM, criando uma nova sessão de aplicativo.
* **Inicialização a quente** é a alternação do aplicativo do modo de segundo plano, quando o aplicativo está pausado na RAM, para o modo de primeiro plano.
## Implementação {#implement}
1. Inicializar o SDK ao inicializar o aplicativo.
2. Criar e configurar o objeto carregador de anúncios `AppOpenAdLoader`.
3. Definir o delegado do método de callback `AppOpenAdLoaderDelegate` para enviar notificações quando os anúncios são carregados com êxito ou não.
4. Carregar o anúncio usando o método `loadAd(with: AdRequestConfiguration)`.
5. Usar o método `applicationDidBecomeActive(_ application: UIApplication)` da classe AppDelegate para renderizar anúncios na abertura do aplicativo.
6. Antes de renderizar o anúncio, definir o delegado do método de callback do anúncio `AppOpenAdDelegate`.
7. Renderizar o anúncio usando o método `show`.
### Principais etapas
1. Inicialize o SDK ao inicializar o aplicativo.
```swift
// wait for sdk initialization before loading ads
MobileAds.initializeSDK(completionHandler: completionHandler)
```
2. Crie e configure o objeto carregador de anúncios `AppOpenAdLoader`.
Você vai precisar da ID de unidade de anúncio da interface do Yandex Advertising Network (`AD_UNIT_ID`).
Você pode expandir os parâmetros de solicitação de anúncio através de `AdRequestConfiguration`, passando interesses do usuário, dados contextuais da página, detalhes de localização ou outras informações. Fornecer dados contextuais adicionais na solicitação pode melhorar consideravelmente a qualidade do anúncio. Saiba mais na seção [Segmentação de anúncios](../../../en/dev/ios/target.md).
```swift
private lazy var appOpenAdLoader: AppOpenAdLoader = {
let loader = AppOpenAdLoader()
loader.delegate = self
return loader
}()
```
3. Defina o delegado do método de callback `AppOpenAdLoaderDelegate` para enviar notificações quando os anúncios são carregados com êxito ou não.
```swift
extension AppOpenAdController: AppOpenAdLoaderDelegate {
func appOpenAdLoader(_ adLoader: AppOpenAdLoader, didLoad appOpenAd: AppOpenAd) {
// The ad was loaded successfully. You can now show the ad.
self.appOpenAd = appOpenAd
self.appOpenAd?.delegate = self
}
func appOpenAdLoader(_ adLoader: AppOpenAdLoader, didFailToLoadWithError error: AdRequestError) {
// Ad failed to load with AdRequestError.
// Attempting to load a new ad from the onAdFailedToLoad() method is strongly discouraged.
}
}
```
4. Carregue o anúncio usando o método `loadAd(with: AdRequestConfiguration)`.
```swift
func loadAd() {
// Replace demo-appopenad-yandex with actual Ad Unit ID
let configuration = AdRequestConfiguration(adUnitID: "demo-appopenad-yandex")
self.appOpenAdLoader.loadAd(with: configuration)
}
```
5. Use o método da classe AppDelegate para exibir anúncios ao abri-lo.
```swift
func applicationDidBecomeActive(_ application: UIApplication)
```
6. Antes de renderizar o anúncio, defina o delegado do método de callback do anúncio `AppOpenAdDelegate`.
```swift
extension AppOpenAdController: AppOpenAdDelegate {
func appOpenAd(_ appOpenAd: AppOpenAd, didFailToShowWithError error: Error) {
// Called when an ad failed to show.
// Load next ad after fail to show with error
loadAd()
}
func appOpenAdDidShow(_ appOpenAd: AppOpenAd) {
// Called when ad did shown.
}
func appOpenAdDidDismiss(_ appOpenAd: AppOpenAd) {
// Called when ad is dismissed.
// Load next ad after dismiss
loadAd()
}
func appOpenAdDidClick(_ appOpenAd: AppOpenAd) {
// Called when a click is recorded for an ad.
}
func appOpenAd(_ appOpenAd: AppOpenAd, didTrackImpressionWith impressionData: ImpressionData?) {
// Called when an impression is recorded for an ad.
}
}
```
7. Renderize o anúncio usando o método `show`.
```swift
self.appOpenAd?.show(from: self)
```
{% note info %}
Se o anúncio já tiver sido veiculado, a chamada do método `show(from:)` (mostrar desde) retornará um erro de exibição em `AppOpenAdDelegate.appOpenAd(_:didFailToShowError:)` (falha na exibição, erro no anúncio).
{% endnote %}
## Funcionalidades da integração de anúncios App Open {#features}
1. Todas as chamadas para métodos do Yandex Mobile Ads SDK devem ser feitas a partir do thread principal.
2. O carregamento pode demorar, então não aumente o tempo de inicialização a frio se o anúncio não tiver carregado.
3. Pré-carregue o anúncio para exibição subsequente durante inicializações a quente.
4. Desencorajamos o carregamento de anúncios App Open e outros formatos de anúncio em paralelo durante a inicialização do aplicativo, pois o aplicativo pode estar baixando dados operacionais nesse momento. Isso pode sobrecarregar o dispositivo e a conexão com a internet, fazendo com que o carregamento do anúncio demore mais.
5. Se houve um erro no callback `appOpenAdLoader(_ adLoader: AppOpenAdLoader, didFailToLoadWithError error: AdRequestError)`, não tente carregar um novo anúncio. Se precisar fazer isso, limite o número de tentativas de recarregamento de anúncios. Isso ajudará a evitar solicitações constantes malsucedidas e problemas de conexão quando surgirem limitações.
## Teste da integração de anúncios na inicialização {#test}
### Uso de blocos de anúncios de demonstração para teste de anúncios {#demo-blocks}
Recomendamos usar anúncios de teste para testar sua integração para anúncios App Open e seu próprio aplicativo.
Para garantir que anúncios de teste sejam retornados para cada solicitação de anúncio, criamos um ID especial de posicionamento de anúncios de demonstração. Use-o para verificar sua integração de anúncios.
adUnitId de demonstração: `demo-appopenad-yandex`.
{% note warning %}
Antes de publicar seu app na loja, lembre-se de substituir a ID de inserção demonstrativa por uma ID real obtida na interface do Yandex Advertising Network.
{% endnote %}
Confira a lista de IDs de posicionamento de anúncios de demonstração disponíveis na seção [Blocos de anúncio de demonstração para teste](../../../en/dev/ios/demo-blocks.md).
### Teste da integração de anúncios
Você pode testar sua integração de anúncios usando a ferramenta Console nativa.
Para ver logs detalhados, chame o método `enableLogging` da classe `YMAMobileAds`.
```swift
YMAMobileAds.enableLogging()
```
Para ver os logs do SDK, acesse a ferramenta Console e defina `Subsystem = com.mobile.ads.ads.sdk`. Você também pode filtrar logs por categoria e nível de erro.
Se você estiver tendo problemas para integrar anúncios, receberá um relatório detalhado sobre os problemas e recomendações de como corrigi-los.
## Recomendações
1. Não renderize seu anúncio de abertura do aplicativo antes da tela de carregamento inicial.
Ao exibir a tela de carregamento inicial, você melhora a experiência do usuário no aplicativo, deixando-a mais fluida e agradável. Isso evitará que o usuário fique surpreso ou confuso, e ele terá a certeza de que abriu o aplicativo correto. Na mesma tela, você pode avisar os usuários sobre o próximo anúncio. Use um indicador de carregamento ou simplesmente uma mensagem de texto informando ao usuário que ele retomará a visualização do conteúdo do aplicativo após o anúncio.
2. Se houver um atraso entre a solicitação e a renderização do anúncio, o usuário poderá abrir brevemente seu aplicativo e, em seguida, ver inesperadamente um anúncio não relacionado ao conteúdo. Isso pode impactar negativamente a experiência do usuário, então vale a pena evitar. Uma solução é usar a tela de carregamento inicial antes de exibir o conteúdo principal do aplicativo e iniciar a renderização do anúncio a partir dessa tela. Se o aplicativo abrir algum conteúdo após a tela de carregamento inicial, é melhor não renderizar o anúncio.
3. Espere até que novos usuários abram o aplicativo e o usem algumas vezes antes de renderizar um anúncio de abertura do aplicativo. Renderize o anúncio apenas para usuários que atenderam a certos critérios no aplicativo (por exemplo, passaram de um certo nível, abriram o aplicativo um certo número de vezes ou não estão participando de ofertas premiadas). Não renderize o anúncio imediatamente após a instalação do aplicativo.
4. Altere a frequência de renderização de anúncios com base no comportamento do usuário do aplicativo. Não renderize o anúncio a cada inicialização a frio/quente do aplicativo.
5. Renderize o anúncio apenas se o seu aplicativo estiver em segundo plano por um certo período de tempo (por exemplo, 30 segundos, dois minutos, 15 minutos).
6. Você deve realizar testes completos, já que cada aplicativo é único e requer uma estratégia especial para maximizar a receita sem reduzir a retenção ou o tempo gasto no aplicativo. O comportamento e o engajamento dos usuários podem mudar ao longo do tempo, então recomendamos testar periodicamente as estratégias que você usa para seus anúncios App Open.
## Recursos adicionais {#resources}
*
Link para [GitHub](https://github.com/yandexmobile/yandex-ads-sdk-ios/blob/master/Examples/YandexMobileAdsExample/YandexMobileAdsExample/Yandex/AppOpenAd/AppOpenAdViewController.swift).