रनटाइम की सुविधा के साथ काम करने वाला SDK टूल बनाना और उसका इस्तेमाल करना

रनटाइम के साथ काम करने वाला एसडीके बनाना

रनटाइम की सुविधा वाले SDK टूल को बनाने के लिए, आपको यह तरीका अपनाना होगा:

1. अपने प्रोजेक्ट का स्ट्रक्चर सेट अप करना
2. अपने प्रोजेक्ट और मॉड्यूल की डिपेंडेंसी तैयार करना
3. एसडीके का बिज़नेस लॉजिक जोड़ना
4. एसडीके एपीआई तय करना
5. अपने एसडीके के लिए एंट्री-पॉइंट तय करना

अपने प्रोजेक्ट का स्ट्रक्चर सेट अप करना

हमारा सुझाव है कि आपका प्रोजेक्ट इन मॉड्यूल में व्यवस्थित किया गया हो:

1. ऐप्लिकेशन मॉड्यूल - यह वह टेस्ट ऐप्लिकेशन होता है जिसका इस्तेमाल करके, एसडीके को टेस्ट और डेवलप किया जाता है. यह आपके असली ऐप्लिकेशन क्लाइंट के ऐप्लिकेशन जैसा होता है. आपके ऐप्लिकेशन में, मौजूदा विज्ञापन लाइब्रेरी मॉड्यूल (रनटाइम के साथ काम करने वाला एसडीके) की डिपेंडेंसी होनी चाहिए.
2. विज्ञापन लाइब्रेरी का मौजूदा मॉड्यूल (रनटाइम-अवेयर एसडीके) - यह एक Android लाइब्रेरी मॉड्यूल है. इसमें 'नॉन-रनटाइम-इनेबल' एसडीके का मौजूदा लॉजिक और स्टैटिक तौर पर लिंक किया गया एसडीके शामिल होता है.
   • शुरुआत में, क्षमताओं को अलग-अलग किया जा सकता है. उदाहरण के लिए, कुछ कोड को आपके मौजूदा SDK टूल से मैनेज किया जा सकता है. वहीं, कुछ कोड को रनटाइम के साथ काम करने वाले SDK टूल पर भेजा जा सकता है.
3. रनटाइम के साथ काम करने वाली विज्ञापन लाइब्रेरी मॉड्यूल - इसमें रनटाइम के साथ काम करने वाले SDK टूल का बिज़नेस लॉजिक शामिल होता है. इसे Android Studio में, Android लाइब्रेरी मॉड्यूल के तौर पर बनाया जा सकता है.
4. रनटाइम के साथ काम करने वाला ASB मॉड्यूल - यह पैकेज डेटा तय करता है, ताकि रनटाइम के साथ काम करने वाले एसडीके कोड को ASB में बंडल किया जा सके.
   • इसे com.android.privacy-sandbox-sdk टाइप का इस्तेमाल करके मैन्युअल तरीके से बनाना होगा. इसके लिए, नई डायरेक्ट्री बनाएं.
   • इस मॉड्यूल में कोई कोड नहीं होना चाहिए. इसमें सिर्फ़ एक खाली build.gradle फ़ाइल होनी चाहिए. साथ ही, इसमें रनटाइम के दौरान चालू होने वाली विज्ञापन लाइब्रेरी मॉड्यूल की डिपेंडेंसी होनी चाहिए. इस फ़ाइल का कॉन्टेंट, एसडीके तैयार करना में बताया गया है.
   • इस मॉड्यूल को settings.gradle फ़ाइल और विज्ञापन लाइब्रेरी के मौजूदा मॉड्यूल में शामिल करना न भूलें.

इस गाइड में दिया गया प्रोजेक्ट स्ट्रक्चर सिर्फ़ एक सुझाव है. अपने SDK टूल के लिए कोई दूसरा स्ट्रक्चर चुना जा सकता है. साथ ही, उसी तकनीकी सिद्धांत को लागू किया जा सकता है. ऐप्लिकेशन और लाइब्रेरी मॉड्यूल में कोड को मॉड्यूलर बनाने के लिए, हमेशा अन्य मॉड्यूल बनाए जा सकते हैं.

अपना एसडीके तैयार करना

रनटाइम के साथ काम करने वाले एसडीके को डेवलप करने के लिए, आपको अपने प्रोजेक्ट को तैयार करना होगा. इसके लिए, आपको सबसे पहले कुछ टूलिंग और लाइब्रेरी डिपेंडेंसी तय करनी होंगी:

