Android 版 Protected Audience API 開發人員指南

val customAudienceManager: CustomAudienceManager =
    context.getSystemService(CustomAudienceManager::class.java)

// Initialize a custom audience.
val audience = CustomAudience.Builder()
    .setBuyer(buyer)
    .setName(name)
    ...
    .build()

// Initialize a custom audience request.
val joinCustomAudienceRequest: JoinCustomAudienceRequest =
    JoinCustomAudienceRequest.Builder().setCustomAudience(audience).build()

// Request to join a custom audience.
customAudienceManager.joinCustomAudience(joinCustomAudienceRequest,
    executor,
    outcomeReceiver)

CustomAudienceManager customAudienceManager =
    context.getSystemService(CustomAudienceManager.class);

// Initialize a custom audience.
CustomAudience audience = new CustomAudience.Builder()
    .setBuyer(buyer)
    .setName(name)
    ...
    .build();

// Initialize a custom audience request.
JoinCustomAudienceRequest joinCustomAudienceRequest =
    new JoinCustomAudienceRequest.Builder().setCustomAudience(audience).build();

// Request to join a custom audience.
customAudienceManager.joinCustomAudience(joinCustomAudienceRequest,
    executor,
    outcomeReceiver);

// Minimal initialization of a CustomAudience object
val customAudience: CustomAudience = CustomAudience.Builder()
    .setBuyer(AdTechIdentifier.fromString("my.buyer.domain.name"))
    .setName("example-custom-audience-name")
    .setDailyUpdateUrl(Uri.parse("https://DAILY_UPDATE_URL"))
    .setBiddingLogicUrl(Uri.parse("https://BIDDING_LOGIC_URL"))
    .build()

// Minimal initialization of a CustomAudience object
CustomAudience customAudience = CustomAudience.Builder()
    .setBuyer(AdTechIdentifier.fromString("my.buyer.domain.name"))
    .setName("example-custom-audience-name")
    .setDailyUpdateUrl(Uri.parse("https://DAILY_UPDATE_URL"))
    .setBiddingLogicUrl(Uri.parse("https://BIDDING_LOGIC_URL"))
    .build();

var callback: OutcomeReceiver<Void, AdServicesException> =
    object : OutcomeReceiver<Void, AdServicesException> {
    override fun onResult(result: Void) {
        Log.i("CustomAudience", "Completed joinCustomAudience")
    }

    override fun onError(error: AdServicesException) {
        // Handle error
        Log.e("CustomAudience", "Error executing joinCustomAudience", error)
    }
};

OutcomeReceiver callback = new OutcomeReceiver<Void, AdServicesException>() {
    @Override
    public void onResult(@NonNull Void result) {
        Log.i("CustomAudience", "Completed joinCustomAudience");
    }

    @Override
    public void onError(@NonNull AdServicesException error) {
        // Handle error
        Log.e("CustomAudience", "Error executing joinCustomAudience", error);
    }
};

val customAudienceManager: CustomAudienceManager =
    context.getSystemService(CustomAudienceManager::class.java)

// Initialize a LeaveCustomAudienceRequest
val leaveCustomAudienceRequest: LeaveCustomAudienceRequest =
    LeaveCustomAudienceRequest.Builder()
        .setBuyer(buyer)
        .setName(name)
        .build()

// Request to leave a custom audience
customAudienceManager.leaveCustomAudience(
    leaveCustomAudienceRequest,
    executor,
    outcomeReceiver)

CustomAudienceManager customAudienceManager =
    context.getSystemService(CustomAudienceManager.class);

// Initialize a LeaveCustomAudienceRequest
LeaveCustomAudienceRequest leaveCustomAudienceRequest =
    new LeaveCustomAudienceRequest.Builder()
        .setBuyer(buyer)
        .setName(name)
        .build();

// Request to leave a custom audience
customAudienceManager.leaveCustomAudience(
    leaveCustomAudienceRequest,
    executor,
    outcomeReceiver);

val adSelectionManager: AdSelectionManager =
  context.getSystemService(AdSelectionManager::class.java)

