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

रनटाइम की सुविधा वाले एसडीके टूल का इस्तेमाल करना

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

इस गाइड में, हम आपके मौजूदा एसडीके मॉड्यूल (या रनटाइम-अवेयर एसडीके) को क्लाइंट के तौर पर देखते हैं.

अगर आपको रनटाइम के साथ काम करने वाले SDK टूल को सीधे तौर पर अपने ऐप्लिकेशन में इस्तेमाल करना है, तो ऐप्लिकेशन मॉड्यूल क्लाइंट होता है.

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

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

SdkSandboxManager क्लास, रनटाइम के साथ काम करने वाले एसडीके लोड करने में मदद करती है. साथ ही, यह IBinder क्लास दिखाती है. इस क्लास को रनटाइम के साथ काम करने वाला एसडीके, रनटाइम के साथ काम करने वाले एसडीके में तय किए गए इंटरफ़ेस से बाइंड कर सकता है.

आपको यह पक्का करना होगा कि आपने हर रनटाइम-इनेबल किए गए एसडीके को सिर्फ़ एक बार लोड किया हो. ऐसा न करने पर, एसडीके मैनेजर एक अपवाद दिखाएगा.

शिम जनरेशन टूल, हेल्पर क्लास जनरेट करते हैं. इनकी मदद से, SdkSandboxManager से मिले IBinder इंटरफ़ेस को, एसडीके एपीआई इंटरफ़ेस में वापस बदला जा सकता है.

ये टूल, @PrivacySandboxService के साथ एनोटेट किए गए इंटरफ़ेस का इस्तेमाल करके, *Factory क्लास जनरेट करते हैं.

इस क्लास में एक स्टैटिक wrapTo* फ़ंक्शन होता है, जो IBinder ऑब्जेक्ट को, आपके रनटाइम-इनेबल किए गए SDK टूल के इंटरफ़ेस के इंस्टेंस में बदलता है.

आपका रनटाइम-अवेयर एसडीके, इस इंटरफ़ेस का इस्तेमाल करके रनटाइम-इनेबल किए गए एसडीके से कम्यूनिकेट कर सकता है. साथ ही, पिछले चरण में आपने जिन एसडीके एपीआई का एलान किया था उन्हें लागू कर सकता है.

// Name of the SDK to be loaded, defined in your ASB module
private const val SDK_NAME = "com.example.sdk"

try {
    // SdkSandboxManagerCompat is used to communicate with the sandbox and load SDKs with backward compatibility.
    val sandboxManagerCompat = SdkSandboxManagerCompat.from(context)
    val sandboxedSdk = sandboxManagerCompat.loadSdk(SDK_NAME, Bundle.EMPTY)
    val mySdk = MySdkFactory.wrapToMySdk(sandboxedSdk.getInterface()!!)
} catch (e: LoadSdkCompatException) {
    Log.e(TAG, "Failed to load SDK, error code: ${e.loadSdkErrorCode}", e)
    return null
}

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

अगर आपको विज्ञापन दिखाने के लिए यूज़र इंटरफ़ेस (यूआई) लाइब्रेरी का इस्तेमाल करना है, तो पक्का करें कि आपने रनटाइम के बारे में जानकारी रखने वाले एसडीके के build.gradle में, डिपेंडेंसी के तौर पर androidx.privacysandbox.ui:ui-core और androidx.privacysandbox.ui:ui-client को जोड़ा हो.

SandboxedSdkView का इस्तेमाल करके बैनर विज्ञापन लोड करना

androidx.privacysandbox.ui:ui-client ने एक नया ViewGroup लॉन्च किया है. इसका नाम SandboxedSdkView है. यह रनटाइम के साथ काम करने वाले एसडीके से बनाए गए यूज़र इंटरफ़ेस (यूआई) को होस्ट करता है.

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

इसे इस तरह इंटिग्रेट किया जा सकता है:

class BannerAd(context: Context, attrs: AttributeSet) : LinearLayout(context, attrs) {
    suspend fun loadAd() {
        // mySdk is the previously loaded SDK in the SDK Runtime.
        val bannerAd = mySdk.loadAd()
        val sandboxedSdkView = SandboxedSdkView(context)
        addViewToLayout(sandboxedSdkView)

        // This renders the ad.
        sandboxedSdkView.setAdapter(bannerAd)
        return
    }
    private fun addViewToLayout(view: View) {
        view.layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
        super.addView(view)
    }
}

यूज़र इंटरफ़ेस (यूआई) दिखाने के लिए, सेशन की स्थिति में बदलाव होने पर, रनटाइम के बारे में जानकारी रखने वाले SDK टूल को भी सूचना मिल सकती है. ऐसा करने के लिए:

