--- metadata: - name: generator content: Diplodoc Platform v5.52.0 alternate: - https://ads.yandex.com/helpcenter/en/dev/ios/native.md - https://ads.yandex.com/helpcenter/pt/dev/ios/native.md - https://ads.yandex.com/helpcenter/ru/dev/ios/native.md - https://ads.yandex.com/helpcenter/zh/dev/ios/native.md - href: pt/dev/ios/native.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 nativos Publicidade nativa é um tipo de anúncio em que o layout pode ser definido no lado do aplicativo. Esta funcionalidade permite alterar o estilo visual dos anúncios e seu posicionamento, considerando as especificidades do design do aplicativo. Anúncios nativos melhoram a experiência com anúncios. Como resultado, você pode exibir mais anúncios sem que o usuário perca o interesse. Isso garante a máxima receita de publicidade a longo prazo. A renderização de anúncios é realizada com ferramentas nativas da plataforma, o que melhora o desempenho e a qualidade dos anúncios. {% cut "Aparência" %} {% endcut %} Este guia mostrará como integrar anúncios nativos em aplicativos iOS. Além de exemplos de código e instruções, contém recomendações específicas aos formatos e links para recursos adicionais. ## 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). ## Implementação {#implement} Principais passos para integrar anúncios nativos: - Criar e configurar o `NativeAdLoader`. - Carregar o anúncio. - Passar [configurações adicionais](../../../en/dev/ios/target-adfox.md) se você estiver usando Adfox. - Exibir o anúncio carregado. ## Características da integração de anúncios nativos {#features} 1. Todas as chamadas para métodos do Yandex Mobile Ads SDK devem ser feitas a partir do thread principal. 2. Aconselhamos que você não tente carregar um novo anúncio quando ocorrer erro de carregamento. Com completion handler, isso é o caso `.failure`; com Swift Concurrency, trate em `catch`. Se precisar repetir a partir do tratamento de erro, limite as tentativas para evitar solicitações de anúncio malsucedidas em sequência por restrições de rede. 3. Recomendamos manter uma referência forte ao anúncio e ao carregador durante todo o ciclo de vida da tela que interage com o anúncio. 4. Recomendamos calcular o tamanho do contêiner do anúncio com base no conteúdo do anúncio. Quando o anúncio é carregado, você precisa renderizar todos os ativos. A lista de componentes disponíveis vem do objeto `NativeAd`. 5. Anúncios com vídeo geralmente têm CTR mais alto e maior receita. Para exibir anúncios em vídeo, o contêiner e o `MediaView` devem ter pelo menos 300×160 dp (pixels independentes de densidade). 6. Recomendamos um layout com o conjunto completo de ativos possíveis. Na prática, isso costuma melhorar a conversão. ## Carregamento de anúncios {#load} Para carregar anúncios nativos, crie um objeto `NativeAdLoader`. Os parâmetros da solicitação são definidos pela classe `AdRequest`. Passe o ID do bloco de anúncios; também é possível configurar segmentação e outros dados que melhorem a qualidade. Opções de carregamento de imagens passam por `NativeAdOptions`. Saiba mais na seção [Segmentação de anúncios](../../../en/dev/ios/target.md). Use `loadAd(with:options:completion:)` com completion handler, ou a sobrecarga com Swift Concurrency `loadAd(with:options:)`. O exemplo a seguir mostra como carregar anúncios nativos a partir de um view controller. {% list tabs %} - Swift Concurrency ```swift final class CustomNativeViewController: UIViewController { private var adLoader: NativeAdLoader? override func viewDidLoad() { adLoader = NativeAdLoader() } private func loadNativeAd() async { let request = AdRequest(adUnitID: "R-M-XXXXX-YY") let options = NativeAdOptions() do { let ad = try await adLoader?.loadAd(with: request, options: options) // Anúncio nativo carregado } catch { // Falha ao carregar } } } ``` - Completion handler ```swift final class CustomNativeViewController: UIViewController { private var adLoader: NativeAdLoader? override func viewDidLoad() { adLoader = NativeAdLoader() } private func loadNativeAd() { let request = AdRequest(adUnitID: "R-M-XXXXX-YY") let options = NativeAdOptions() adLoader?.loadAd(with: request, options: options) { [weak self] result in switch result { case .success(let ad): // Anúncio nativo carregado break case .failure: // Falha ao carregar break } } } } ``` {% endlist %} ## Renderização de anúncios {#ad-view} {% note warning %} A partir da versão 8.0.0, os modelos nativos (`NativeBannerView`, `MutableNativeTemplateAppearance` e tipos relacionados) foram totalmente removidos do SDK. Use layout manual para anúncios nativos, conforme descrito abaixo. {% endnote %} Quando o anúncio é carregado, você precisa renderizar todos os ativos. A lista de componentes disponíveis vem do objeto `NativeAd`. ## Configuração manual do layout de anúncio nativo {#config} Esse método permite montar o layout e posicionar os componentes do anúncio uns em relação aos outros. O anúncio pode ter componentes obrigatórios e opcionais. A lista completa está em [Ativos de anúncio nativo](../../../en/dev/ios/components.md). {% note tip %} Recomendamos um layout com o conjunto completo de ativos possíveis. Na prática, isso costuma melhorar a conversão. {% endnote %} Para configurar manualmente anúncios nativos: 1. Crie um `view` personalizado para a classe `NativeAdView`. 1. Configure o posicionamento dos elementos personalizados para exibir os componentes. 1. Vincule esses elementos às propriedades correspondentes de `NativeAdView`: ```swift final class CustomNativeAdView: NativeAdView { // ... init() { super.init(frame: CGRect()) setupUI() bindAssets() } private func bindAssets() { titleLabel = customTitleLabel domainLabel = customDomainLabel warningLabel = customWarningLabel sponsoredLabel = customSponsoredLabel feedbackButton = customFeedbackButton callToActionButton = customCallToActionButton mediaView = customMediaView priceLabel = customPriceLabel reviewCountLabel = customReviewCountLabel ratingView = customRatingView bodyLabel = customBodyLabel iconImageView = customIconImageView } private func setupUI() { // ... } } ``` {% note info %} Se você não vincular um elemento personalizado à propriedade de `NativeAdView` para um componente obrigatório, o anúncio não será exibido. {% endnote %} 1. Vincule o `view` personalizado ao objeto `NativeAd` após o carregamento. Chame `bind(with adView: NativeAdView)` no `NativeAd`: ```swift final class NativeCustomViewController: UIViewController, NativeAdDelegate { private let adView = NativeCustomAdView() // ... private lazy var adLoader: NativeAdLoader = { let adLoader = NativeAdLoader() return adLoader }() override func viewDidLoad() { super.viewDidLoad() setupUI() loadNativeAd() } private func loadNativeAd() { let request = AdRequest(adUnitID: "demo-native-app-yandex") let options = NativeAdOptions() adLoader.loadAd(with: request, options: options) { [weak self] result in if case .success(let ad) = result { self?.bindNativeAd(ad) } } } private func bindNativeAd(_ ad: NativeAd) { ad.delegate = self do { try ad.bind(with: adView) } catch { // ... } } private func setupUI() { // ... } } ``` ## Carregamento de vários anúncios {#load-more-ads} O Yandex Mobile Ads SDK permite carregar vários anúncios em uma única solicitação (até nove). {% note info %} Use o bloco de demonstração `demo-native-bulk-yandex` como `AdUnitID`. Plataformas suportadas estão em [Blocos de anúncios de demonstração](../../../en/dev/ios/demo-blocks.md). {% endnote %} 1. Crie uma instância de `NativeBulkAdLoader` para obter anúncios nativos. 2. Crie um `AdRequest` com o ID do bloco e `NativeAdOptions` para parâmetros adicionais (imagens etc.). 3. Chame `loadAds(with:adsCount:options:completion:)` para carregar os anúncios. {% list tabs %} - Swift Concurrency ```swift let request = AdRequest(adUnitID: AdUnitID) let options = NativeAdOptions() let adLoader = NativeBulkAdLoader() do { let ads = try await adLoader.loadAds(with: request, adsCount: adsCount, options: options) // Trate cada NativeAd separadamente } catch { // Erro de carregamento } ``` - Completion handler ```swift let request = AdRequest(adUnitID: AdUnitID) let options = NativeAdOptions() let adLoader = NativeBulkAdLoader() adLoader.loadAds(with: request, adsCount: adsCount, options: options) { result in switch result { case .success(let ads): // Trate cada NativeAd separadamente break case .failure: break } } ``` {% endlist %} {% note info %} Uma solicitação em massa permite obter vários anúncios distintos. O array retornado pode ter entre zero e `adsCount` objetos `NativeAd`. Todos podem ser renderizados de forma independente com os métodos de layout acima. {% endnote %} ## Teste da integração de anúncios nativos {#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 a integração e o aplicativo. Para garantir anúncios de teste a cada solicitação, criamos um ID de posicionamento de demonstração. Use-o para verificar a integração. `adUnitId` de demonstração para anúncio de texto e imagem: `demo-native-content-yandex`. `adUnitId` de demonstração para anúncio de app móvel: `demo-native-app-yandex`. {% note warning %} Antes de publicar o app na loja, substitua o ID de demonstração por um ID real na interface do Yandex Advertising Network. {% endnote %} ### Teste da integração de anúncios {#test-int} 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. ## Indicador de integração de anúncios nativos {#native-ad-integration-indicator} {% note info %} Por padrão, o indicador só aparece no simulador (tipo de dispositivo `DeviceTypeSimulator`). Os tipos estão em `DeviceType`. {% endnote %} Se houver erro na integração, um indicador aparece sobre o anúncio no simulador. Toque nele para ver a mensagem de depuração; toque de novo para ocultar. Para ativar também em dispositivos reais, passe `DeviceTypeHardware | DeviceTypeSimulator` em `enableVisibilityErrorIndicatorForDeviceType:`. ```swift YandexAds.enableVisibilityErrorIndicator(for: [.hardware, .simulator]) ``` Para desativar, passe `DeviceTypeNone` em `enableVisibilityErrorIndicatorForDeviceType:`. ```swift YandexAds.enableVisibilityErrorIndicator(for: []) ``` #| || | || |# ## Recursos adicionais {#resources} * Link para [GitHub](https://github.com/yandexmobile/yandex-ads-sdk-ios).