// Initialize AdSelectionConfig
val adSelectionConfig: AdSelectionConfig =
  AdSelectionConfig.Builder().setSeller(seller)
    .setDecisionLogicUrl(decisionLogicUrl)
    .setCustomAudienceBuyers(customAudienceBuyers)
    .setAdSelectionSignals(adSelectionSignals)
    .setSellerSignals(sellerSignals)
    .setPerBuyerSignals(perBuyerSignals)
    .setBuyerContextualAds(
      Collections.singletonMap(
        contextualAds.getBuyer(), contextualAds
      )
    ).build()

// Run ad selection with AdSelectionConfig
adSelectionManager.selectAds(
  adSelectionConfig, executor, outcomeReceiver
)

AdSelectionManager adSelectionManager =
    context.getSystemService(AdSelectionManager.class);

// Initialize AdSelectionConfig
AdSelectionConfig adSelectionConfig =
  new AdSelectionConfig.Builder()
    .setSeller(seller)
    .setDecisionLogicUrl(decisionLogicUrl)
    .setCustomAudienceBuyers(customAudienceBuyers)
    .setAdSelectionSignals(adSelectionSignals)
    .setSellerSignals(sellerSignals)
    .setPerBuyerSignals(perBuyerSignals)
    .setBuyerContextualAds(
      Collections.singletonMap(contextualAds.getBuyer(), contextualAds)
    )
    .build();

// Run ad selection with AdSelectionConfig
adSelectionManager.selectAds(adSelectionConfig, executor, outcomeReceiver);

val signedContextualAds: SignedContextualAds =
  Builder().setBuyer(AdTechIdentifier.fromString(mBiddingLogicUri.getHost()))
    //Pass in your valid app install ads
    .setDecisionLogicUri(mContextualLogicUri)
    .setAdsWithBid(appInstallAd)
    .setSignature(signature)
    .build()

SignedContextualAds signedContextualAds = new SignedContextualAds.Builder()
  .setBuyer(AdTechIdentifier.fromString(mBiddingLogicUri.getHost()))
  .setDecisionLogicUri(mContextualLogicUri)
  //Pass in your valid app install ads
  .setAdsWithBid(appInstallAd)
  .setSignature(signature)
  .build();

val adSelectionConfig = AdSelectionConfig.Builder()
  .setPerBuyerSignedContextualAds(signedContextualAds)
  // Other fields for your config
  .build()

AdSelectionConfig adSelectionConfig = new AdSelectionConfig.Builder()
    .setPerBuyerSignedContextualAds(signedContextualAds)
    //Other fields for your config
    .build();

//Create a request for setting the app install advertisers
val adtech = AdTechIdentifier.fromString("your.enrolled.uri")
val adtechSet = setOf(adtech)
val request = SetAppInstallAdvertisersRequest(adtechSet)

//Set the app install advertisers in the ad selection manager
mAdSelectionManager.setAppInstallAdvertisers(
  request,
  mExecutor,
  object : OutcomeReceiver<Any?, Exception?>() {
    fun onResult(@NonNull ignoredResult: Any?) {
      Log.v("[your tag]", "Updated app install advertisers")
    }

    fun onError(@NonNull error: Exception?) {
      Log.e("[your tag]", "Failed to update app install advertisers", error)
    }
  })

//Create a request for setting the app install advertisers
AdTechIdentifier adtech = AdTechIdentifier.fromString("your.enrolled.uri");
Set<AdTechIdentifier> adtechSet = Collections.singleton(adtech);
SetAppInstallAdvertisersRequest request = new SetAppInstallAdvertisersRequest(adtechSet);

//Set the app install advertisers in the ad selection manager
mAdSelectionManager.setAppInstallAdvertisers(
  request,
  mExecutor,
  new OutcomeReceiver<Object, Exception>() {
    @Override
    public void onResult(@NonNull Object ignoredResult) {
      Log.v("[your tag]", "Updated app install advertisers");
    }

    @Override
    public void onError(@NonNull Exception error) {
      Log.e("[your tag]", "Failed to update app install advertisers", error);
    }
  });

// Instantiate AdFilters object with package names.
val filters: AdFilters = Builder().setAppInstallFilters(
    Builder().setPackageNames(setOf("example.target.app")).build()
  ).build()

// Instantiate AdFilters object with package names.
AdFilters filters = new AdFilters.Builder()
.setAppInstallFilters(
  new AppInstallFilters.Builder()
  .setPackageNames(Collections.singleton("example.target.app"))
  .build())
.build();