• SDK Runtime की बैकवर्ड कंपैटिबिलिटी लाइब्रेरी. ये उन डिवाइसों के लिए सहायता उपलब्ध कराती हैं जिनमें Privacy Sandbox (Android 13 और इससे पहले के वर्शन) नहीं है (androidx.privacysandbox.sdkruntime:)
• विज्ञापन दिखाने के लिए यूज़र इंटरफ़ेस (यूआई) लाइब्रेरी (androidx.privacysandbox.ui:)
• एसडीके डेवलपर टूल, एसडीके एपीआई के एलान और शिम जनरेशन (androidx.privacysandbox.tools:) के लिए

1. रनटाइम के साथ काम करने वाले एसडीके बनाने की सुविधा चालू करने के लिए, इस फ़्लैग को अपने प्रोजेक्ट की gradle.properties फ़ाइल में जोड़ें.

   # This enables the Privacy Sandbox for your project on Android Studio.
   android.experimental.privacysandboxsdk.enable=true
   android.experimental.privacysandboxsdk.requireServices=false
   

2. सहायता देने वाली Jetpack लाइब्रेरी और अन्य डिपेंडेंसी शामिल करने के लिए, अपने प्रोजेक्ट की build.gradle फ़ाइल में बदलाव करें:

   // Top-level build file where you can add configuration options common to all sub-projects/modules.
   buildscript {
       ext.kotlin_version = '1.9.10'
       ext.ksp_version = "$kotlin_version-1.0.13"
       ext.privacy_sandbox_activity_version = "1.0.0-alpha01"
       ext.privacy_sandbox_sdk_runtime_version = "1.0.0-alpha13"
       ext.privacy_sandbox_tools_version = "1.0.0-alpha09"
       ext.privacy_sandbox_ui_version = "1.0.0-alpha09"
       repositories {
           mavenCentral()
       }
       dependencies {
           classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
       }
   }
   
   plugins {
       id 'com.android.application' version '8.4.0-alpha13' apply false
       id 'com.android.library' version '8.4.0-alpha13' apply false
   
       // These two plugins do annotation processing and code generation for the sdk-implementation.
       id 'androidx.privacysandbox.library' version '1.0.0-alpha02' apply false
       id 'com.google.devtools.ksp' version "$ksp_version" apply false
   
       id 'org.jetbrains.kotlin.jvm' version '1.9.10' apply false
   }
   
   task clean(type: Delete) {
       delete rootProject.buildDir
   }
   

3. इन डिपेंडेंसी को शामिल करने के लिए, रनटाइम की सुविधा वाली विज्ञापन लाइब्रेरी (आरई एसडीके) मॉड्यूल में build.gradle फ़ाइल को अपडेट करें.

   dependencies {
       // This allows Android Studio to parse and validate your SDK APIs.
       ksp "androidx.privacysandbox.tools:tools-apicompiler:$privacy_sandbox_tools_version"
   
       // This contains the annotation classes to decorate your SDK APIs.
       implementation "androidx.privacysandbox.tools:tools:$privacy_sandbox_tools_version"
   
       // This is runtime dependency required by the generated server shim code for
       // backward compatibility.
       implementation "androidx.privacysandbox.sdkruntime:sdkruntime-provider:$privacy_sandbox_sdk_runtime_version"
   
       // These are runtime dependencies required by the generated server shim code as
       // they use Kotlin.
       implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1"
       implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1'
   
       // This is the core part of the UI library to help with UI notifications.
       implementation "androidx.privacysandbox.ui:ui-core:$privacy_sandbox_ui_version"
   
       // This helps the SDK open sessions for the ad.
       implementation "androidx.privacysandbox.ui:ui-provider:$privacy_sandbox_ui_version"
   
       // This is needed if your SDK implements mediation use cases
       implementation "androidx.privacysandbox.ui:ui-client:$privacy_sandbox_ui_version"
   }
   

