Revenus publicitaires au niveau des impressions

Sélectionnez une plate-forme : Android Dernière sélection Android iOS Unity

Lorsqu'une impression se produit, GMA Next-Gen SDK fournit les données sur les revenus publicitaires associés à cette impression. Vous pouvez utiliser ces données pour calculer la valeur vie d'un utilisateur ou les transmettre à d'autres systèmes pertinents.

Ce guide vous explique comment implémenter la capture des données sur les revenus publicitaires au niveau des impressions dans votre application Android.

Prérequis

Chaque format d'annonce dispose d'un onAdPaid rappel d'événement. Pendant le cycle de vie d'un événement d'annonce, GMA Next-Gen SDK surveille les événements d'impression et appelle le gestionnaire avec une valeur générée.

L'exemple suivant gère les événements payants pour une annonce avec récompense :

Kotlin

ad.adEventCallback =
  object : RewardedAdEventCallback {
    override fun onAdPaid(adValue: AdValue) {
      // Send the impression-level ad revenue information to your
      // preferred analytics server directly within this callback.

      // Extract the impression-level ad revenue data.
      val valueMicros = adValue.valueMicros
      val currencyCode = adValue.currencyCode
      val precisionType = adValue.precisionType

      val loadedAdSourceResponseInfo = ad.getResponseInfo().loadedAdSourceResponseInfo
      val adSourceName = loadedAdSourceResponseInfo?.name
      val adSourceId = loadedAdSourceResponseInfo?.id
      val adSourceInstanceName = loadedAdSourceResponseInfo?.instanceName
      val adSourceInstanceId = loadedAdSourceResponseInfo?.instanceId
      val extras = ad.getResponseInfo().responseExtras
      val mediationGroupName = extras.getString("mediation_group_name")
      val mediationABTestName = extras.getString("mediation_ab_test_name")
      val mediationABTestVariant = extras.getString("mediation_ab_test_variant")
    }
  }

Java

ad.setAdEventCallback(
    new RewardedAdEventCallback() {
      @Override
      public void onAdPaid(@NonNull AdValue value) {
        // Send the impression-level ad revenue information to your preferred
        // analytics server directly within this callback.

        // Extract the impression-level ad revenue data.
        long valueMicros = value.getValueMicros();
        String currencyCode = value.getCurrencyCode();
        PrecisionType precisionType = value.getPrecisionType();

        AdSourceResponseInfo loadedAdSourceResponseInfo =
            ad.getResponseInfo().getLoadedAdSourceResponseInfo();
        String adSourceName = loadedAdSourceResponseInfo.getName();
        String adSourceId = loadedAdSourceResponseInfo.getId();
        String adSourceInstanceName = loadedAdSourceResponseInfo.getInstanceName();
        String adSourceInstanceId = loadedAdSourceResponseInfo.getInstanceId();

        Bundle extras = ad.getResponseInfo().getResponseExtras();
        String mediationGroupName = extras.getString("mediation_group_name");
        String mediationABTestName = extras.getString("mediation_ab_test_name");
        String mediationABTestVariant = extras.getString("mediation_ab_test_variant");
      }
    });

Identifier un nom de source d'annonces d'événement personnalisé

Pour les sources d'annonces d'événements personnalisés, la propriété AdSourceResponseInfo.name renvoie le nom de la source d'annonces Custom event. Si vous utilisez plusieurs événements personnalisés, le nom de la source d'annonces n'est pas suffisamment précis pour les distinguer. Pour localiser un événement personnalisé spécifique, procédez comme suit :

  1. Obtenez la propriété AdSourceResponseInfo.name.
  2. Définissez un nom de source d'annonces unique.

L'exemple suivant définit un nom de source d'annonces unique pour un événement personnalisé :

Kotlin

private fun getUniqueAdSourceName(loadedAdapterResponseInfo: AdSourceResponseInfo): String {
  var adSourceName = loadedAdapterResponseInfo.name
  if (adSourceName == "Custom Event") {
    if (
      loadedAdapterResponseInfo.adapterClassName ==
        "com.google.ads.mediation.sample.customevent.SampleCustomEvent"
    ) {
      adSourceName = "Sample Ad Network (Custom Event)"
    }
  }
  return adSourceName
}

Java

private String getUniqueAdSourceName(@NonNull AdSourceResponseInfo loadedAdapterResponseInfo) {
  String adSourceName = loadedAdapterResponseInfo.getName();
  if (adSourceName.equals("Custom Event")) {
    if (loadedAdapterResponseInfo
        .getAdapterClassName()
        .equals("com.google.ads.mediation.sample.customevent.SampleCustomEvent")) {
      adSourceName = "Sample Ad Network (Custom Event)";
    }
  }
  return adSourceName;
}