// Instantiate an AdData object with the AdFilters created in the
// previous example.
val appInstallAd: AdData =
  Builder().setMetadata("{ ... }") // Valid JSON string
    .setRenderUri(Uri.parse("www.example-dsp1.com/.../campaign123.html"))
    .setAdFilters(filters).build()

// Instantiate an AdData object with the AdFilters created in the
// previous example.
AdData appInstallAd = new AdData.Builder()
.setMetadata("{ ... }") // Valid JSON string
.setRenderUri(Uri.parse("www.example-dsp1.com/.../campaign123.html"))
    .setAdFilters(filters)
    .build();

// Value used when incrementing frequency counter
val adCounterKey = 123

// Frequency cap exceeded after 2 counts
val keyedFrequencyCapForImpression: KeyedFrequencyCap = Builder(
  adCounterKey, 2, Duration.ofSeconds(10)
).build()

// Frequency cap exceeded after 1 counts
val keyedFrequencyCapForImpression: KeyedFrequencyCap = Builder(
  adCounterKey, 1, Duration.ofSeconds(10)
).build()

// Value used when incrementing frequency counter
int adCounterKey = 123;

// Frequency cap exceeded after 2 counts
KeyedFrequencyCap keyedFrequencyCapForImpression =
  new KeyedFrequencyCap.Builder(
    adCounterKey, 2, Duration.ofSeconds(10)
  ).build();

// Frequency Cap exceeded after 1 counts
KeyedFrequencyCap keyedFrequencyCapForClick =
  new KeyedFrequencyCap.Builder(
    adCounterKey, 1, Duration.ofSeconds(10)
  ).build();

val filters: AdFilters = Builder()
  .setFrequencyCapFilters(
    Builder()
      .setKeyedFrequencyCapsForImpressionEvents(
        ImmutableObject.of(keyedFrequencyCapForImpression)
      )
      .setKeyedFrequencyCapsForClickEvents(
        ImmutableObject.of(keyedFrequencyCapForClick)
      )
  ).build()

AdFilters filters = new AdFilters.Builder()
    .setFrequencyCapFilters(new FrequencyCapFilters.Builder()
        .setKeyedFrequencyCapsForImpressionEvents(
            ImmutableObject.of(keyedFrequencyCapForImpression)
        )
        .setKeyedFrequencyCapsForClickEvents(
            ImmutableObject.of(keyedFrequencyCapForClick)
        )
    ).build();

// Initialize a custom audience.
val audience: CustomAudience = Builder()
  .setBuyer(buyer)
  .setName(name)
  .setAds(
    listOf(
      Builder()
        .setRenderUri(renderUri)
        .setMetadata(JSONObject().toString())
        .setAdFilters(filters)
        .setAdCounterKeys(adCounterKeys)
        .build()
    )
  ).build()

// Initialize a custom audience.
CustomAudience audience = new CustomAudience.Builder()
    .setBuyer(buyer)
    .setName(name)
    .setAds(Collections.singletonList(new AdData.Builder()
        .setRenderUri(renderUri)
        .setMetadata(new JSONObject().toString())
        .setAdFilters(filters)
        .setAdCounterKeys(adCounterKeys)
        .build()))
    .build();

val callerAdTech: AdTechIdentifier = mAdSelectionConfig.getSeller()

val request: UpdateAdCounterHistogramRequest = Builder(
  adSelectionId,
  FrequencyCapFilters.AD_EVENT_TYPE_CLICK,  //CLICK, VIEW, or IMPRESSION
  callerAdTech
).build()

AdTechIdentifier callerAdTech = mAdSelectionConfig.getSeller();

UpdateAdCounterHistogramRequest request =
  new UpdateAdCounterHistogramRequest.Builder(
      adSelectionId,
      FrequencyCapFilters.AD_EVENT_TYPE_CLICK, //CLICK, VIEW, or IMPRESSION
      callerAdTech
).build();

import java.security.*;

public class ECDSASignatureManager {
    private static KeyPair generateKeyPair() throws Exception {
        // Specify the curve name P-256
        ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256r1");

        // Initialize the KeyPairGenerator
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
        keyPairGenerator.initialize(ecSpec);

        // Generate the KeyPair
        return keyPairGenerator.generateKeyPair();
    }