4. अपनी रंटाइम के दौरान चालू किए जा सकने वाले ASB मॉड्यूल में मौजूद build.gradle फ़ाइल को इससे बदलें:

   plugins {
       id 'com.android.privacy-sandbox-sdk'
   }
   
   android {
       compileSdk 34
       minSdk 21
   
       bundle {
           // This is the package name of the SDK that you want to publish.
           // This is used as the public identifier of your SDK.
           // You use this later on to load the runtime-enabled SDK
           packageName = '<package name of your runtime-enabled SDK>'
   
           // This is the version of the SDK that you want to publish.
           // This is used as the public identifier of your SDK version.
           setVersion(1, 0, 0)
   
           // SDK provider defined in the SDK Runtime library.
           // This is an important part of the future backwards compatibility
           // support, most SDKs won't need to change it.
           sdkProviderClassName = "androidx.privacysandbox.sdkruntime.provider.SandboxedSdkProviderAdapter"
   
           // This is the class path of your implementation of the SandboxedSdkProviderCompat class.
           // It's the implementation of your runtime-enabled SDK's entry-point.
           // If you miss this step, your runtime-enabled SDK will fail to load at runtime:
           compatSdkProviderClassName = "<your-sandboxed-sdk-provider-compat-fully-qualified-class-name>"
       }
   }
   
   dependencies {
       // This declares the dependency on your runtime-enabled ad library module.
       include project(':<your-runtime-enabled-ad-library-here>')
   }
   

5. नीचे दी गई डिपेंडेंसी को शामिल करने के लिए, अपनी मौजूदा विज्ञापन लाइब्रेरी (RA SDK) मॉड्यूल में build.gradle फ़ाइल को अपडेट करें:

   dependencies {
       // This declares the client's dependency on the runtime-enabled ASB module.
       //  ⚠️ Important: We depend on the ASB module, not the runtime-enabled module.
       implementation project(':<your-runtime-enabled-asb-module-here>')
   
       // Required for backwards compatibility on devices where SDK Runtime is unavailable.
       implementation "androidx.privacysandbox.sdkruntime:sdkruntime-client:$privacy_sandbox_sdk_runtime_version"
   
       // This is required to display banner ads using the SandboxedUiAdapter interface.
       implementation "androidx.privacysandbox.ui:ui-core:$privacy_sandbox_ui_version"
       implementation "androidx.privacysandbox.ui:ui-client:$privacy_sandbox_ui_version"
   
       // This is required to use SDK ActivityLaunchers.
       implementation "androidx.privacysandbox.activity:activity-core:$privacy_sandbox_activity_version"
       implementation "androidx.privacysandbox.activity:activity-client:$privacy_sandbox_activity_version"
   }
   

SDK टूल में कारोबारी नियम जोड़ना

अपने SDK टूल के कारोबार के लॉजिक को लागू करें. इसे रनटाइम के साथ काम करने वाली विज्ञापन लाइब्रेरी मॉड्यूल में नियमित तौर पर लागू किया जाता है.

अगर आपको किसी मौजूदा SDK को माइग्रेट करना है, तो इस चरण में अपने कारोबार के लॉजिक, इंटरफ़ेस, और सिस्टम से जुड़े फ़ंक्शन को अपनी ज़रूरत के हिसाब से माइग्रेट करें. हालांकि, आने वाले समय में पूरे SDK को माइग्रेट करने की योजना बनाएं.

अगर आपको स्टोरेज, Google Play का विज्ञापन आईडी या ऐप्लिकेशन सेट आईडी का ऐक्सेस चाहिए, तो यहां दिए गए सेक्शन पढ़ें:

class SdkServiceImpl(private val context: Context) : SdkService {
    override suspend fun getMessage(): String = "Hello from Privacy Sandbox!"

    override suspend fun createFile(sizeInMb: Int): String {
        val path = Paths.get(
            context.dataDir.path, "file.txt"
        )

        withContext(Dispatchers.IO) {
            Files.deleteIfExists(path)
            Files.createFile(path)
            val buffer = ByteArray(sizeInMb * 1024 * 1024)
            Files.write(path, buffer)
        }

        val file = File(path.toString())
        val actualFileSize: Long = file.length() / (1024 * 1024)
        return "Created $actualFileSize MB file successfully"
    }
}

एसडीके एपीआई के बारे में जानकारी देना

अगर आपको रनटाइम के बाहर भी रनटाइम की सुविधा वाले एसडीके को ऐक्सेस करना है, तो आपको ऐसे एपीआई तय करने होंगे जिनका इस्तेमाल क्लाइंट (आरए एसडीके या क्लाइंट ऐप्लिकेशन) कर सकते हैं.

इन इंटरफ़ेस का एलान करने के लिए, एनोटेशन का इस्तेमाल करें.

एनोटेशन