Pour en savoir plus sur la source d'annonces gagnante, consultez Récupérer des informations sur la réponse d'annonce.

Intégration des partenaires d'attribution d'applications

Pour en savoir plus sur la transmission des données sur les revenus publicitaires aux plates-formes d'analyse, consultez le guide du partenaire :

SDK partenaire
Adjust
AppsFlyer
Singular
Tenjin

Il est possible que le guide du partenaire ne soit pas mis à jour pour faire référence à GMA Next-Gen SDK.

Les exemples suivants montrent comment envoyer des données sur les revenus au niveau des impressions aux partenaires d'attribution d'applications à l'aide de GMA Next-Gen SDK :

Adjust

Java

rewardedAd.setAdEventCallback(
    new RewardedAdEventCallback() {
      @Override
      public void onAdPaid(@NonNull AdValue value) {
        // Send ad revenue info to Adjust.
        AdjustAdRevenue adRevenue = new AdjustAdRevenue("admob_sdk");
        adRevenue.setRevenue(value.getValueMicros() / 1000000.0, value.getCurrencyCode());
        if (rewardedAd.getResponseInfo().getLoadedAdSourceResponseInfo() != null) {
          adRevenue.setAdRevenueNetwork(
              rewardedAd.getResponseInfo().getLoadedAdSourceResponseInfo().getName());
        }
        Adjust.trackAdRevenue(adRevenue);
      }
    });

Kotlin

rewardedAd.adEventCallback =
  object : RewardedAdEventCallback {
    override fun onAdPaid(value: AdValue) {
      // Send ad revenue info to Adjust.
      val adRevenue = AdjustAdRevenue("admob_sdk")
      adRevenue.setRevenue(value.valueMicros / 1000000.0, value.currencyCode)
      val loadedAdSourceResponseInfo = rewardedAd.getResponseInfo().loadedAdSourceResponseInfo
      loadedAdSourceResponseInfo?.let { adRevenue.setAdRevenueNetwork(it.name) }
      Adjust.trackAdRevenue(adRevenue)
    }
  }

AppsFlyer

Java

rewardedAd.setAdEventCallback(
    new RewardedAdEventCallback() {
      @Override
      public void onAdPaid(@NonNull AdValue value) {
        long valueMicros = value.getValueMicros();
        String currencyCode = value.getCurrencyCode();

        AFAdRevenueData adRevenueData =
            new AFAdRevenueData(
                "AdMob Mediation", // monetizationNetwork
                MediationNetwork.GOOGLE_ADMOB, // mediationNetwork
                currencyCode, // currencyIso4217Code
                (double) valueMicros // revenue
                );

        Map<String, Object> additionalParameters = new HashMap<>();
        additionalParameters.put(COUNTRY, "US");
        additionalParameters.put(AD_UNIT, AD_UNIT_ID);
        additionalParameters.put(AD_TYPE, AdFormat.REWARDED);

        AppsFlyerLib.getInstance().logAdRevenue(adRevenueData, additionalParameters);
      }
    });

Kotlin

rewardedAd.adEventCallback =
  object : RewardedAdEventCallback {
    override fun onAdPaid(value: AdValue) {
      val valueMicros = value.valueMicros
      val currencyCode = value.currencyCode

      val adRevenueData =
        AFAdRevenueData(
          "AdMob Mediation", // monetizationNetwork
          MediationNetwork.GOOGLE_ADMOB, // mediationNetwork
          currencyCode, // currencyIso4217Code
          valueMicros.toDouble(), // revenue
        )

      val additionalParameters: MutableMap<String?, Any?> = HashMap()
      additionalParameters[COUNTRY] = "US"
      additionalParameters[AD_UNIT] = AD_UNIT_ID
      additionalParameters[AD_TYPE] = AdFormat.REWARDED

      appsflyer.logAdRevenue(adRevenueData, additionalParameters)
    }
  }

Singular

Java

rewardedAd.setAdEventCallback(
    new RewardedAdEventCallback() {
      @Override
      public void onAdPaid(@NonNull AdValue value) {
        // Convert revenue from micros to standard units.
        double revenue = value.getValueMicros() / 1000000.0;
        String currency = value.getCurrencyCode();

        // Validate ad revenue data before sending.
        if (revenue > 0 && !currency.isEmpty()) {
          SingularAdData adData = new SingularAdData("AdMob", currency, revenue);
          Singular.adRevenue(adData);
        }
      }
    });

Kotlin

