Cette page a été traduite par l'API Cloud Translation.
Switch to English

Vidéo récompensée

Vous pouvez utiliser AdMob pour afficher des vidéos avec récompense dans vos applications C ++ via la médiation AdMob .

Ce guide vous montre comment demander et afficher une vidéo avec récompense, déterminer quand les vidéos avec récompense sont disponibles et récompenser l'utilisateur.

Conditions préalables

Avant de commencer à interagir avec l'API C ++ vidéo récompensée, vous devez inclure les adaptateurs réseau de médiation et les SDK dans votre application à partir desquels vous souhaitez diffuser des vidéos récompensées. Vous pouvez voir les étapes pour ajouter une médiation vidéo avec récompense à votre application dans le guide vidéo avec récompense des éditeurs pour iOS et Android .

De plus, si c'est la première fois que vous configurez AdMob et Firebase dans votre application C ++, consultez le guide de démarrage d' AdMob C ++ pour obtenir des instructions détaillées sur l'intégration de votre application à AdMob et Firebase.

Interagir avec l'espace de noms awarded_video

L' rewarded_video espace de noms contient des méthodes pour afficher des vidéos via Google récompensés mobile SDK publicitaire. Contrairement à bannières et interstitiels, qui ont leurs propres objets, des vidéos sont contrôlés à l' aide récompensés méthodes statiques dans le rewarded_video espace de noms.

Pour accéder à l'espace de noms rewarded_video , ajoutez l'inclusion suivante au code C ++ de votre application:

 #include "firebase/admob/rewarded_video.h"
 

Voici les étapes de base pour interagir avec l' rewarded_video espace de noms:

  1. Appelez Initialize() pour initialiser la bibliothèque et les adaptateurs de médiation:

     firebase::admob::rewarded_video::Initialize();
     
  2. Maintenant que la bibliothèque et les adaptateurs de médiation ont été initialisés, vous êtes prêt à appeler LoadAd() pour charger une vidéo récompensée:

     firebase::admob::AdRequest my_ad_request;
    // Set some or all of the member variables in the AdRequest struct.
    firebase::admob::rewarded_video::LoadAd("YOUR_REWARDED_AD_UNIT_ID", my_ad_request);
     

    Consultez l'article Créer une demande d'annonce AdMob pour un exemple de ciblage et de personnalisation des demandes d'annonces.

  3. Une fois la vidéo récompensée chargée, appelez Show() pour afficher la vidéo à l'utilisateur:

     // my_ad_parent is a reference to an iOS UIView or an Android Activity. This is
    // the parent UIView or Activity of the rewarded video.
    firebase::admob::rewarded_video::Show(my_ad_parent);
     
  4. Répétez les étapes 2 et 3 au besoin.

  5. Appelez Pause() pour suspendre tout traitement en arrière-plan associé à la vidéo récompensée:

     firebase::admob::rewarded_video::Pause();
     

    Appelez cette méthode chaque fois que le moteur C ++ s'interrompt ou que l'application perd le focus.

  6. Appelez Resume() pour reprendre une pause, par exemple, lorsque l'utilisateur revient à votre application depuis Google Play:

     firebase::admob::rewarded_video::Resume();
     
  7. Lorsque vous avez terminé d'afficher des annonces vidéo avec récompense dans votre application, appelez Destroy() pour nettoyer et désallouer toutes les ressources utilisées par l'espace de noms vidéo récompensé:

     firebase::admob::rewarded_video::Destroy();
     

Les étapes ci-dessus mettent en évidence la méthode de base que votre application doit utiliser lors du chargement et de l'affichage d'une vidéo récompensée. Cependant, il est recommandé de surveiller l'état d'achèvement des appels de méthode précédents avant de les appeler. La section suivante décrit les étapes pour l' utilisation de contrats à terme afin de déterminer l'état d'achèvement des précédent rewarded_video appels de méthode d'espace de noms.

Utilisez Futures pour surveiller l'état d'achèvement des appels de méthode

À terme vous fournir un moyen de déterminer l'état d'avancement de vos précédents rewarded_video appels de méthode d'espace de noms. Lorsqu'un appel est fait à la méthode rewarded_video::Initialize() , par exemple, un nouveau Future est créé et renvoyé. Voir firebase :: Future pour plus de détails. Les applications peuvent interroger le statut du futur pour déterminer quand l'initialisation est terminée. Une fois le futur terminé, vous êtes prêt à charger la vidéo récompensée.

La plupart des méthodes de l'espace de noms rewarded_video ont une méthode "dernier résultat" correspondante que les applications peuvent utiliser pour récupérer le futur le plus récent pour une action donnée. La méthode Initialize() , par exemple, a une méthode appelée InitializeLastResult() qui renvoie le Future pour l'appel le plus récent à Initialize() :

 if (firebase::admob::rewarded_video::InitializeLastResult().status() ==
    firebase::kFutureStatusComplete &&
    firebase::admob::rewarded_video::InitializeLastResult().error() ==
    firebase::admob::kAdMobErrorNone) {
  firebase::admob::rewarded_video::LoadAd("YOUR_REWARDED_AD_UNIT_ID",
      my_ad_request);
}
 

Utilisez la méthode LoadAdLastResult() pour obtenir un Future représentant l'état du dernier appel à la méthode LoadAd() . Si son statut est terminé, vous pouvez afficher la vidéo récompensée au prochain point d'arrêt naturel dans votre application:

 if (firebase::admob::rewarded_video::LoadAdLastResult().status() ==
    firebase::kFutureStatusComplete &&
    firebase::admob::rewarded_video::LoadAdLastResult().error() ==
    firebase::admob::kAdMobErrorNone) {
  // my_ad_parent is a reference to an iOS UIView or an Android Activity.
  // This is the parent UIView or Activity of the rewarded video.
  firebase::admob::rewarded_video::Show(my_ad_parent);
}
 

