Gli annunci con premio consentono agli utenti di interagire con loro in cambio di premi in-app. Questa guida illustra come integrare gli annunci con premio nelle app per Android e iOS utilizzando l'SDK Google Mobile Ads C++.
Leggi alcuni casi di successo dei clienti: case study 1, case study 2.
Prerequisiti
- Completa Inizia.
- (Solo Android) Familiarità nell'utilizzo dei riferimenti
jobject
di JNI (vedi i suggerimenti per JNI per Android).
Esegui sempre test con annunci di prova
Quando crei e testi le tue app, assicurati di utilizzare annunci di prova anziché annunci pubblicati in produzione. In caso contrario, l'account verrà sospeso.
Il modo più semplice per caricare gli annunci di prova è utilizzare il nostro ID unità pubblicitaria di prova dedicato per gli annunci con premio, che varia in base alla piattaforma del dispositivo:
- Android:
ca-app-pub-3940256099942544/5224354917
- iOS:
ca-app-pub-3940256099942544/1712485313
Sono stati appositamente configurati per restituire annunci di prova per ogni richiesta e puoi utilizzarli nelle tue app durante la programmazione, i test e il debug. Assicurati solo di sostituirlo con il tuo ID unità pubblicitaria prima di pubblicare la tua app.
Per ulteriori informazioni sul funzionamento degli annunci di prova dell'SDK Mobile Ads, consulta Annunci di prova.
Implementazione
I passaggi principali per integrare gli annunci con premio sono:
- Carica un annuncio.
- Registrati per i callback.
- Mostra l'annuncio e gestisci l'evento con premio.
Configurare un RewardedAd
Gli annunci con premio vengono visualizzati negli oggetti RewardedAd
, pertanto il primo passaggio per
integrarli nella tua app è creare e inizializzare un'istanza
di RewardedAd
.
Aggiungi la seguente intestazione al codice C++ dell'app:
#include "firebase/gma/rewarded_ad.h"
Dichiara e crea un'istanza di un oggetto
RewardedAd
:firebase::gma::RewardedAd* rewarded_ad; rewarded_ad = new firebase::gma::RewardedAd();
Inizializza l'istanza
RewardedAd
utilizzando la visualizzazione principale trasmessa a un tipoAdParent
. La visualizzazione principale è un riferimentojobject
JNI a unActivity
Android o un puntatore a unUIView
iOS.// my_ad_parent is a jobject reference to an Android Activity or // a pointer to an iOS UIView. firebase::gma::AdParent ad_parent = static_cast<firebase::gma::AdParent>(my_ad_parent); firebase::Future<void> result = rewarded_ad->Initialize(ad_parent);
In alternativa alla conservazione del futuro come variabile, puoi controllare periodicamente lo stato dell'operazione di inizializzazione richiamando
InitializeLastResult()
sull'oggettoRewardedAd
. Questa operazione può essere utile per tenere traccia del processo di inizializzazione nel ciclo di gioco globale.// Monitor the status of the future in your game loop: firebase::Future<void> result = rewarded_ad->InitializeLastResult(); if (result.status() == firebase::kFutureStatusComplete) { // Initialization completed. if(future.error() == firebase::gma::kAdErrorCodeNone) { // Initialization successful. } else { // An error has occurred. } } else { // Initialization on-going. }
Per ulteriori informazioni sull'utilizzo di firebase::Future
, consulta
Utilizzare i futures per monitorare lo stato di completamento delle chiamate ai metodi.
Carica un annuncio
Il caricamento di un annuncio viene eseguito utilizzando il metodo LoadAd()
su un
oggetto RewardedAd
. Il metodo load richiede che tu abbia inizializzato l'oggetto RewardedAd
e che tu disponga dell'ID unità pubblicitaria e di un oggetto AdRequest
. Viene restituito un
firebase::Future
che puoi utilizzare per monitorare lo stato e il risultato
dell'operazione di caricamento.
Il seguente codice mostra come caricare un annuncio dopo che RewardedAd
è stato inizializzato correttamente:
firebase::gma::AdRequest ad_request;
firebase::Future<firebase::gma::AdResult> load_ad_result;
load_ad_result = rewarded_ad->LoadAd(rewarded_ad_unit_id, ad_request);
Registrati per i callback
Devi estendere la classe FullScreenContentListener
per ricevere le notifiche relative alla presentazione degli annunci con premio e agli eventi del ciclo di vita. La sottoclasse personalizzataFullScreenContentListener
può essere registrata tramite il metodoRewardedAd::SetFullScreenContentListener()
e riceverà callback quando l'annuncio viene visualizzato correttamente o non correttamente, nonché quando viene ignorato.
Il seguente codice mostra come estendere la classe e assegnarla all'annuncio:
class ExampleFullScreenContentListener : public firebase::gma::FullScreenContentListener { public: ExampleFullScreenContentListener() {} void OnAdClicked() override { // This method is invoked when the user clicks the ad. } void OnAdDismissedFullScreenContent() override { // This method is invoked when the ad dismisses full screen content. } void OnAdFailedToShowFullScreenContent(const AdError& error) override { // This method is invoked when the ad failed to show full screen content. // Details about the error are contained within the AdError parameter. } void OnAdImpression() override { // This method is invoked when an impression is recorded for an ad. } void OnAdShowedFullScreenContent() override { // This method is invoked when the ad showed its full screen content. } }; ExampleFullScreenContentListener* example_full_screen_content_listener = new ExampleFullScreenContentListener(); rewarded_ad->SetFullScreenContentListener(example_full_screen_content_listener);
RewardedAd
è un oggetto monouso. Ciò significa che, una volta visualizzato, un annuncio con premio non può essere mostrato di nuovo. Una best practice consiste nel caricare un altro annuncio con premio
nel metodo OnAdDismissedFullScreenContent()
di
FullScreenContentListener
in modo che l'annuncio con premio successivo inizi a caricarsi non appena quello precedente viene ignorato.
Mostrare l'annuncio e gestire l'evento con premio
Prima di mostrare agli utenti un annuncio con premio, devi presentare una scelta esplicita per visualizzare i contenuti dell'annuncio con premio in cambio di un premio. Gli annunci con premio devono sempre essere attivati.
Quando presenti l'annuncio, devi fornire un oggetto UserEarnedReward
per gestire il premio per l'utente.
Il seguente codice mostra come visualizzare un RewardedAd
:
// A simple listener track UserEarnedReward events.
class ExampleUserEarnedRewardListener :
public firebase::gma::UserEarnedRewardListener {
public:
ExampleUserEarnedRewardListener() { }
void OnUserEarnedReward(const firebase::gma::AdReward& reward) override {
// Reward the user!
}
};
ExampleUserEarnedRewardListener* user_earned_reward_listener =
new ExampleUserEarnedRewardListener();
firebase::Future<void> result = rewarded_ad->Show(user_earned_reward_listener);
Domande frequenti
- C'è un timeout per la chiamata di inizializzazione?
- Dopo 10 secondi, l'SDK Google Mobile Ads per C++ completa il
firebase::Future
restituito daInitialize()
anche se una rete di mediazione non ha ancora completato l'inizializzazione. - Cosa succede se alcune reti di mediazione non sono pronte quando ricevo il callback di inizializzazione?
Una best practice consiste nel caricare gli annunci al termine dell'inizializzazione dell'SDK. Anche se una rete di mediazione non è pronta, l'SDK Google Mobile Ads C++ chiederà comunque un annuncio a quella rete. Pertanto, se una rete di mediazione completa l'inizializzazione dopo il timeout, può comunque gestire le richieste di annunci future in quella sessione.
Puoi continuare a monitorare lo stato di inizializzazione di tutti gli adattatori durante la sessione dell'app chiamando
GetInitializationStatus()
.- Come faccio a sapere perché una determinata rete di mediazione non è pronta?
AdapterStatus.description()
descrive il motivo per cui un adattatore non è pronto a gestire le richieste di annunci. Consulta il codice sorgente della nostra app di esempio della guida rapida su GitHub per un esempio di registrazione dello stato dell'adattatore di mediazione.
Risorse aggiuntive
Esempio in GitHub
- Visualizza il codice sorgente della nostra app di avvio rapido di esempio in GitHub.