एसडीके एपीआई को Kotlin में इंटरफ़ेस और डेटा क्लास के तौर पर घोषित किया जाना चाहिए. इसके लिए, इन एनोटेशन का इस्तेमाल करें:

आपको इन इंटरफ़ेस और क्लास को, रनटाइम के साथ काम करने वाली विज्ञापन लाइब्रेरी मॉड्यूल में कहीं भी तय करना होगा.

इन एनोटेशन के इस्तेमाल के बारे में यहां जानें.

@PrivacySandboxService
interface SdkService {
    suspend fun getMessage(): String

    suspend fun createFile(sizeInMb: Int): String

    suspend fun getBanner(request: SdkBannerRequest, requestMediatedAd: Boolean): SdkSandboxedUiAdapter?

    suspend fun getFullscreenAd(): FullscreenAd
}

@PrivacySandboxInterface
interface SdkSandboxedUiAdapter : SandboxedUiAdapter

@PrivacySandboxValue
data class SdkBannerRequest(
    /** The package name of the app. */
    val appPackageName: String,
    /**
     *  An [SdkActivityLauncher] used to launch an activity when the banner is clicked.
     */
    val activityLauncher: SdkActivityLauncher,
    /**
     * Denotes if a WebView banner ad needs to be loaded.
     */
    val isWebViewBannerAd: Boolean
)

@PrivacySandboxCallback
interface InAppMediateeSdkInterface {
    suspend fun show()
}

इस तरह के कोड काम करते हैं

रनटाइम के साथ काम करने वाले एसडीके के एपीआई, इन टाइप के साथ काम करते हैं:

• Java प्रोग्रामिंग लैंग्वेज में मौजूद सभी प्रिमिटिव टाइप (जैसे, int, long, char, boolean वगैरह)
• स्ट्रिंग
• @PrivacySandboxInterface या @PrivacySandboxCallback के साथ एनोटेट किए गए Kotlin इंटरफ़ेस
• @PrivacySandboxValue के साथ एनोटेट की गई Kotlin की डेटा क्लास
• java.lang.List - List में मौजूद सभी एलिमेंट, इस्तेमाल किए जा सकने वाले डेटा टाइप में से किसी एक टाइप के होने चाहिए

कुछ और चेतावनियां भी हैं:

• @PrivacySandboxValue के साथ एनोटेट की गई डेटा क्लास में, @PrivacySandboxCallback टाइप के फ़ील्ड नहीं हो सकते
• @PrivacySandboxCallback के साथ एनोटेट किए गए टाइप, रिटर्न टाइप में शामिल नहीं किए जा सकते
• सूची में, @PrivacySandboxInterface या @PrivacySandboxCallback के साथ एनोटेट किए गए टाइप के एलिमेंट शामिल नहीं किए जा सकते

एसिंक्रोनस एपीआई

एसडीके एपीआई हमेशा किसी अलग प्रोसेस को कॉल करते हैं. इसलिए, हमें यह पक्का करना होगा कि ये कॉल, क्लाइंट की कॉलिंग थ्रेड को ब्लॉक न करें.

इसके लिए, @PrivacySandboxService, @PrivacySandboxInterface, और @PrivacySandboxCallback के साथ एनोटेट किए गए इंटरफ़ेस के सभी तरीकों को एसिंक्रोनस एपीआई के तौर पर साफ़ तौर पर एलान करना होगा.

Kotlin में एसिंक्रोनस एपीआई को दो तरीकों से लागू किया जा सकता है:

1. सस्पेंड फ़ंक्शन का इस्तेमाल करें.
2. ऐसे कॉलबैक स्वीकार करें जो ऑपरेशन पूरा होने पर सूचना देते हैं. इसके अलावा, ऑपरेशन की प्रोसेस के दौरान होने वाली अन्य घटनाओं की सूचना भी देते हैं. फ़ंक्शन का रिटर्न टाइप, यूनिट होना चाहिए.

अपवाद

SDK के एपीआई, किसी भी तरह के चेक किए गए अपवादों के साथ काम नहीं करते.

जनरेट किया गया शिम कोड, SDK टूल से मिले किसी भी रनटाइम अपवाद को पकड़ लेता है. साथ ही, उन्हें क्लाइंट को PrivacySandboxException के तौर पर भेज देता है. इसमें अपवाद की वजह के बारे में जानकारी शामिल होती है.

यूज़र इंटरफ़ेस (यूआई) लाइब्रेरी

