Descubre las novedades de Firebase en Google I/O 2022. Más información

Video recompensado

Puedes usar AdMob para mostrar videos recompensados en tus aplicaciones de C++ a través de la Mediación de AdMob.

Esta guía te muestra cómo solicitar y mostrar un video recompensado, determinar cuándo hay videos recompensados disponibles y recompensar al usuario.

Requisitos previos

Antes de empezar a interactuar con la API de C++ para videos recompensados, debes incluir los adaptadores de la red de mediación y los SDK en la app desde la que quieres publicar videos recompensados. Puedes ver los pasos para agregar la mediación de videos recompensados a tu app en la guía para publicadores sobre videos recompensados de iOS y Android.

Si es la primera vez que configuras AdMob y Firebase en tu app de C++, consulta la guía de introducción de AdMob para C++, que incluye instrucciones paso a paso para integrar tu app con AdMob y Firebase.

Interactúa con el espacio de nombres rewarded_video

El espacio de nombres rewarded_video contiene métodos para mostrar videos recompensados a través del SDK de anuncios de Google para dispositivos móviles. A diferencia de los anuncios de banner y los intersticiales, que tienen sus propios objetos, los videos recompensados se controlan mediante métodos estáticos en el espacio de nombres rewarded_video.

Para acceder al espacio de nombres rewarded_video, agrega lo siguiente al código C++ de tu app:

#include "firebase/admob/rewarded_video.h"

Estos son los pasos básicos para interactuar con el espacio de nombres rewarded_video:

Llama a Initialize() para inicializar la biblioteca y los adaptadores de mediación:
```
firebase::admob::rewarded_video::Initialize();
```
Nota: Se debe llamar a Initialize() antes que a cualquier otro método.
Ahora que se inicializaron los adaptadores de mediación y la biblioteca, podrás llamar a LoadAd() para cargar un video recompensado:
```
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);
```
Consulta cómo crear una solicitud de anuncio de AdMob para ver un ejemplo de cómo orientar y personalizar las solicitudes de anuncios.

Una vez que se cargue el video recompensado, llama a Show() para mostrarle el video al usuario:

// 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);

Repite los pasos 2 y 3 según sea necesario.
Llama a Pause() para interrumpir cualquier proceso en segundo plano asociado con el video recompensado:
```
firebase::admob::rewarded_video::Pause();
```
Llama a este método cada vez que el motor de C++ se detenga o la aplicación pierda el enfoque.
Llama a Resume() para reanudar desde una pausa, por ejemplo, cuando el usuario regrese a tu app desde Google Play:
```
firebase::admob::rewarded_video::Resume();
```
Cuando termines de mostrar anuncios de video recompensado en tu app, llama a Destroy() para limpiar los recursos que haya utilizado el espacio de nombres del video recompensado y cancelar su asignación:
```
firebase::admob::rewarded_video::Destroy();
```
Nota: No se debe llamar a ningún otro método en el espacio de nombres rewarded_video una vez que se invoca este método.

En los pasos anteriores, se muestran las llamadas de método básicas que tu app puede utilizar para cargar y mostrar un video recompensado. Sin embargo, se recomienda verificar si las llamadas de método anteriores se completaron antes de llamarlas nuevamente. En la siguiente sección, se describen los pasos para utilizar las interfaces Future a fin de determinar el estado de las llamadas al método anteriores en el espacio de nombres rewarded_video.

Usa interfaces Future para controlar el estado de las llamadas al método

Las interfaces Future te permiten conocer el estado de las llamadas al método anteriores en el espacio de nombres rewarded_video. Cuando se realiza una llamada al método rewarded_video::Initialize(), por ejemplo, se crea y se muestra una nueva interfaz Future. Consulta firebase::Future para obtener más detalles. Las apps pueden consultar el estado de la interfaz Future para determinar cuándo se completó la inicialización. Una vez que la interfaz Future esté completa, podrás cargar el video recompensado.

La mayoría de los métodos del espacio de nombres rewarded_video tienen un método "LastResult" correspondiente que las apps pueden usar para recuperar la interfaz Future más reciente de una acción específica. El método Initialize(), por ejemplo, tiene un método llamado InitializeLastResult() que muestra la interfaz Future de la llamada más reciente a 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);
}

Utiliza el método LoadAdLastResult() para obtener una interfaz Future que representará el estado de la última llamada al método LoadAd(). Si su estado está completo, podrás mostrar el video recompensado en el siguiente punto de detención natural de tu app:

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);
}

Usa un objeto de escucha para recibir notificaciones sobre los eventos del ciclo de vida de los anuncios

El espacio de nombres rewarded_video de AdMob proporciona una clase abstracta Listener que puedes extender y pasar al método SetListener() para recibir notificaciones de recompensas y cambios en el estado de la presentación de videos recompensados.

En el siguiente ejemplo, se muestra la implementación de una clase que extiende la clase abstracta 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);

Recompensas por sondeo

El espacio de nombre rewarded_video también proporciona una clase PollableRewardListener, de la que puedes crear una instancia y pasar al método SetListener(). Esta clase proporciona una opción alternativa para acceder a recompensas sin tener que extender la clase abstracta Listener.

El objeto de escucha basado en sondeo utiliza una cola para mantener los premios otorgados por el SDK de anuncios para dispositivos móviles, que se puede recuperar más tarde. El método PollReward(RewardItem* reward) del PollableRewardListener muestra la recompensa en cola más antigua y copia sus datos en el struct RewardItem proporcionado.

El ejemplo siguiente muestra la implementación de recompensas por sondeo mediante la clase 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);
}

Ejemplo de bucle de juego simple

En este ejemplo se muestra un bucle de juego simple que utiliza una máquina de estados para no perder de vista las llamadas de método al espacio de nombres 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
}

¿Qué sigue?

Consulta las guías de introducción de video recompensado para iOS y de video recompensado para Android a fin de obtener más información sobre los anuncios de video recompensado.