Utilisez un auditeur pour être informé des événements du cycle de vie des annonces

Le AdMob rewarded_video espace de noms fournit un résumé Listener classe que vous pouvez étendre et passer à la SetListener() méthode pour être informé des récompenses et récompensé les changements d'état de présentation vidéo.

Voici un exemple d'implémentation d'une classe qui étend la classe abstraite Listener :

 // A simple listener that logs changes to rewarded video state.
class LoggingRewardedVideoListener
    : public firebase::admob::rewarded_video::Listener {
 public:
  LoggingRewardedVideoListener() {}
  void OnRewarded(firebase::admob::rewarded_video::RewardItem reward) override {
    LogMessage("Rewarding user with %f %s.", reward.amount,
               reward.reward_type.c_str());
  }
  void OnPresentationStateChanged(
      firebase::admob::rewarded_video::PresentationState state) override {
    LogMessage("Rewarded video PresentationState has changed to %d.", state);
  }
};

// After calling Initialize and waiting for the Initialize future to complete
// successfully, set the listener.
LoggingRewardedVideoListener rewarded_video_listener;
firebase::admob::rewarded_video::SetListener(&rewarded_video_listener);
 

Récompenses du sondage

Le rewarded_video espace de noms fournit également PollableRewardListener , une classe que vous pouvez instancier et passer à la SetListener() méthode. Cette classe fournit une option alternative pour accéder aux récompenses sans avoir à étendre la classe abstraite Listener .

L'écouteur basé sur l'interrogation utilise une file d'attente pour gérer les récompenses accordées par le SDK Mobile Ads qui peuvent être récupérées ultérieurement. La PollReward(RewardItem* reward) du PollableRewardListener la plus ancienne récompense en file d'attente et copie ses données dans la structure RewardItem fournie.

Voici un exemple d'implémentation pour interroger les récompenses à l'aide de la classe rewarded_video::PollableRewardListener :

 // After calling Initialize and waiting for the Initialize future to complete
// successfully, instantiate a PollableRewardListener object and set the listener.
firebase::admob::rewarded_video::PollableRewardListener* listener =
    new firebase::admob::rewarded_video::PollableRewardListener();

// Pass the PollableRewardListener object to the SetListener method.
firebase::admob::rewarded_video::SetListener(listener);

...
// Display the rewarded videos to users so they can earn rewards.
...

// Declare a RewardItem struct. Pass this RewardItem struct by reference to
// the PollReward method.
firebase::admob::rewarded_video::RewardItem reward;
// Call the PollReward method to see if a reward is available.
while (listener->PollReward(&reward)) {
  // A reward is available. Do something with the reward.
  printf("Reward user with %f %s.", reward.amount, reward.reward_type);
}
 

Exemple de boucle de jeu simple

Voici une boucle de jeu simple qui utilise une machine à états pour suivre les appels de méthode à l'espace de noms rewarded_video :

 namespace rewarded_video = firebase::admob::rewarded_video;

enum State {
  kNextStepInitialize,
  kNextStepLoadAd,
  kNextStepShowAd,
  kNextStepRewardUser,
  kNextStepRestartGame
}

// Instantiate a PollableRewardListener object.
firebase::admob::rewarded_video::PollableRewardListener* listener =
    new firebase::admob::rewarded_video::PollableRewardListener();

State state = kNextStepInitialize;
for ( ; ; ) /* game loop */ {
  switch (state) {
    case kNextStepInitialize:
      rewarded_video::Initialize();
      state = kNextStepLoadAd;
      break;
    case kNextStepLoadAd:
      if (rewarded_video::InitializeLastResult().status() ==
          firebase::kFutureStatusComplete &&
          rewarded_video::InitializeLastResult().error() ==
          firebase::admob::kAdMobErrorNone) {
        // Pass the PollableRewardListener object to the SetListener method.
        firebase::admob::rewarded_video::SetListener(listener);
        rewarded_video::LoadAd("YOUR_REWARDED_AD_UNIT_ID",
                               my_ad_request);
      }
      state = kNextStepShowAd;
      break;
    case kNextStepShowAd:
      if (rewarded_video::LoadAdLastResult().status() ==
          firebase::kFutureStatusComplete &&
          rewarded_video::LoadAdLastResult().error() ==
          firebase::admob::kAdMobErrorNone) {
        rewarded_video::Show(my_ad_parent);
      }

      if (rewarded_video::ShowLastResult().status() ==
          firebase::kFutureStatusComplete &&
          rewarded_video::ShowLastResult().error() ==
          firebase::admob::kAdMobErrorNone &&
          rewarded_video::presentation_state() ==
          rewarded_video::kPresentationStateHidden) {
        // If the rewarded video has been displayed to the user and
        // the user closed the ad, then reward the user.
        state = kNextStepRewardUser;
      }
      break;
    case kNextStepRewardUser:
      firebase::admob::rewarded_video::RewardItem reward;
      // Call the PollReward method to see if a reward is available.
      while (listener->PollReward(&reward)) {
        // A reward is available. Do something with the reward.
        printf("Reward user with %f %s.", reward.amount, reward.reward_type);
      }
      state = kNextStepRestartGame;
      break;
    case kNextStepRestartGame:
      // restart game
      break;
  }

  // render game
}
 

Et après

Pour plus d'informations sur les publicités vidéo avec récompense, consultez les guides de mise en route des vidéos avec récompense iOS et des vidéos avec récompense Android .