    public byte[] sign(byte[] data, byte[] privateKey) throws Exception {
        Signature ecdsa = Signature.getInstance("SHA256withECDSA");
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
        KeyFactory keyFactory = KeyFactory.getInstance("EC");
        PrivateKey aPrivateKey = keyFactory.generatePrivate(keySpec);

        ecdsa.initSign(aPrivateKey);
        ecdsa.update(data);

        return ecdsa.sign();
    }
}

const crypto = require('crypto');

function generateKeyPair() {
  const keyPair = crypto.generateKeyPairSync('ec', {
    // Specifies ECDSA algorithm
    namedCurve: 'prime256v1',
    publicKeyEncoding: { type: 'spki', format: 'der' },
    privateKeyEncoding: { type: 'pkcs8', format: 'der'}
  });

  return {
    publicKey: keyPair.publicKey,
    privateKey: keyPair.privateKey
  };
}

function signContextualAds(data, privateKey) {
  // Convert the private key from PKCS8 to PEM format
  const base64PrivateKey = Buffer.from(privateKey).toString('base64');
  const pemPrivateKey = `-----BEGIN PRIVATE KEY-----\n${base64PrivateKey}\n-----END PRIVATE KEY-----`;

  // Create a Sign object using SHA256
  const sign = crypto.createSign('SHA256');
  sign.update(Buffer.from(data));

  // Sign the data with ECDSA as specified in the key specs
  return sign.sign(pemPrivateKey);
}

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ec

def sign_contextual_ads(data, private_key_der):
    private_key = serialization.load_der_private_key(
        private_key_der,
        password=None,
        backend=default_backend()
    )

    signature = private_key.sign(
        data,
        ec.ECDSA(hashes.SHA256())
    )

    return signature

def generate_key_pair():
    private_key = ec.generate_private_key(ec.SECP256R1())

    # Serialize the keys into DER format
    public_key_der = private_key.public_key().public_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )

    private_key_der = private_key.private_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )

    return public_key_der, private_key_der

public class ContextualAdsSerializationUtil {
    private static final String FIELD_SEPARATOR = "|";
    private static final String ENUMERATOR_SEPARATOR = ",";

    private final ByteArrayOutputStream mByteArrayStream;

    public ContextualAdsSerializationUtil() {
        this.mByteArrayStream = new ByteArrayOutputStream();
    }

    byte[] getBytes() {
        return this.mByteArrayStream.toByteArray();
    }

    public byte[] serialize(ContextualAds ads) {
        writeContextualAds(ads);
        return getBytes();
    }

    private void writeContextualAds(ContextualAds ads) {
        writeString("buyer=");
        writeField(ads.getBuyer().getIdentifier(), this::writeString);

        writeString("decision_logic_uri=");
        writeField(ads.getDecisionLogicUri().toString(), this::writeString);

        writeString("ads_with_bid=");
        writeList(ads.getAdsWithBid(), this::writeAdWithBid);
    }

    private void writeAdWithBid(AdWithBid adWithBid) {
        writeString("ad_data=");
        writeField(adWithBid.getAdData(), this::writeAdData);

        writeString("bid=");
        writeField(adWithBid.getBid(), this::writeDouble);
    }

    private void writeAdData(AdData adData) {
        writeString("ad_counter_keys=");
        writeSet(adData.getAdCounterKeys(), this::writeInt);

        if (!Objects.isNull(adData.getAdFilters())) {
            writeString("ad_filters=");
            writeField(adData.getAdFilters(), this::writeAdFilters);
        }

        if (!Objects.isNull(adData.getAdRenderId())) {
            writeString("ad_render_id=");
            writeField(adData.getAdRenderId(), this::writeString);
        }

        writeString("metadata=");
        writeField(adData.getMetadata(), this::writeString);

        writeString("render_uri=");
        writeField(adData.getRenderUri().toString(), this::writeString);
    }

    private void writeAdFilters(AdFilters adFilters) {
        if (!Objects.isNull(adFilters.getAppInstallFilters())) {
            writeString("app_install_filters=");
            writeField(adFilters.getAppInstallFilters(), this::writeAppInstallFilter);
        }

        if (!Objects.isNull(adFilters.getFrequencyCapFilters())) {
            writeString("frequency_cap_filters=");
            writeField(adFilters.getFrequencyCapFilters(), this::writeFrequencyCapFilters);
        }
    }

