private void RequestRewardedAd()
{
    RewardedAd.LoadAd(adUnitId, new AdRequest.Builder().Build(), (rewardedAd, error) => {
        if (error != null) { return; }

        this.rewardedAd = rewardedAd;
        this.rewardedAd.OnPaidEvent += this.HandleAdPaidEvent;
    }
}

public void HandleAdPaidEvent(object sender, AdValueEventArgs args)
{
    AdValue adValue = args.AdValue;
    var adUnitId = this.rewardedAd.adUnitId;
    var adNetworkAdapter = this.rewardedAd.MediationAdapterClassName();
  
    AirbridgeEvent @event = new AirbridgeEvent("airbridge.adImpression");

    var admob = new Dictionary<string, object>();
    admob["value_micros"] = adValue.Value;
    admob["currency_code"] = adValue.CurrencyCode;
    admob["precision"] = adValue.Precision;
  
    admob["ad_unit_id"] = adUnitId;
    admob["ad_network_adapter"] = adNetworkAdapter;
     
    var adPartners = new Dictionary<string, object>();
    adPartners["admob"] = admob;
  
    @event.SetAction(adUnitId);
    @event.SetLabel(adNetworkAdapter);
    @event.SetValue(adValue.Value / 1000000.0);
    @event.AddSemanticAttribute("adPartners", adPartners);
    @event.AddSemanticAttribute("currency", adValue.CurrencyCode);
  
    AirbridgeUnity.TrackEvent(@event);
}

import GoogleMobileAds
import AirBridge
import UIKit

class ViewController: UIViewController {
    var rewardedAd: GADRewardedAd? = nil
    
    func requestRewardedAd() {
        let request = GADRequest()
        GADRewardedAd.load(
            withAdUnitID: "ad unit ID",
            request: request
        ) { ad, error in
            if let error {
                print("Rewarded ad failed to load with error: \(error.localizedDescription)")
                return
            }
            
            self.rewardedAd = ad
            self.rewardedAd?.paidEventHandler = { value in
                let (value, currencyCode, precision) = (
                    value.value,
                    value.currencyCode,
                    value.precision
                )
                
                let adUnitID = self.rewardedAd?.adUnitID
                let adNetworkAdapter = self.rewardedAd?.responseInfo.adNetworkClassName
                
                let event = ABInAppEvent()
                event?.setCategory("airbridge.adImpression")
                event?.setAction(adUnitID)
                event?.setLabel(adNetworkAdapter)
                event?.setValue(value)
                event?.setSemantics([
                    "adPartners": [
                        "admob": [
                            "value_micros": value * 1000000.0,
                            "currency_code": currencyCode,
                            "precision": precision,
                            
                            "ad_unit_id": adUnitID ?? NSNull(),
                            "ad_network_adapter": adNetworkAdapter ?? NSNull(),
                        ]
                    ],
                  	"currency": currencyCode
                ])

                event?.send()
            }
        }
    }
}

@import GoogleMobileAds;
@import AirBridge;
@import UIKit;

@interface ViewController ()
@property(nonatomic, strong) GADRewardedAd *rewardedAd;
@end

@implementation ViewController
- (void)requestRewardedAd {
    __weak ViewController* weakSelf = self;

    GADRequest* request = [GADRequest request];
    [GADRewardedAd loadWithAdUnitID:@"ad unit ID"
                            request:request
                  completionHandler:^(GADRewardedAd *ad, NSError *error) 
    {
        if (error) {
            NSLog(@"Rewarded ad failed to load with error: %@", [error localizedDescription]);
            return;
        }
        self.rewardedAd = ad;
        self.rewardedAd.paidEventHandler = ^void(GADAdValue *_Nonnull adValue){
            ViewController* strongSelf = weakSelf;

            // Extract the impression-level ad revenue data.
            NSDecimalNumber* value; = adValue.value;
            NSString* currencyCode = adValue.currencyCode;
            GADAdValuePrecision precision = adValue.precision;

            // Get the ad unit ID.
            NSString* adUnitId = strongSelf.rewardedAd.adUnitID;
            NSString* adNetworkAdapter = strongSelf.rewardedAd.responseInfo.adNetworkClassName;

            ABInAppEvent* event = [[ABInAppEvent alloc] init];
            [event setCategory:@"airbridge.adImpression"];
            [event setAction:adUnitId];
            [event setLabel:adNetworkAdapter];
            [event setValue:value];
            [event setSemantics:@{
                @"adPartners": @{
                    @"admob": @{
                        @"value_micros": [value decimalNumberByMultiplyingByPowerOf10:6],
                        @"currency_code": currencyCode,
                        @"precision": precision,
                        
                        @"ad_unit_id": adUnitId,
                        @"ad_network_adapter": adNetworkAdapter
                    }
                },
                @"currency": currencyCode
            }];

            [event send];
        };
    }];
}

import com.google.android.gms.ads.rewarded.RewardedAd;

public class MainActivity extends Activity {
    private RewardedAd rewardedAd;
    private final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        AdRequest adRequest = new AdRequest.Builder().build();

        RewardedAd.load(this, "ad unit ID", adRequest, new RewardedAdLoadCallback(){
            @Override
            public void onAdLoaded(@NonNull RewardedAd ad) {
                rewardedAd = ad;
                // Set paid event listener
                rewardedAd.setOnPaidEventListener(new OnPaidEventListener() {
                    @Override
                    public void onPaidEvent(AdValue adValue) {
                        // Extract the impression-level ad revenue data.
                        long valueMicros = adValue.getValueMicros();
                        String currencyCode = adValue.getCurrencyCode();
                        String precision = adValue.getPrecisionType();

                        // Get the ad unit ID.
                        String adUnitId = rewardedAd.getAdUnitId();
                        String adNetworkAdapter = rewardedAd.getMediationAdapterClassName();
              
                        Event event = new Event("airbridge.adImpression");
                        Map<String, Object> admob = new HashMap<>();
                        admob.put("value_micros", valueMicros);
                        admob.put("currency_code", currencyCode);
                        admob.put("precision", precision);
              
                        admob.put("ad_unit_id", adUnitId);
                        admob.put("ad_network_adapter", adNetworkAdapter);
              
                        Map<String, Object> adPartners = new HashMap<>();
                        adPartners.put("admob", admob);
                        Map<String, Object> semanticAttributes = new HashMap<>();
                        semanticAttributes.put("adPartners", adPartners);
                        semanticAttributes.put("currency", currencyCode);
              
                        event.setAction(adUnitId);
                        event.setLabel(adNetworkAdapter);
                        event.setValue(valueMicros / 1000000.0);
                        event.setSemanticAttributes(semanticAttributes);
                        Airbridge.trackEvent(event);
                    }
                });
            }
        });
    }
}