अगर आपके पास ऐसे इंटरफ़ेस हैं जो विज्ञापन दिखाते हैं, जैसे कि बैनर, तो आपको SandboxedUiAdapter इंटरफ़ेस भी लागू करना होगा. इससे लोड किए गए विज्ञापन के लिए सेशन खोलने की सुविधा चालू की जा सकेगी.

ये सेशन, क्लाइंट और एसडीके के बीच एक साइड चैनल बनाते हैं. साथ ही, ये दो मुख्य मकसद पूरे करते हैं:

• यूज़र इंटरफ़ेस (यूआई) में बदलाव होने पर सूचनाएं पाएं.
• क्लाइंट को यूज़र इंटरफ़ेस (यूआई) में हुए किसी भी बदलाव के बारे में सूचना दें.

क्लाइंट, @PrivacySandboxService के साथ एनोटेट किए गए इंटरफ़ेस का इस्तेमाल करके आपके एसडीके से कम्यूनिकेट कर सकता है. इसलिए, विज्ञापन लोड करने के लिए किसी भी एपीआई को इस इंटरफ़ेस में जोड़ा जा सकता है.

जब क्लाइंट, विज्ञापन लोड करने का अनुरोध करता है, तो विज्ञापन लोड करें और SandboxedUiAdapter को लागू करने वाले इंटरफ़ेस का इंस्टेंस दिखाएं. इससे क्लाइंट, उस विज्ञापन के लिए सेशन खोलने का अनुरोध कर सकता है.

जब क्लाइंट किसी सेशन को खोलने का अनुरोध करता है, तब रनटाइम की सुविधा वाला एसडीके, विज्ञापन के जवाब और दिए गए कॉन्टेक्स्ट का इस्तेमाल करके विज्ञापन व्यू बना सकता है.

इसके लिए, SandboxedUiAdapter.Session इंटरफ़ेस लागू करने वाली क्लास बनाएं. साथ ही, जब SandboxedUiAdapter.openSession() को कॉल किया जाए, तब यह पक्का करें कि आपने client.onSessionOpened() को कॉल किया हो. इसके लिए, Session क्लास के इंस्टेंस को पैरामीटर के तौर पर पास करें.

class SdkSandboxedUiAdapterImpl(
   private val sdkContext: Context,
   private val request: SdkBannerRequest,
) : SdkSandboxedUiAdapter {
   override fun openSession(
       context: Context,
       windowInputToken: IBinder,
       initialWidth: Int,
       initialHeight: Int,
       isZOrderOnTop: Boolean,
       clientExecutor: Executor,
       client: SandboxedUiAdapter.SessionClient
   ) {
       val session = SdkUiSession(clientExecutor, sdkContext, request)
       clientExecutor.execute {
           client.onSessionOpened(session)
       }
   }
}

यूज़र इंटरफ़ेस (यूआई) में बदलाव होने पर, इस क्लास को भी सूचनाएं मिलती हैं. इस क्लास का इस्तेमाल, विज्ञापन का साइज़ बदलने के लिए किया जा सकता है. इसके अलावा, यह जानने के लिए भी इसका इस्तेमाल किया जा सकता है कि कॉन्फ़िगरेशन में कब बदलाव हुआ.

Runtime में यूज़र इंटरफ़ेस (यूआई) प्रज़ेंटेशन एपीआई के बारे में ज़्यादा जानें.

गतिविधि से जुड़ी सहायता

Privacy Sandbox से एसडीके के मालिकाना हक वाली गतिविधियां शुरू करने के लिए, आपको एसडीके एपीआई में बदलाव करना होगा, ताकि आपको SdkActivityLauncher ऑब्जेक्ट मिल सके. यह ऑब्जेक्ट, यूज़र इंटरफ़ेस (यूआई) लाइब्रेरी भी उपलब्ध कराती है.

उदाहरण के लिए, यहां दिया गया SDK API, गतिविधियों को लॉन्च करता है. इसलिए, यह SdkActivityLauncher पैरामीटर का इस्तेमाल करता है:

@PrivacySandboxInterface
interface FullscreenAd {
    suspend fun show(activityLauncher: SdkActivityLauncher)
}

एसडीके एंट्री-पॉइंट

ऐब्स्ट्रैक्ट क्लास SandboxedSdkProvider, उस एपीआई को इनकैप्सुलेट करता है जिसका इस्तेमाल SDK टूल का रनटाइम, उसमें लोड किए गए एसडीके टूल के साथ इंटरैक्ट करने के लिए करता है.