    private void writeAppInstallFilter(AppInstallFilters appInstallFilters) {
        writeString("package_names=");
        writeSet(appInstallFilters.getPackageNames(), this::writeString);
    }

    private void writeFrequencyCapFilters(FrequencyCapFilters frequencyCapFilters) {
        writeString("keyed_frequency_caps_for_click_events=");
        writeList(
            frequencyCapFilters.getKeyedFrequencyCapsForClickEvents(),
            this::writeKeyedFrequencyCap);

        writeString("keyed_frequency_caps_for_impression_events=");
        writeList(
            frequencyCapFilters.getKeyedFrequencyCapsForImpressionEvents(),
            this::writeKeyedFrequencyCap);

        writeString("keyed_frequency_caps_for_view_events=");
        writeList(
            frequencyCapFilters.getKeyedFrequencyCapsForViewEvents(),
            this::writeKeyedFrequencyCap);

        writeString("keyed_frequency_caps_for_win_events=");
        writeList(
            frequencyCapFilters.getKeyedFrequencyCapsForWinEvents(),
            this::writeKeyedFrequencyCap);
    }

    private void writeKeyedFrequencyCap(KeyedFrequencyCap keyedFrequencyCap) {
        writeString("ad_counter_key=");
        writeField(keyedFrequencyCap.getAdCounterKey(), this::writeInt);

        writeString("interval=");
        writeField(keyedFrequencyCap.getInterval().toMillis(), this::writeLong);

        writeString("max_count=");
        writeField(keyedFrequencyCap.getMaxCount(), this::writeInt);
    }

    private <T> void writeField(T field, Consumer<T> writerConsumer) {
        Objects.requireNonNull(field);

        writerConsumer.accept(field);
        writeString(FIELD_SEPARATOR);
    }

    private <T> void writeList(List<T> list, Consumer<T> writerConsumer) {
        FirstElementStateHolder state = new FirstElementStateHolder();
        for (T t : list) {
            if (!state.isFirstThenSetFalse()) {
                writeString(ENUMERATOR_SEPARATOR);
            }
            writerConsumer.accept(t);
        }
        writeString(FIELD_SEPARATOR);
    }

    private <T> void writeSet(Set<T> set, Consumer<T> writerConsumer) {
        FirstElementStateHolder state = new FirstElementStateHolder();
        set.stream()
            .sorted()
            .forEach(
                (value) -> {
                    if (!state.isFirstThenSetFalse()) {
                        writeString(ENUMERATOR_SEPARATOR);
                    }
                    writerConsumer.accept(value);
                });
        writeString(FIELD_SEPARATOR);
    }

    void writeString(String value) {
        mByteArrayStream.writeBytes(value.getBytes(StandardCharsets.UTF_8));
    }

    void writeLong(long value) {
        writeString(Long.toString(value));
    }

    void writeDouble(double value) {
        writeString(String.format("%.2f", value));
    }

    void writeInt(int value) {
        writeString(Integer.toString(value));
    }

    private static class FirstElementStateHolder {

        private boolean mIsFirst = true;

        public boolean isFirstThenSetFalse() {
            boolean initialValue = mIsFirst;
            mIsFirst = false;
            return initialValue;
        }
    }
}

class SignedContextualAdsHashUtil {
  constructor() {
    this.serializedString = '';
  }

  serialize(ads) {
    this.writeContextualAds(ads);
    return new TextEncoder().encode(this.serializedString);
  }

  writeContextualAds(ads) {
    this.writeString('buyer=');
    this.writeField(ads.buyer.identifier, value => this.writeString(value));

    this.writeString('decision_logic_uri=');
    this.writeField(ads.decisionLogicUri, value => this.writeString(value));

    this.writeString('ads_with_bid=');
    this.writeList(ads.adsWithBid, adWithBid => this.writeAdWithBid(adWithBid));
  }

  writeAdWithBid(adWithBid) {
    this.writeString('ad_data=');
    this.writeField(adWithBid.adData, adData => this.writeAdData(adData));

    this.writeString('bid=');
    this.writeField(adWithBid.bid, value => this.writeDouble(value));
  }