import com.google.android.gms.ads.rewarded.RewardedAd

class MainActivity : AppCompatActivity() {
    private var rewardedAd: RewardedAd? = null
    private final var TAG = "MainActivity"

    override fun onCreate(savedInstanceState: Bundle?) {
        AdRequest adRequest = new AdRequest.Builder().build()

        RewardedAd.load(this, "ad unit ID", adRequest, object: RewardedAdLoadCallback() {
            override fun onAdLoaded(ad: RewardedAd) {
                rewardedAd = ad
                // Set paid event listener
                rewardedAd.onPaidEventListener = OnPaidEventListener { adValue ->
                    // Extract the impression-level ad revenue data.
                    val valueMicros = adValue.valueMicros
                    val currencyCode = adValue.currencyCode
                    val precision = adValue.precisionType

                    // Get the ad unit ID.
                    val adUnitId = rewardedAd.adUnitId
                    val adNetworkAdapter = rewardedAd.mediationAdapterClassName

                    val event = Event("airbridge.adImpression")
                    val admob = mutableMapOf<String, Any?>()
                    admob["value_micros"] = valueMicros
                    admob["currency_code"] = currencyCode
                    admob["precision"] = precision
                    
                    admob["ad_unit_id"] = adUnitId
                    admob["ad_network_adapter"] = adNetworkAdapter
                  
                    val adPartners = mapOf("admob" to admob)
                    event.action = adUnitId
                    event.label = adNetworkAdapter
                    event.value = valueMicros / 1000000.0
                    event.semanticAttributes = mutableMapOf(
                        "adPartners" to adPartners,
                        "currency" to currencyCode
                    )
                    Airbridge.trackEvent(event)
                }
            }
        })
    }
}