1. अलग-अलग स्थितियों को मैनेज करने के लिए, SessionStateChangeListener() क्लास बनाएं:

   private class SessionStateChangeListener() : SandboxedSdkUiSessionStateChangedListener {
       override fun onStateChanged(state: SandboxedSdkUiSessionState) {
           if (state is SandboxedSdkUiSessionState.Error) {
           // Some error has occurred while opening the session. Handle
           // accordingly.
           Log.e(TAG, state.throwable.message!!);
           } else if (state is SandboxedSdkUiSessionState.Loading) {
               // The session is attempting to be opened.
           } else if (state is SandboxedSdkUiSessionState.Active) {
               // The session is open and the UI presentation was successful.
           } else if (state is SandboxedSdkUiSessionState.Idle) {
               // There is no open session.
           }
       }
   }
   

2. आपने पहले जिस SandboxedSdkView को इंस्टैंशिएट किया था उसमें स्थिति में होने वाले बदलावों को सुनने वाला एक लिसनर जोड़ें. व्यू से अटैच होते ही, लिसनर को मौजूदा स्थिति के बारे में तुरंत सूचना दी जाती है.

निम्न पर ध्यान दें:

• अगर सेशन के पूरी तरह से खुलने से पहले ही, रनटाइम के बारे में जानकारी रखने वाला SDK, SandboxedSdkView के तरीकों को कॉल करता है, तो सेशन के पूरी तरह से खुलने के बाद सभी इफ़ेक्ट लागू होंगे.
  • SandboxedSdkView.orderProviderUiAboveClientUi(providerUiOnTop) जैसे तरीके
• SandboxedSdkView से व्यू जोड़ने या हटाने वाले कॉलिंग के तरीके (जैसे कि addView(), removeView(), removeViewAt() वगैरह) काम नहीं करते. इससे UnsupportedOperationException दिखता है.
  • विज्ञापन दिखाने के लिए, सिर्फ़ setAdapter() का इस्तेमाल करें.
• SandboxedSdkView.orderProviderUiAboveClientUi(providerUiOnTop), Z-ऑर्डरिंग को टॉगल करता है. इससे यह तय होता है कि उपयोगकर्ता के इंटरैक्शन से मिले MotionEvents को रनटाइम के साथ काम करने वाले एसडीके या रनटाइम के बारे में जानकारी रखने वाले एसडीके को भेजा जाए या नहीं.
  • अगर इसे false पर सेट किया जाता है, तो MotionEvents को रनटाइम के साथ काम करने वाले एसडीके पर भेजा जाता है. ऐसा न होने पर, इन्हें रनटाइम के साथ काम करने वाले एसडीके पर भेजा जाएगा. यूज़र इंटरफ़ेस (यूआई) प्रज़ेंटेशन एपीआई का इस्तेमाल करके, Z-ऑर्डरिंग के बारे में ज़्यादा जानें.

गतिविधियां शुरू करना

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

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

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

val launchSdkActivityPredicate = {
    // Boolean which has to be true to launch the activities
    }
val launcher = baseActivity.createSdkActivityLauncher(launchSdkActivityPredicate)
fullscreenService.showActivity(launcher)

रनटाइम के साथ काम करने वाले एसडीके में, SdkSandboxActivityHandlerCompat को रजिस्टर करें और इसे SdkActivityLauncher.LaunchSdkActivity(IBinder) को उपलब्ध कराएं.

fun showActivity(activityLauncher: SdkActivityLauncher) {
    val handler = object : SdkSandboxActivityHandlerCompat {
        override fun onActivityCreated(activityHolder: ActivityHolder) {
            activityHolder.getActivity().setContentView(contentView)
        }
    }

    val token = controller.registerSdkSandboxActivityHandler(handler)
    activityLauncher.launchSdkActivity(token)
}

ActivityHolder को ActivityHolder पास किया जाता है, जो LifecycleOwner लागू करता है. इससे रनटाइम के साथ काम करने वाले SDK टूल को ऐक्टिविटी के लाइफ़साइकल का ऐक्सेस मिलता है.SdkSandboxActivityHandlerCompat.onActivityCreated(ActivityHolder)

यह getOnBackPressedDispatcher एपीआई भी उपलब्ध कराता है. इसका इस्तेमाल, getOnBackPressedCallback इंस्टेंस को रजिस्टर करने के लिए किया जा सकता है, ताकि गतिविधि में वापस जाने वाले बटन के व्यवहार को मैनेज किया जा सके.

arrow_back_iosतीसरा चरण: रनटाइम के साथ काम करने वाला एसडीके बनाना पांचवां चरण: डिस्ट्रिब्यूशन के लिए टेस्टिंग और एसडीके बनानाarrow_forward_ios