  writeAdData(adData) {
    this.writeString('ad_counter_keys=');
    this.writeSet([...adData.adCounterKeys], value => this.writeInt(value));

    if (adData.adFilters) {
      this.writeString('ad_filters=');
      this.writeField(adData.adFilters, adFilters => this.writeAdFilters(adFilters));
    }

    if (adData.adRenderId) {
      this.writeString('ad_render_id=');
      this.writeField(adData.adRenderId, value => this.writeString(value));
    }

    this.writeString('metadata=');
    this.writeField(adData.metadata, value => this.writeString(value));

    this.writeString('render_uri=');
    this.writeField(adData.renderUri, value => this.writeString(value));
  }

  writeAdFilters(adFilters) {
    if (adFilters.appInstallFilters) {
      this.writeString('app_install_filters=');
      this.writeField(adFilters.appInstallFilters, appInstallFilters => this.writeAppInstallFilter(appInstallFilters));
    }

    if (adFilters.frequencyCapFilters) {
      this.writeString('frequency_cap_filters=');
      this.writeField(adFilters.frequencyCapFilters, frequencyCapFilters => this.writeFrequencyCapFilters(frequencyCapFilters));
    }
  }

  writeAppInstallFilter(appInstallFilters) {
    this.writeString('package_names=');
    this.writeSet([...appInstallFilters.packageNames], value => this.writeString(value));
  }

  writeFrequencyCapFilters(frequencyCapFilters) {
    this.writeString('keyed_frequency_caps_for_click_events=');
    this.writeList(frequencyCapFilters.keyedFrequencyCapsForClickEvents, cap => this.writeKeyedFrequencyCap(cap));

    this.writeString('keyed_frequency_caps_for_impression_events=');
    this.writeList(frequencyCapFilters.keyedFrequencyCapsForImpressionEvents, cap => this.writeKeyedFrequencyCap(cap));

    this.writeString('keyed_frequency_caps_for_view_events=');
    this.writeList(frequencyCapFilters.keyedFrequencyCapsForViewEvents, cap => this.writeKeyedFrequencyCap(cap));

    this.writeString('keyed_frequency_caps_for_win_events=');
    this.writeList(frequencyCapFilters.keyedFrequencyCapsForWinEvents, cap => this.writeKeyedFrequencyCap(cap));
  }

  writeKeyedFrequencyCap(cap) {
    this.writeString('ad_counter_key=');
    this.writeField(cap.adCounterKey, value => this.writeInt(value));

    this.writeString('interval=');
    this.writeField(cap.interval, value => this.writeLong(value));

    this.writeString('max_count=');
    this.writeField(cap.maxCount, value => this.writeInt(value));
  }

  writeField(field, writer) {
    writer(field);
    this.writeString('|');
  }

  writeList(list, writer) {
    list.forEach((item, index) => {
      if (index > 0) this.writeString(',');
      writer(item);
    });
    this.writeString('|');
  }

  writeSet(set, writer) {
    [...set].sort().forEach((item, index) => {
      if (index > 0) this.writeString(',');
      writer(item);
    });
    this.writeString('|');
  }

  writeString(value) {
    this.serializedString += value;
  }

  writeLong(value) {
    this.writeString(value.toString());
  }

  writeDouble(value) {
    this.writeString(value.toFixed(2));
  }

  writeInt(value) {
    this.writeString(value.toString());
  }
}

module.exports = {
  SignedContextualAdsHashUtil,
};