rewardedAd.adEventCallback =
  object : RewardedAdEventCallback {
    override fun onAdPaid(value: AdValue) {
      // Convert revenue from micros to standard units.
      val revenue = value.valueMicros / 1000000.0
      val currency = value.currencyCode

      // Validate ad revenue data before sending.
      if (revenue > 0 && currency.isNotEmpty()) {
        val adData = SingularAdData("AdMob", currency, revenue)
        Singular.adRevenue(adData)
      }
    }
  }

Tenjin

Pour GMA Next-Gen SDK, vous devez effectuer l'intégration à l'aide d'un objet JSON. L'exemple suivant envoie des données sur les revenus au niveau des impressions à Tenjin à l'aide d'un objet JSON :

Java

rewardedAd.setAdEventCallback(
    new RewardedAdEventCallback() {
      @Override
      public void onAdPaid(@NonNull AdValue value) {
        ResponseInfo responseInfo = rewardedAd.getResponseInfo();

        // Extract the impression-level ad revenue data.
        long valueMicros = value.getValueMicros();
        String currencyCode = value.getCurrencyCode();
        PrecisionType precisionType = value.getPrecisionType();

        JSONObject json = new JSONObject();
        try {
          json.put("ad_unit_id", AD_UNIT_ID);
          json.put("currency_code", currencyCode);
          json.put("response_id", responseInfo.getResponseId());
          json.put("value_micros", valueMicros);
          if (responseInfo.getLoadedAdSourceResponseInfo() != null) {
            json.put(
                "mediation_adapter_class_name",
                responseInfo.getLoadedAdSourceResponseInfo().getAdapterClassName());
          }
          json.put("precision_type", precisionType);

          tenjinInstance.eventAdImpressionAdMob(json);
        } catch (JSONException e) {
          // Handle error.
        }
      }
    });

Kotlin

rewardedAd.adEventCallback =
  object : RewardedAdEventCallback {
    override fun onAdPaid(value: AdValue) {
      val responseInfo = rewardedAd.getResponseInfo()

      // Extract the impression-level ad revenue data.
      val valueMicros = value.valueMicros
      val currencyCode = value.currencyCode
      val precisionType = value.precisionType

      val json = JSONObject()
      try {
        json.put("ad_unit_id", AD_UNIT_ID)
        json.put("currency_code", currencyCode)
        json.put("response_id", responseInfo.responseId)
        json.put("value_micros", valueMicros)
        responseInfo.loadedAdSourceResponseInfo?.let {
          json.put("mediation_adapter_class_name", it.adapterClassName)
        }
        json.put("precision_type", precisionType)

        tenjinInstance.eventAdImpressionAdMob(json)
      } catch (_: JSONException) {
        // Handle error.
      }
    }
  }

Bonnes pratiques pour l'implémentation

  • Définissez l'écouteur immédiatement après avoir créé l'objet publicitaire ou y avoir accédé, et avant d'afficher l'annonce. Vous vous assurez ainsi de ne manquer aucun rappel d'événement payant.
  • Envoyez immédiatement les informations sur les revenus publicitaires au niveau des impressions au serveur d'analyse de votre choix lorsque le rappel d'événement payant est appelé. Vous vous assurez ainsi de ne pas supprimer accidentellement de rappels et d'éviter les écarts de données.

AdValue

AdValue est une classe qui représente la valeur monétaire générée pour une annonce, y compris le code de devise de la valeur et son type de précision encodés comme suit.

PrecisionType Description
UNKNOWN Valeur d'annonce inconnue. Cette valeur est renvoyée lorsque le pingback de la valeur vie est activé, mais que les données disponibles sont insuffisantes.
ESTIMATED La valeur de l'annonce est estimée à partir de données globales.
PUBLISHER_PROVIDED La valeur de l'annonce est fournie par l'éditeur (CPM manuels dans un groupe de médiation, par exemple).
PRECISE Montant exact payé pour cette annonce.

Dans le cas de la médiation AdMob, AdMob tente de fournir une ESTIMATED valeur pour les sources d'annonces qui sont optimisées. Pour les sources d'annonces non optimisées ou lorsque les données globales sont insuffisantes pour générer une estimation significative, la valeur PUBLISHER_PROVIDED est renvoyée.

Tester les impressions provenant de sources d'annonces pour les enchères

Lorsqu'un événement de revenus publicitaires au niveau des impressions se produit pour une source d'annonces pour les enchères via une requête de test, vous ne recevez que les valeurs suivantes :

  • UNKNOWN : indique le type de précision.
  • 0 : indique la valeur de l'annonce.

Auparavant, le type de précision pouvait être une valeur autre que UNKNOWN et la valeur de l'annonce pouvait être supérieure à 0.

Pour en savoir plus sur l'envoi d'une demande d'annonce test, consultez Activer les appareils de test.