रनटाइम के साथ काम करने वाले एसडीके को इस ऐब्स्ट्रैक्ट क्लास को लागू करना होगा, ताकि एसडीके रनटाइम के लिए एंट्री पॉइंट जनरेट किया जा सके. इससे एसडीके रनटाइम, एसडीके से कम्यूनिकेट कर पाएगा.

पुराने सिस्टम के साथ काम करने की सुविधा के लिए, हमने ये क्लास लॉन्च की हैं:

• SandboxedSdkProviderAdapter, जो SandboxedSdkProvider को बढ़ाता है और एसडीके रनटाइम की उपलब्धता के बावजूद, एसडीके लोड करने के अनुरोधों को मैनेज करता है. इसका इस्तेमाल इंटरनल तौर पर किया जाता है. इसे ASB मॉड्यूल में तय किया जाता है.
• SandboxedSdkProviderCompat, एक ऐब्स्ट्रैक्ट क्लास है. यह SandboxedSdkProvider के इंटरफ़ेस की तरह काम करती है.

SDK Runtime के लिए, पुराने सिस्टम के साथ काम करने की सुविधा के बारे में ज़्यादा जानें.

शिम जनरेट करने वाले टूल, ऐब्स्ट्रैक्शन की एक और लेयर जोड़ते हैं: ये @PrivacySandboxService एनोटेशन वाले इंटरफ़ेस का इस्तेमाल करके, AbstractSandboxedSdkProvider नाम की एक ऐब्स्ट्रैक्ट क्लास जनरेट करते हैं.

यह क्लास SandboxedSdkProviderCompat को एक्सटेंड करती है और उसी पैकेज के तहत आती है जिसमें आपका एनोटेट किया गया इंटरफ़ेस है.

// Auto-generated code.
abstract class AbstractSandboxedSdkProvider : SandboxedSdkProviderCompat {
    abstract fun createMySdk(context: Context): MySdk
}

जनरेट की गई यह क्लास, एक ऐब्सट्रैक्ट फ़ैक्ट्री मेथड को दिखाती है. यह Context को इनपुट के तौर पर लेता है और एनोटेट किए गए आपके एंट्री-पॉइंट इंटरफ़ेस को वापस पाने की उम्मीद करता है.

इस तरीके का नाम आपके @PrivacySandboxService इंटरफ़ेस के नाम पर रखा गया है. इसके नाम से पहले create जोड़ा गया है. उदाहरण के लिए, अगर आपके इंटरफ़ेस का नाम MySdk है, तो टूल createMySdk जनरेट करते हैं.

अपने एंट्री पॉइंट को पूरी तरह से कनेक्ट करने के लिए, आपको जनरेट किए गए AbstractSandboxedSdkProvider में, रनटाइम के साथ काम करने वाले एसडीके में मौजूद @PrivacySandboxService एनोटेट किए गए इंटरफ़ेस को लागू करना होगा.

class MySdkSandboxedSdkProvider : AbstractSandboxedSdkProvider() {
    override fun createMySdk(context: Context): MySdk = MySdkImpl(context)
}

ASB मॉड्यूल में हुए बदलाव

आपको ASB मॉड्यूल की build.gradle फ़ाइल के compatSdkProviderClassName फ़ील्ड में, SandboxedSdkProviderCompat को लागू करने के लिए पूरी तरह क्वालिफ़ाइड क्लास का नाम बताना होगा.

यह वही क्लास है जिसे आपने पिछले चरण में लागू किया था. आपको अपने ASB मॉड्यूल पर build.gradle में इस तरह बदलाव करना होगा:

bundle {
    packageName = '<package name of your runtime-enabled SDK>'
    setVersion(1, 0, 0)

    // SDK provider defined in the SDK Runtime library.
    sdkProviderClassName = "androidx.privacysandbox.sdkruntime.provider.SandboxedSdkProviderAdapter"
    // This is the class that extends AbstractSandboxedSdkProvider,
    // MySdkSandboxProvider as per the example provided.
    compatSdkProviderClassName = "com.example.mysdk.MySdkSandboxProvider"
}

arrow_back_iosदूसरा चरण: डेवलपमेंट एनवायरमेंट सेट अप करना चौथा चरण: रनटाइम के दौरान चालू होने वाले एसडीके का इस्तेमाल करनाarrow_forward_ios