class SignedContextualAdsHashUtil:
    def __init__(self):
        self.serialized_string = ''

    def serialize(self, ads):
        self.write_contextual_ads(ads)
        return self.serialized_string.encode('utf-8')

    def write_contextual_ads(self, ads):
        self.write_string('buyer=')
        self.write_field(ads.buyer.identifier, lambda v: self.write_string(v))

        self.write_string('decision_logic_uri=')
        self.write_field(ads.decision_logic_uri, lambda v: self.write_string(v))

        self.write_string('ads_with_bid=')
        self.write_list(ads.ads_with_bid, self.write_ad_with_bid)

    def write_ad_with_bid(self, ad_with_bid):
        self.write_string('ad_data=')
        self.write_field(ad_with_bid.ad_data, self.write_ad_data)

        self.write_string('bid=')
        self.write_field(ad_with_bid.bid, lambda v: self.write_double(v))

    def write_ad_data(self, ad_data):
        self.write_string('ad_counter_keys=')
        self.write_set(ad_data.ad_counter_keys, lambda v: self.write_int(v))

        if ad_data.ad_filters:
            self.write_string('ad_filters=')
            self.write_field(ad_data.ad_filters, self.write_ad_filters)

        if ad_data.ad_render_id:
            self.write_string('ad_render_id=')
            self.write_field(ad_data.ad_render_id, lambda v: self.write_string(v))

        self.write_string('metadata=')
        self.write_field(ad_data.metadata, lambda v: self.write_string(v))

        self.write_string('render_uri=')
        self.write_field(ad_data.render_uri, lambda v: self.write_string(v))

    def write_ad_filters(self, ad_filters):
        if ad_filters.app_install_filters:
            self.write_string('app_install_filters=')
            self.write_field(ad_filters.app_install_filters,
                            self.write_app_install_filter)

        if ad_filters.frequency_cap_filters:
            self.write_string('frequency_cap_filters=')
            self.write_field(ad_filters.frequency_cap_filters,
                            self.write_frequency_cap_filters)

    def write_app_install_filter(self, app_install_filters):
        self.write_string('package_names=')
        self.write_set(app_install_filters.package_names,
                      lambda v: self.write_string(v))

    def write_frequency_cap_filters(self, frequency_cap_filters):
        for attr in ['keyed_frequency_caps_for_click_events',
                    'keyed_frequency_caps_for_impression_events',
                    'keyed_frequency_caps_for_view_events',
                    'keyed_frequency_caps_for_win_events']:
            self.write_string(f'{attr}=')
            self.write_list(getattr(frequency_cap_filters, attr),
                            self.write_keyed_frequency_cap)

    def write_keyed_frequency_cap(self, cap):
        self.write_string('ad_counter_key=')
        self.write_field(cap.ad_counter_key, lambda v: self.write_int(v))

        self.write_string('interval=')
        self.write_field(cap.interval, lambda v: self.write_long(v))

        self.write_string('max_count=')
        self.write_field(cap.max_count, lambda v: self.write_int(v))

    def write_field(self, field, writer):
        writer(field)
        self.write_string('|')

    def write_list(self, list_items, writer):
        for index, item in enumerate(list_items):
            if index > 0:
                self.write_string(',')
            writer(item)
        self.write_string('|')

    def write_set(self, set_items, writer):
        for index, item in enumerate(sorted(set_items)):
            if index > 0:
                self.write_string(',')
            writer(item)
        self.write_string('|')

    def write_string(self, value):
        self.serialized_string += value

    def write_long(self, value):
        self.write_string(str(value))

    def write_double(self, value):
        self.write_string(f'{value:.2f}')

    def write_int(self, value):
        self.write_string(str(value))

class NetworkAdaptor {
    private val adSelectionManager : AdSelectionManager

    init {
        adSelectionManager = context.getSystemService(AdSelectionManager::class.java)
    }

    fun selectAds() {...}

    fun reportImpressions() {...}
}

class NetworkAdaptor {
    AdSelectionManager adSelectionManager;

    public NetworkAdaptor() {
        AdSelectionManager adSelectionManager =
            context.getSystemService(AdSelectionManager.class);
    }

    public void selectAds() {...}

    public void reportImpressions() {...}
}

fun  runSelectOutcome(
    adSelectionClient : AdSelectionClient,
    outcome1p : AdSelectionOutcome,
    network3p : NetworkAdapter) : ListenableFuture<AdSelectionOutcome?> {
    val config = AdSelectionFromOutcomesConfig.Builder()
        .setSeller(seller)
        .setAdSelectionIds(listOf(outcome1p))
        .setSelectionSignals({"bid_floor": bid_floor})
        .setSelectionLogicUri(selectionLogicUri)
        .build()
    return adSelectionClient.selectAds(config)
}

public ListenableFuture<AdSelectionOutcome> runSelectOutcome(AdSelectionOutcome outcome1p,
                                              NetworkAdapter network3p) {
    AdSelectionFromOutcomesConfig config = new AdSelectionFromOutcomesConfig.Builder()
            .setSeller(seller)
            .setAdSelectionIds(Collection.singletonList(outcome1p))
            .setSelectionSignals({"bid_floor": bid_floor})
            .setSelectionLogicUri(selectionLogicUri)
            .build();

    return adSelectionClient.selectAds(config){}
}

val adSelectionManager = context.getSystemService(AdSelectionManager::class.java)

// Initialize AdSelectionFromOutcomesConfig
AdSelectionFromOutcomesConfig adSelectionFromOutcomesConfig =
  AdSelectionFromOutcomesConfig.Builder()
    .setSeller(seller)
    .setAdSelectionIds(listof(outcome1p))
    .setSelectionSignals({"bid_floor": bid_floor})
    .setSelectionLogicUri(selectionLogicUri)
    .setAdSelectionIds(outcomeIds)
    .build()

// Run ad selection with AdSelectionConfig
adSelectionManager.selectAds(
    adSelectionFromOutcomesConfig,
    executor,
    outcomeReceiver)

AdSelectionManager adSelectionManager =
    context.getSystemService(AdSelectionManager.class);

// Initialize AdSelectionFromOutcomesConfig
AdSelectionFromOutcomesConfig adSelectionFromOutcomesConfig =
        new AdSelectionFromOutcomesConfig.Builder()
            .setSeller(seller)
            .setAdSelectionIds(Collection.singletonList(outcome1p))
            .setSelectionSignals({"bid_floor": bid_floor})
            .setSelectionLogicUri(selectionLogicUri)
            .setAdSelectionIds(outcomeIds)
            .build();

// Run ad selection with AdSelectionConfig
adSelectionManager.selectAds(
    adSelectionFromOutcomesConfig,
    executor,
    outcomeReceiver);

fun runWaterfallMediation(mediationChain : List<NetworkAdapter>)
  : Pair<AdSelectionOutcome, NetworkAdapter> {
    val outcome1p = runAdSelection()

    var outcome : AdSelectionOutcome
    for(network3p in mediationChain) {
      outcome = runSelectOutcome(outcome1p, network3p)
      if (outcome1p.hasOutcome() && outcome.hasOutcome()) {
          return Pair(outcome, this)
      }

      outcome = network3p.runAdSelection()
      if(outcome.hasOutcome()) {
          return Pair(outcome, network3p)
      }
    }
  return Pair(outcome1p, this)
}

class MediationNetwork {
    AdSelectionManager adSelectionManager;

    public MediationNetwork() {
        AdSelectionManager adSelectionManager =
            context.getSystemService(AdSelectionManager.class);
    }

    public void runAdSelection() {...}

    public void reportImpressions() {...}

    public Pair<AdSelectionOutcome, NetworkAdapter> runWaterfallMediation(
            List<NetworkAdapter> mediationChain) {
        AdSelectionOutcome outcome1p = runAdSelection();

        AdSelectionOutcome outcome;
        for(NetworkAdapter network3p: mediationChain) {
            if (outcome1p.hasOutcome() &&
              (outcome = runSelectOutcome(outcome1p, network3p)).hasOutcome()) {
                return new Pair<>(outcome, this);
            }

            if((outcome = network3p.runAdSelection()).hasOutcome()) {
                return new Pair<>(outcome, network3p);
            }
        }
        return new Pair<>(outcome1p, this);
    }

    /* Runs comparison by creating an AdSelectionFromOutcomesConfig */
    public AdSelectionOutcome runSelectOutcome(AdSelectionOutcome outcome1p,
                                              NetworkAdapter network3p) { ... }
}

AdSelectionManager adSelectionManager =
    context.getSystemService(AdSelectionManager.class);

// Initialize a ReportImpressionRequest
ReportImpressionRequest reportImpressionRequest =
        new ReportImpressionRequest.Builder()
                .setAdSelectionId(adSelectionId)
                .setAdSelectionConfig(adSelectionConfig)
                .build();

// Request to report the impression with the ReportImpressionRequest
adSelectionManager.reportImpression(
    reportImpressionRequest,
    executor,
    outcomeReceiver);

val adSelectionManager = context.getSystemService(AdSelectionManager::class.java)

// Initialize a ReportImpressionRequest
val adSelectionConfig: ReportImpressionRequest =
    ReportImpressionRequest.Builder()
        .setAdSelectionId(adSelectionId)
        .setAdSelectionConfig(adSelectionConfig)
        .build()

// Request to report the impression with the ReportImpressionRequest
adSelectionManager.reportImpression(
    reportImpressionRequest,
    executor,
    outcomeReceiver)