इस पेज का अनुवाद Cloud Translation API से किया गया है.

SDK टूल का रनटाइम डेवलपर की गाइड

Android पर प्राइवसी सैंडबॉक्स के इस्तेमाल से जुड़ी जानकारी दस्तावेज़ का इस्तेमाल करने के लिए, डेवलपर झलक या बीटा बटन का इस्तेमाल करें प्रोग्राम का वर्शन सही है या नहीं, क्योंकि इसके निर्देश अलग-अलग हो सकते हैं.

सुझाव या राय देना

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

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

सीमाएं

SDK टूल के रनटाइम की जिन सुविधाओं पर काम किया जा रहा है उनकी सूची देखने के लिए, रिलीज़ देखें नोट.

अगले मुख्य Android ऐप्लिकेशन में, ये सीमाएं ठीक हो सकती हैं. प्लैटफ़ॉर्म रिलीज़ किया गया.

स्क्रोल किए जा सकने वाले व्यू में विज्ञापन रेंडरिंग. उदाहरण के लिए, RecyclerView यह काम नहीं करता काम ठीक से होता है.
- साइज़ बदलने पर जैंक होने की समस्या आ सकती है.
- उपयोगकर्ता के टच स्क्रोल इवेंट को रनटाइम में ठीक से पास नहीं किया जाता.
स्टोरेज एपीआई
- हर एसडीके के हिसाब से स्टोरेज, Android 13 में उपलब्ध नहीं है.

यह समस्या 2023 में ठीक कर दी जाएगी:

getAdId और getAppSetId एपीआई अब तक पूरी तरह से काम नहीं करते हैं. जिन्हें अभी चालू नहीं किया गया है.

शुरू करने से पहले

शुरू करने से पहले, नीचे दिया गया तरीका अपनाएं:

Android पर प्राइवसी सैंडबॉक्स के लिए, अपना डेवलपमेंट एनवायरमेंट सेट अप करें. SDK टूल के रनटाइम के साथ काम करने वाले टूल पर अभी काम चल रहा है. इसलिए, यह गाइड के लिए आपको Android का नया कैनरी वर्शन Studio. आप Android Studio के इस वर्शन को Android Studio के इस वर्शन के साथ का इस्तेमाल करते हैं, तो कृपया हमें बताएं कि इस ज़रूरी शर्त को पूरा करने के लिए मदद मिलती है.

ध्यान दें: अगर आपने बिना Play Store वाला कोई डिवाइस चुना है, तो TiramisuPrivacySandbox इमेज विकल्प के तौर पर नहीं दिखेगी.
ऐसे डिवाइस पर सिस्टम इमेज इंस्टॉल करें जिस पर यह सुविधा काम करती है या किसी ऐसे डिवाइस पर सिस्टम इमेज इंस्टॉल करें एम्युलेटर, जिसमें Android पर प्राइवसी सैंडबॉक्स के साथ काम करने की सुविधा शामिल है.

Android Studio में अपना प्रोजेक्ट सेट अप करना

SDK टूल का रनटाइम आज़माने के लिए, ऐसे मॉडल का इस्तेमाल करें जो क्लाइंट-सर्वर मॉडल. मुख्य अंतर यह है कि ऐप्लिकेशन ( क्लाइंट) और SDK ("सर्वर") एक ही डिवाइस पर चलते हैं.

अपने प्रोजेक्ट में कोई ऐप्लिकेशन मॉड्यूल जोड़ें. यह मॉड्यूल उस क्लाइंट के तौर पर काम करता है जो SDK टूल ड्राइव करता है. अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
अपने ऐप्लिकेशन मॉड्यूल में, SDK टूल का रनटाइम चालू करें, ज़रूरी अनुमतियों का एलान करना और एपीआई से जुड़ी खास विज्ञापन सेवाओं को कॉन्फ़िगर करें.
अपने प्रोजेक्ट में एक लाइब्रेरी मॉड्यूल जोड़ें. इस मॉड्यूल में आपका SDK कोड शामिल है.
अपने SDK टूल मॉड्यूल में, ज़रूरी अनुमतियों का एलान करें. आपको ये काम करने की ज़रूरत नहीं है इस मॉड्यूल में API-विशिष्ट विज्ञापन सेवाओं को कॉन्फ़िगर करें.
अपने लाइब्रेरी मॉड्यूल की build.gradle फ़ाइल से उस dependencies को हटाएं आपका SDK टूल इस्तेमाल नहीं करता. ज़्यादातर मामलों में, सभी डिपेंडेंसी हटाई जा सकती हैं. आपने लोगों तक पहुंचाया मुफ़्त में ऐसा करने के लिए, एक नई डायरेक्ट्री बनानी होगी जिसका नाम आपके SDK टूल से मेल खाता हो.
com.android.privacy-sandbox-sdk का इस्तेमाल करके, मैन्युअल तरीके से एक नया मॉड्यूल बनाएं टाइप करें. इसे SDK कोड के साथ बंडल किया जाता है, ताकि ऐसा APK बनाया जा सके जिसे आपके डिवाइस पर डिप्लॉय किया गया है. आप एक नई डायरेक्ट्री बनाकर यह काम कर सकते हैं, जिसकी नाम आपके SDK टूल से मेल खाता हो. एक खाली build.gradle फ़ाइल जोड़ें. कॉन्टेंट इस गाइड में बाद में इस फ़ाइल की जानकारी अपने-आप भर जाएगी.
अपनी gradle.properties फ़ाइल में यह स्निपेट जोड़ें:
```
android.experimental.privacysandboxsdk.enable=true
```
TiramisuPrivacySandbox एम्युलेटर इमेज को डाउनलोड करें और एम्युलेटर की इमेज मौजूद है, जिसमें Play Store भी शामिल है.

आप SDK डेवलपर हैं या ऐप्लिकेशन डेवलपर, इसके आधार पर आपके पास यह पिछले पैराग्राफ़ में बताए गए सेटअप से अलग है.

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

किसी टेस्ट डिवाइस पर, SDK टूल को उसी तरह इंस्टॉल करें जैसे किसी ऐप्लिकेशन को इंस्टॉल करने के लिए इस्तेमाल किया जाता है. या तो Android Studio या Android डीबग ब्रिज (ADB) पर जाएं. अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है शुरू करने में आपकी मदद करने के लिए, हमने Kotlin और Java में सैंपल ऐप्लिकेशन बनाए हैं प्रोग्रामिंग भाषाएँ, जो GitHub का डेटा स्टोर करने की जगह. README और मेनिफ़ेस्ट फ़ाइलों में ऐसी टिप्पणियां जिनसे यह पता चलता है कि स्टेबल वर्शन में सैंपल चलाने के लिए, क्या बदलाव करने होंगे Android Studio में भी उपलब्ध हैं.

अपना SDK टूल तैयार करना

मैन्युअल तरीके से मॉड्यूल-लेवल की डायरेक्ट्री बनाएं. यह एक रैपर के रूप में काम करता है SDK APK बनाने के लिए, लागू किया जाने वाला आपका कोड. नई डायरेक्ट्री में, build.gradle फ़ाइल में सेव करें और इसे नीचे दिए गए स्निपेट से भरें. किसी यूनीक प्रॉडक्ट या सेवा के विज्ञापन दिखाने के लिए, रनटाइम के साथ काम करने वाले आपके SDK टूल (RE-SDK) का नाम डालें और उसका वर्शन दें. शामिल करें dependencies सेक्शन में अपने लाइब्रेरी मॉड्यूल को जोड़ें.
```
plugins {
    id 'com.android.privacy-sandbox-sdk'
}

android {
    compileSdkPreview 'TiramisuPrivacySandbox'
    minSdkPreview 'TiramisuPrivacySandbox'
    namespace = "com.example.example-sdk"

    bundle {
        packageName = "com.example.privacysandbox.provider"
        sdkProviderClassName = "com.example.sdk_implementation.SdkProviderImpl"
        setVersion(1, 0, 0)
    }
}

dependencies {
    include project(':<your-library-here>')
}
```
लागू करने की लाइब्रेरी में एक क्लास बनाएं, ताकि वह एंट्री पॉइंट के तौर पर काम कर सके आपका SDK टूल. क्लास का नाम sdkProviderClassName और SandboxedSdkProvider की अवधि बढ़ाएं.

आपके SDK टूल के लिए, एंट्री पॉइंट SandboxedSdkProvider को बड़ा कर दिया गया है. कॉन्टेंट बनाने SandboxedSdkProvider में आपके SDK टूल के लिए, Context ऑब्जेक्ट मौजूद है. आपके पास यह करने का विकल्प है getContext() पर कॉल करके ऐक्सेस करें. इस संदर्भ को सिर्फ़ एक बार ऐक्सेस किया जाना चाहिए onLoadSdk() शुरू हो गया है.

SDK टूल के ऐप्लिकेशन को कंपाइल करने के लिए, आपको SDK टूल को मैनेज करने के तरीकों को बदलना होगा लाइफ़साइकल:

onLoadSdk()

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

उदाहरण के तौर पर AIDL का इस्तेमाल करके, प्रज़ेंट करने के लिए आपको एआईडीएल फ़ाइल तय करनी होगी आपका IBinder जिसे ऐप्लिकेशन शेयर और इस्तेमाल करेगा:

// ISdkInterface.aidl
interface ISdkInterface {
    // the public functions to share with the App.
    int doSomething();
}

getView()

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

नीचे दिया गया कोड स्निपेट, इन तरीकों को बदलने का तरीका बताता है:

Kotlin

class SdkProviderImpl : SandboxedSdkProvider() {
    override fun onLoadSdk(params: Bundle?): SandboxedSdk {
        // Returns a SandboxedSdk, passed back to the client. The IBinder used
        // to create the SandboxedSdk object is used by the app to call into the
        // SDK.
        return SandboxedSdk(SdkInterfaceProxy())
    }

    override fun getView(windowContext: Context, bundle: Bundle, width: Int,
            height: Int): View {
        val webView = WebView(windowContext)
        val layoutParams = LinearLayout.LayoutParams(width, height)
        webView.setLayoutParams(layoutParams)
        webView.loadUrl("https://developer.android.com/privacy-sandbox")
        return webView
    }

    private class SdkInterfaceProxy : ISdkInterface.Stub() {
        fun doSomething() {
            // Implementation of the API.
        }
    }
}

Java

public class SdkProviderImpl extends SandboxedSdkProvider {
    @Override
    public SandboxedSdk onLoadSdk(Bundle params) {
        // Returns a SandboxedSdk, passed back to the client. The IBinder used
        // to create the SandboxedSdk object is used by the app to call into the
        // SDK.
        return new SandboxedSdk(new SdkInterfaceProxy());
    }

    @Override
    public View getView(Context windowContext, Bundle bundle, int width,
            int height) {
        WebView webView = new WebView(windowContext);
        LinearLayout.LayoutParams layoutParams =
                new LinearLayout.LayoutParams(width, height);
        webView.setLayoutParams(layoutParams);
        webView.loadUrl("https://developer.android.com/privacy-sandbox");
        return webView;
    }

    private static class SdkInterfaceProxy extends ISdkInterface.Stub {
        @Override
        public void doSomething() {
            // Implementation of the API.
        }
    }
}

एसडीकेसैंडबॉक्सकंट्रोल

SdkSandboxController संदर्भ के हिसाब से सिस्टम सर्विस रैपर उपलब्ध है इस्तेमाल करना है. SDK टूल से इसे फ़ेच करने के लिए, इनसे मिले कॉन्टेक्स्ट का इस्तेमाल किया जा सकता है SandboxedSdkProvider#getContext() और शुरू किया जा रहा है इस संदर्भ पर context.getSystemService(SdkSandboxController.class). कॉन्टेंट बनाने कंट्रोलर में ऐसे एपीआई हैं जो SDK टूल को प्राइवसी सैंडबॉक्स.

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

SDK टूल से SDK टूल के बारे में जानकारी

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

SdkSandboxController में मौजूद getSandboxedSdks() एपीआई, प्राइवसी सैंडबॉक्स में, लोड किए गए सभी SDK टूल के लिए SandboxedSdk क्लास. कॉन्टेंट बनाने SandboxedSdk ऑब्जेक्ट में, SDK टूल और इसके लिए sdkInterface की जानकारी मौजूद है संपर्क करने के लिए प्रोत्साहित करते हैं.

प्राइवसी सैंडबॉक्स में मौजूद SDK टूल, फ़ॉलो किया जा रहा है. मान लें कि यह कोड "SDK1" को चालू करने के लिए लिखा गया है से "SDK2" का इस्तेमाल करें. ये दोनों ही तरीके, ऐप्लिकेशन की निजता सेटिंग में लोड होते हैं सैंडबॉक्स.

SdkSandboxController controller = mSdkContext
    .getSystemService(SdkSandboxController.class);
List<SandboxedSdk> sandboxedSdks = controller.getSandboxedSdks();
SandboxedSdk sdk2 = sandboxedSdks.stream().filter( // The SDK it wants to
    // connect to, based on SDK name or SharedLibraryInfo.
try {
    IBinder binder = sdk2.getInterface();
    ISdkApi sdkApi = ISdkApi.Stub.asInterface(binder);
    // Call API on SDK2
    message = sdkApi.getMessage();
    } catch (RemoteException e) {
        throw new RuntimeException(e);
}

ऊपर दिए गए उदाहरण में, SDK1 टूल, SDK2 की एआईडीएल लाइब्रेरी को डिपेंडेंसी के तौर पर जोड़ता है. इस क्लाइंट SDK टूल में, एआईडीएल से जनरेट किया गया बाइंडर कोड शामिल है. दोनों SDK टूल को इस एआईडीएल लाइब्रेरी को एक्सपोर्ट करें. यह ठीक वैसा ही है जैसा ऐप्लिकेशन को ये प्राइवसी सैंडबॉक्स में SDK टूल का इस्तेमाल करके डेटा शेयर करते हैं.

SDK टूल के बीच इंटरफ़ेस शेयर करने के लिए, अपने-आप जनरेट होने वाले तरीके की सुविधा जोड़ी जाएगी इन सुझावों को लागू किया जा सकता है.

रनटाइम में इस्तेमाल किए जाने वाले SDK टूल को, ऐप्लिकेशन डिपेंडेंसी और विज्ञापन SDK टूल के साथ काम करने की ज़रूरत पड़ सकती है जो अभी रनटाइम के लिए चालू नहीं हैं.

SdkSandboxManager में मौजूद registerAppOwnedSdkSandboxInterface() एपीआई, ऐसे SDK टूल के लिए एक तरीका है जो रनटाइम के साथ काम नहीं करते प्लैटफ़ॉर्म. इसमें getAppOwnedSdkSandboxInterfaces() API (एपीआई) SdkSandboxController सभी के लिए AppOwnedSdkSandboxInterface उपलब्ध कराता है रजिस्टर किए गए, स्टैटिक तरीके से लिंक किए गए SDK टूल.

यहां दिए गए उदाहरण में, इंटरफ़ेस को रजिस्टर करने का तरीका बताया गया है रनटाइम के साथ काम करने वाले SDK टूल कम्यूनिकेशन के लिए उपलब्ध:

// Register AppOwnedSdkSandboxInterface
mSdkSandboxManager.registerAppOwnedSdkSandboxInterface(
    new AppOwnedSdkSandboxInterface(
        APP_OWNED_SDK_NAME, (long) APP_OWNED_SDK_VERSION, new AppOwnedSdkApi())
    );

इस उदाहरण में गैर-पेशेवरों के साथ इंस्ट्रुमेंट कम्यूनिकेशन का तरीका बताया गया है रनटाइम के साथ काम करने वाले SDK टूल:

// Get AppOwnedSdkSandboxInterface
List<AppOwnedSdkSandboxInterface> appOwnedSdks = mSdkContext
        .getSystemService(SdkSandboxController.class)
        .getAppOwnedSdkSandboxInterfaces();
    AppOwnedSdkSandboxInterface appOwnedSdk = appOwnedSdks.stream()
        .filter(s -> s.getName().contains(APP_OWNED_SDK_NAME))
        .findAny()
        .get();
    IAppOwnedSdkApi appOwnedSdkApi =
        IAppOwnedSdkApi.Stub.asInterface(appOwnedSdk.getInterface());
    message = appOwnedSdkApi.getMessage();

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

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

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

1. SdkSandboxActivityHandler रजिस्टर करें

SdkSandboxActivityHandler का एक इंस्टेंस रजिस्टर करने के लिए, इसका इस्तेमाल करें SdkSandboxController#registerSdkSandboxActivityHandler(SandboxedActivityHandler)

एपीआई उस ऑब्जेक्ट को रजिस्टर करता है और IBinder ऑब्जेक्ट दिखाता है, जो पास हो गया SdkSandboxActivityHandler.

public interface SdkSandboxActivityHandler {
    void onActivityCreated(Activity activity);
}

2. सैंडबॉक्स गतिविधि शुरू करें

रजिस्टर किए गए टोकन की पहचान करने के लिए, SDK टूल, लौटाए गए टोकन को पास करता है SdkSandboxActivityHandler को क्लाइंट ऐप्लिकेशन में जोड़ें. इसके बाद, क्लाइंट ऐप्लिकेशन कॉल करता है SdkSandboxManager#startSdkSandboxActivity(Activity, Binder) की वजह से गतिविधि को सैंडबॉक्स करना है और एक टोकन है, जो रजिस्टर किए गए SdkSandboxActivityHandler.

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

गतिविधि शुरू होने पर, SDK टूल को SdkSandboxActivityHandler#onActivityCreated(Activity) Activity#OnCreate(Bundle) निष्पादन.

उदाहरण के लिए, Activity ऑब्जेक्ट का ऐक्सेस होने पर और कॉल करने वाला (कॉलर) सेट कर सकता है Activity#setContentView(View) पर कॉल करके व्यू contentView.

लाइफ़साइकल कॉलबैक रजिस्टर करने के लिए, इसका इस्तेमाल करें Activity#registerActivityLifecycleCallbacks(Application.ActivityLifecycleCallbacks).

पास की गई गतिविधि में OnBackInvokedCallback को रजिस्टर करने के लिए, इसका इस्तेमाल करें Activity#getOnBackInvokedDispatcher().registerOnBackInvokedCallback(Int, OnBackInvokedCallback).

SDK टूल के रनटाइम में वीडियो प्लेयर की जांच करें

बैनर विज्ञापन दिखाने के साथ-साथ, प्राइवसी सैंडबॉक्स इन चीज़ों के लिए भी प्रतिबद्ध है SDK टूल के रनटाइम में चलने वाले वीडियो प्लेयर की सुविधा देता है.

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

जांच करने और सुझाव देने से यह पक्का होगा कि SDK टूल का रनटाइम, आपके पसंदीदा वीडियो प्लेयर के इस्तेमाल के उदाहरण.

नीचे दिया गया कोड स्निपेट बताता है कि कैसे एक आसान वीडियो व्यू पर वापस जाया जा सकता है किसी यूआरएल से लोड होता है.

Kotlin

    class SdkProviderImpl : SandboxedSdkProvider() {

        override fun getView(windowContext: Context, bundle: Bundle, width: Int,
                height: Int): View {
            val videoView = VideoView(windowContext)
            val layoutParams = LinearLayout.LayoutParams(width, height)
            videoView.setLayoutParams(layoutParams)
            videoView.setVideoURI(Uri.parse("https://test.website/video.mp4"))
            videoView.setOnPreparedListener { mp -> mp.start() }
            return videoView
        }
    }

Java

    public class SdkProviderImpl extends SandboxedSdkProvider {

        @Override
        public View getView(Context windowContext, Bundle bundle, int width,
                int height) {
            VideoView videoView = new VideoView(windowContext);
            LinearLayout.LayoutParams layoutParams =
                    new LinearLayout.LayoutParams(width, height);
            videoView.setLayoutParams(layoutParams);
            videoView.setVideoURI(Uri.parse("https://test.website/video.mp4"));
            videoView.setOnPreparedListener(mp -> {
                mp.start();
            });
            return videoView;
        }
    }

SDK टूल में स्टोरेज एपीआई इस्तेमाल करना

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

SDK टूल, फ़ाइल का इस्तेमाल करके इस अलग इंटरनल स्टोरेज को ऐक्सेस कर सकेंगे Context ऑब्जेक्ट पर Storage API SandboxedSdkProvider#getContext(). SDK टूल सिर्फ़ डिवाइस के स्टोरेज का इस्तेमाल करते हैं. इसलिए डिवाइस की मेमोरी के एपीआई, जैसे कि Context.getFilesDir() या Context.getCacheDir() काम करेगा. ज़्यादा उदाहरण यहां देखें डिवाइस के स्टोरेज से ऐक्सेस करना.

SDK टूल के रनटाइम से बाहरी स्टोरेज को ऐक्सेस नहीं किया जा सकता. इस पर कॉलिंग एपीआई ऐक्सेस बाहरी स्टोरेज ऐक्सेस करने पर या तो अपवाद दिया जाएगा या null दिया जाएगा. कई उदाहरण:

स्टोरेज के ऐक्सेस फ़्रेमवर्क का इस्तेमाल करके फ़ाइलें ऐक्सेस करने पर SecurityException.
getExternalFilsDir() हमेशा null दिखाएगा.

Android 13 में, SDK टूल के रनटाइम में शामिल सभी SDK टूल, डिवाइस का स्टोरेज शेयर करेंगे SDK टूल के रनटाइम के लिए तय किया गया है. स्टोरेज तब तक बना रहेगा जब तक कि Client ऐप्लिकेशन अनइंस्टॉल किया गया या क्लाइंट ऐप्लिकेशन का डेटा हटाने पर.

आपको इसके लिए SandboxedSdkProvider.getContext() से मिले Context का इस्तेमाल करना होगा स्टोरेज. किसी अन्य Context ऑब्जेक्ट इंस्टेंस पर, File Storage API का इस्तेमाल करना इस बात की कोई गारंटी नहीं है कि ऐप्लिकेशन का कॉन्टेक्स्ट, सभी स्थितियों में उम्मीद के मुताबिक काम करे भविष्य में आ रहे हैं.

यहां दिया गया कोड स्निपेट, SDK टूल के रनटाइम में स्टोरेज के इस्तेमाल का तरीका बताता है:

Kotlin

    private static class SdkInterfaceStorage extends ISdkInterface.Stub {
    override fun doSomething() {
        val filename = "myfile"
        val fileContents = "content"
        try {
            getContext().openFileOutput(filename, Context.MODE_PRIVATE).use {
                it.write(fileContents.toByteArray())
            } catch (e: Exception) {
                throw RuntimeException(e)
            }
        }
    }
}

Java

    private static class SdkInterfaceStorage extends ISdkInterface.Stub {
    @Override
    public void doSomething() {
        final filename = "myFile";
        final String fileContents = "content";
        try (FileOutputStream fos = getContext().openFileOutput(filename, Context.MODE_PRIVATE)) {
            fos.write(fileContents.toByteArray());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

हर SDK टूल के हिसाब से स्टोरेज

SDK टूल के हर रनटाइम के लिए, अलग-अलग इंटरनल स्टोरेज में, हर SDK टूल का अपना अलग रनटाइम होता है स्टोरेज डायरेक्ट्री पर जाएं. हर SDK टूल का स्टोरेज, SDK टूल के रनटाइम डिवाइस का स्टोरेज. इससे यह पता चलता है कि हर एसडीके टूल कितना स्टोरेज इस्तेमाल करता है.

Android 13 में, सिर्फ़ एक एपीआई हर SDK टूल के स्टोरेज का पाथ दिखाता है: Context#getDataDir().

Android 14 पर, Context ऑब्जेक्ट पर सभी डिवाइस के स्टोरेज के एपीआई हर एसडीके के लिए स्टोरेज पाथ. आपको यह सुविधा चालू करनी पड़ सकती है: adb कमांड का इस्तेमाल करना:

adb shell device_config put adservices sdksandbox_customized_sdk_context_enabled true

क्लाइंट के `SharedPreferences` की जानकारी फ़ेच की जा रही है

क्लाइंट ऐप्लिकेशन, अपने SharedPreferences से कुंजियों का सेट, उनके साथ शेयर कर सकते हैं SdkSandbox. SDK टूल, क्लाइंट ऐप्लिकेशन से सिंक किए गए डेटा को इनका इस्तेमाल करके पढ़ सकते हैं SdkSanboxController#getClientSharedPreferences() एपीआई. SharedPreferences इस एपीआई से मिले नतीजे सिर्फ़ पढ़ने के लिए हैं. आपको इस बारे में नहीं लिखना चाहिए.

Google Play services से मिला विज्ञापन आईडी ऐक्सेस करना

अगर आपके SDK टूल को Google Play services से मिले विज्ञापन आईडी का ऐक्सेस चाहिए, तो:

SDK टूल के मेनिफ़ेस्ट में, android.permission.ACCESS_ADSERVICES_AD_ID की अनुमति का एलान करें.
एसिंक्रोनस रूप से वैल्यू को फिर से पाने के लिए AdIdManager#getAdId() का इस्तेमाल करें.

Google Play services से मिला ऐप्लिकेशन सेट आईडी ऐक्सेस करें

अगर आपके SDK टूल को Google Play services से मिले ऐप्लिकेशन सेट आईडी का ऐक्सेस चाहिए, तो:

एसिंक्रोनस रूप से वैल्यू को फिर से पाने के लिए AppSetIdManager#getAppSetId() का इस्तेमाल करें.

क्लाइंट ऐप्लिकेशन अपडेट करना

SDK टूल के रनटाइम में चल रहे किसी SDK टूल में कॉल करने के लिए, इन निर्देशों का पालन करें कॉल के लिए इस्तेमाल किए जाने वाले क्लाइंट ऐप्लिकेशन में हुए बदलाव:

INTERNET और ACCESS_NETWORK_STATE की अनुमतियां जोड़ें का मेनिफ़ेस्ट होगा:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

अपने ऐप्लिकेशन की गतिविधि में, जिसमें कोई विज्ञापन शामिल है, उसमें SdkSandboxManager एक बूलियन है. इससे पता चलता है कि SDK टूल लोड है या नहीं, और रिमोट रेंडरिंग के लिए SurfaceView ऑब्जेक्ट:

Kotlin

    private lateinit var mSdkSandboxManager: SdkSandboxManager
    private lateinit var mClientView: SurfaceView
    private var mSdkLoaded = false

    companion object {
        private const val SDK_NAME = "com.example.privacysandbox.provider"
    }

Java

    private static final String SDK_NAME = "com.example.privacysandbox.provider";

    private SdkSandboxManager mSdkSandboxManager;
    private SurfaceView mClientView;
    private boolean mSdkLoaded = false;

देखें कि डिवाइस पर SDK टूल की रनटाइम प्रोसेस उपलब्ध है या नहीं.
1. SdkSandboxState कॉन्स्टेंट (getSdkSandboxState()) की जांच करें. SDK_SANDBOX_STATE_ENABLED_PROCESS_ISOLATION का मतलब है कि SDK टूल का रनटाइम उपलब्ध हैं.
2. देखें कि loadSdk() को कॉल किया गया है या नहीं. वह सफल होता है, अगर अपवाद नहीं हैं, और रिसीवर SandboxedSdk.
  - loadSdk() को फ़ोरग्राउंड से कॉल करें. अगर इसे बैकग्राउंड में SecurityException फेंका जाएगा.
  - SandboxedSdk के उदाहरण के लिए, OutcomeReceiver की जांच करें ताकि यह पुष्टि की जा सके कि LoadSdkException को फेंका गया है या नहीं. अपवाद का मतलब है ऐसा हो सकता है कि SDK टूल का रनटाइम उपलब्ध न हो.
अगर SdkSandboxState या loadSdk कॉल पूरा नहीं होता है, तो SDK टूल का रनटाइम उपलब्ध है और कॉल को मौजूदा SDK टूल पर वापस आना चाहिए.

इंटरैक्ट करने के लिए OutcomeReceiver लागू करके कॉलबैक क्लास तय करें SDK टूल के लोड होने के बाद, उसे रनटाइम में इस्तेमाल किया जा सकता है. निम्न में उदाहरण के लिए, SDK टूल लोड होने तक इंतज़ार करने के लिए क्लाइंट, कॉलबैक का इस्तेमाल करता है साथ ही, SDK टूल से वेब व्यू रेंडर करने की कोशिश करता है. कॉलबैक की परिभाषा इस चरण में आगे दी गई है.

Kotlin

    private inner class LoadSdkOutcomeReceiverImpl private constructor() :
            OutcomeReceiver<SandboxedSdk?, LoadSdkException?> {

      override fun onResult(sandboxedSdk: SandboxedSdk) {
          mSdkLoaded = true

          val binder: IBinder = sandboxedSdk.getInterface()
          if (!binderInterface.isPresent()) {
              // SDK is not loaded anymore.
              return
          }
          val sdkInterface: ISdkInterface = ISdkInterface.Stub.asInterface(binder)
          sdkInterface.doSomething()

          Handler(Looper.getMainLooper()).post {
              val bundle = Bundle()
              bundle.putInt(SdkSandboxManager.EXTRA_WIDTH_IN_PIXELS, mClientView.getWidth())
              bundle.putInt(SdkSandboxManager.EXTRA_HEIGHT_IN_PIXELS, mClientView.getHeight())
              bundle.putInt(SdkSandboxManager.EXTRA_DISPLAY_ID, display!!.displayId)
              bundle.putInt(SdkSandboxManager.EXTRA_HOST_TOKEN, mClientView.getHostToken())
              mSdkSandboxManager!!.requestSurfacePackage(
                      SDK_NAME, bundle, { obj: Runnable -> obj.run() },
                      RequestSurfacePackageOutcomeReceiverImpl())
          }
      }

      override fun onError(error: LoadSdkException) {
              // Log or show error.
      }
    }

Java

    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_DISPLAY_ID;
    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_HEIGHT_IN_PIXELS;
    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_HOST_TOKEN;
    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_WIDTH_IN_PIXELS;

    private class LoadSdkOutcomeReceiverImpl
            implements OutcomeReceiver<LoadSdkResponse, LoadSdkException> {
        private LoadSdkOutcomeReceiverImpl() {}

        @Override
        public void onResult(@NonNull SandboxedSdk sandboxedSdk) {
            mSdkLoaded = true;

            IBinder binder = sandboxedSdk.getInterface();
            if (!binderInterface.isPresent()) {
                // SDK is not loaded anymore.
                return;
            }
            ISdkInterface sdkInterface = ISdkInterface.Stub.asInterface(binder);
            sdkInterface.doSomething();

            new Handler(Looper.getMainLooper()).post(() -> {
                Bundle bundle = new Bundle();
                bundle.putInt(EXTRA_WIDTH_IN_PIXELS, mClientView.getWidth());
                bundle.putInt(EXTRA_HEIGHT_IN_PIXELS, mClientView.getHeight());
                bundle.putInt(EXTRA_DISPLAY_ID, getDisplay().getDisplayId());
                bundle.putInt(EXTRA_HOST_TOKEN, mClientView.getHostToken());

                mSdkSandboxManager.requestSurfacePackage(
                        SDK_NAME, bundle, Runnable::run,
                        new RequestSurfacePackageOutcomeReceiverImpl());
            });
        }

        @Override
        public void onError(@NonNull LoadSdkException error) {
            // Log or show error.
        }
    }

कॉल करते समय, रनटाइम में SDK टूल से रिमोट व्यू वापस पाने के लिए requestSurfacePackage(), OutcomeReceiver<Bundle, RequestSurfacePackageException> इंटरफ़ेस लागू करें:

Kotlin

    private inner class RequestSurfacePackageOutcomeReceiverImpl :
            OutcomeReceiver<Bundle, RequestSurfacePackageException> {
        fun onResult(@NonNull result: Bundle) {
            Handler(Looper.getMainLooper())
                    .post {
                        val surfacePackage: SurfacePackage = result.getParcelable(
                                EXTRA_SURFACE_PACKAGE,
                                SurfacePackage::class.java)
                        mRenderedView.setChildSurfacePackage(surfacePackage)
                        mRenderedView.setVisibility(View.VISIBLE)
                    }
        }

        fun onError(@NonNull error: RequestSurfacePackageException?) {
            // Error handling
        }
    }

Java

    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_SURFACE_PACKAGE;

    private class RequestSurfacePackageOutcomeReceiverImpl
            implements OutcomeReceiver<Bundle, RequestSurfacePackageException> {
        @Override
        public void onResult(@NonNull Bundle result) {
            new Handler(Looper.getMainLooper())
                    .post(
                            () -> {
                                SurfacePackage surfacePackage =
                                        result.getParcelable(
                                                EXTRA_SURFACE_PACKAGE,
                                                SurfacePackage.class);
                                mRenderedView.setChildSurfacePackage(surfacePackage);
                                mRenderedView.setVisibility(View.VISIBLE);
                            });
        }
        @Override
        public void onError(@NonNull RequestSurfacePackageException error) {
            // Error handling
        }
    }

व्यू दिखाने के बाद, SurfacePackage को यहां से रिलीज़ करना न भूलें:

surfacePackage.notifyDetachedFromWindow()

onCreate() में, ज़रूरी कॉलबैक, SdkSandboxManager शुरू करें, इसके बाद, SDK टूल को लोड करने का अनुरोध करें:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    mSdkSandboxManager = applicationContext.getSystemService(
            SdkSandboxManager::class.java
    )

    mClientView = findViewById(R.id.rendered_view)
    mClientView.setZOrderOnTop(true)

    val loadSdkCallback = LoadSdkCallbackImpl()
    mSdkSandboxManager.loadSdk(
            SDK_NAME, Bundle(), { obj: Runnable -> obj.run() }, loadSdkCallback
    )
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mSdkSandboxManager = getApplicationContext().getSystemService(
            SdkSandboxManager.class);

    mClientView = findViewById(R.id.rendered_view);
    mClientView.setZOrderOnTop(true);

    LoadSdkCallbackImpl loadSdkCallback = new LoadSdkCallbackImpl();
    mSdkSandboxManager.loadSdk(
            SDK_NAME, new Bundle(), Runnable::run, loadSdkCallback);
}

ऐप्लिकेशन अपने डिफ़ॉल्ट SharedPreferences की कुछ कुंजियों को शेयर करने का विकल्प चुन सकता है को आसानी से ट्रैक करें. वे कॉल करके ऐसा कर सकते हैं SdkSandboxManager#addSyncedSharedPreferencesKeys(Set<String>keys) तरीका SdkSandbox मैनेजर के किसी भी इंस्टेंस पर. ऐप्लिकेशन से सूचना मिलने के बाद SdkSandboxManager किन कुंजियों को सिंक करना है, SdkSandboxManager सिंक करेगा तो सैंडबॉक्स और SDK में उन कुंजियों के मान का इस्तेमाल करके उन्हें पढ़ सकते हैं SdkSandboxController#getClientSharedPreferences. यहां जाएं: ज़्यादा जानकारी के लिए, क्लाइंट की SharedPreferences पढ़ना जानकारी.

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

कॉल करके, सिंक की जा रही कुंजियों के सेट में बदलाव किया जा सकता है SdkSandboxManager#removeSyncedSharedPreferencesKeys(Set<String>keys) से कुंजियां हटाएं. सिंक की जा रही कुंजियों के मौजूदा सेट को देखने के लिए, इसका इस्तेमाल करें SdkSandboxManager#getSyncedSharedPreferencesKeys().

हमारा सुझाव है कि कुंजियों के सेट को जितना हो सके उतना छोटा रखें और उसका इस्तेमाल तभी करें, जब ज़रूरी है. अगर आपको सामान्य कामों के लिए SDK टूल को जानकारी देनी है, कृपया SDK टूल से संपर्क करने के लिए, उनके SandboxedSdk इंटरफ़ेस का इस्तेमाल करें. ऐप्लिकेशन इन एपीआई का इस्तेमाल तब किया जा सकता है, जब ऐप्लिकेशन सहमति मैनेजमेंट प्लैटफ़ॉर्म (सीएमपी) SDK टूल की तुलना में, सैंडबॉक्स में मौजूद SDK टूल सीएमपी SDK टूल, डिफ़ॉल्ट रूप से स्टोर में मौजूद डेटा को देखने में दिलचस्पी रखते हैं SharedPreferences.
Kotlin
override fun onCreate(savedInstanceState: Bundle?) { … // At some point, initiate the set of keys for synchronization with sandbox mSdkSandboxManager.addSyncedSharedPreferencesKeys(Set.of("foo", "bar")); }
Java
@Override protected void onCreate(Bundle savedInstanceState) { … // At some point, initiate the set of keys for synchronization with sandbox mSdkSandboxManager.addSyncedSharedPreferencesKeys(Set.of("foo", "bar")); }

SDK टूल के सैंडबॉक्स की प्रोसेस अचानक बंद हो जाने पर, समस्या को मैनेज करने के लिए, SdkSandboxProcessDeathCallback इंटरफ़ेस के लिए लागू करने की प्रक्रिया तय करें:

Kotlin

    private inner class SdkSandboxLifecycleCallbackImpl() : SdkSandboxProcessDeathCallback {
        override fun onSdkSandboxDied() {
            // The SDK runtime process has terminated. To bring back up the
            // sandbox and continue using SDKs, load the SDKs again.
            val loadSdkCallback = LoadSdkOutcomeReceiverImpl()
            mSdkSandboxManager.loadSdk(
                      SDK_NAME, Bundle(), { obj: Runnable -> obj.run() },
                      loadSdkCallback)
        }
    }

Java

      private class SdkSandboxLifecycleCallbackImpl
              implements SdkSandboxProcessDeathCallback {
          @Override
          public void onSdkSandboxDied() {
              // The SDK runtime process has terminated. To bring back up
              // the sandbox and continue using SDKs, load the SDKs again.
              LoadSdkOutcomeReceiverImpl loadSdkCallback =
                      new LoadSdkOutcomeReceiverImpl();
              mSdkSandboxManager.loadSdk(
                          SDK_NAME, new Bundle(), Runnable::run, loadSdkCallback);
          }
      }

इस कॉलबैक को रजिस्टर करने के लिए, ताकि SDK टूल के सैंडबॉक्स के बारे में जानकारी मिल सके को खत्म कर दिया गया है, तो किसी भी समय यह लाइन जोड़ें:

Kotlin

    mSdkSandboxManager.addSdkSandboxProcessDeathCallback({ obj: Runnable -> obj.run() },
            SdkSandboxLifecycleCallbackImpl())

Java

    mSdkSandboxManager.addSdkSandboxProcessDeathCallback(Runnable::run,
            new SdkSandboxLifecycleCallbackImpl());

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

अपने क्लाइंट ऐप्लिकेशन के SDK टूल मॉड्यूल पर डिपेंडेंसी जोड़ें build.gradle:
```
dependencies {
    ...
    implementation project(':<your-sdk-module>')
    ...
}
```

अपने ऐप्लिकेशन की जांच करें

क्लाइंट ऐप्लिकेशन चलाने के लिए, अपने टेस्ट डिवाइस पर SDK टूल और क्लाइंट ऐप्लिकेशन इंस्टॉल करें कमांड लाइन का इस्तेमाल करें.

Android Studio की मदद से डिप्लॉय करें

Android Studio से डिप्लॉय करते समय, इन चरणों को पूरा करें:

अपने क्लाइंट ऐप्लिकेशन के लिए Android Studio प्रोजेक्ट खोलें.
Run > कॉन्फ़िगरेशन में बदलाव करना. रन/डीबग कॉन्फ़िगरेशन विंडो दिखाई देता है.
लॉन्च विकल्प में, लॉन्च को बताई गई गतिविधि पर सेट करें.
गतिविधि के बगल में मौजूद तीन बिंदु वाले मेन्यू पर क्लिक करें और मुख्य गतिविधि चुनें एक समस्या को हल करने में मदद की है.
लागू करें पर क्लिक करें. इसके बाद, ठीक है पर क्लिक करें.
Run पर क्लिक करें का इस्तेमाल करके, अपने टेस्ट डिवाइस पर क्लाइंट ऐप्लिकेशन और SDK टूल इंस्टॉल करें.

कमांड लाइन पर डिप्लॉय करें

कमांड लाइन का इस्तेमाल करके डिप्लॉय करते समय, नीचे दी गई सूची में दिए गए चरणों को पूरा करें. इस सेक्शन में माना गया है कि आपके SDK टूल ऐप्लिकेशन मॉड्यूल का नाम sdk-app है और आपके क्लाइंट ऐप्लिकेशन मॉड्यूल का नाम client-app है.

कमांड-लाइन टर्मिनल से, Privacy Sandbox SDK टूल के APKs बनाएं:
```
./gradlew :client-app:buildPrivacySandboxSdkApksForDebug
```
इससे जनरेट किए गए APKs की जगह की जानकारी मिलती है. इन APK पर साइन इन किया गया है अपनी लोकल डीबग कुंजी का इस्तेमाल करें. आपको अगले निर्देश में इस पाथ की ज़रूरत है.
अपने डिवाइस पर APK इंस्टॉल करें:
```
adb install -t /path/to/your/standalone.apk
```
Android Studio में, Run > कॉन्फ़िगरेशन में बदलाव करना. रन/डीबग कॉन्फ़िगरेशन विंडो दिखती है.
इंस्टॉल करने के विकल्प में जाकर, Deploy को डिफ़ॉल्ट APK पर सेट करें.
लागू करें पर क्लिक करें. इसके बाद, ठीक है पर क्लिक करें.
अपने टेस्ट डिवाइस पर APK बंडल इंस्टॉल करने के लिए, Run पर क्लिक करें.

अपने ऐप्लिकेशन डीबग करना

क्लाइंट ऐप्लिकेशन को डीबग करने के लिए, डीबग पर क्लिक करें बटन पर क्लिक करें.

SDK टूल के ऐप्लिकेशन को डीबग करने के लिए, Run > प्रोसेस में अटैच करें पर क्लिक करने पर, आपको पॉप-अप दिखेगा डालें (नीचे दिखाया गया है). सभी प्रोसेस दिखाएं बॉक्स पर सही का निशान लगाएं. इस सूची में तो CLIENT_APP_PROCESS_sdk_sandbox नाम की प्रोसेस खोजें. यह विकल्प चुनें और SDK टूल के ऐप्लिकेशन के कोड में ब्रेकपॉइंट जोड़ें अपने SDK टूल को डीबग करना शुरू करें.

SDK टूल ऐप्लिकेशन की प्रोसेस, सूची के तौर पर सबसे नीचे दिखती है
डायलॉग का हिस्सा — **प्रोसेस चुनें** स्क्रीन, जहां ये काम किए जा सकते हैं डीबग करने के लिए SDK टूल का ऐप्लिकेशन चुनें.

कमांड लाइन की मदद से, SDK टूल का रनटाइम शुरू और बंद करें

अपने ऐप्लिकेशन के लिए SDK टूल के रनटाइम की प्रोसेस शुरू करने के लिए, नीचे दिए गए शेल कमांड का इस्तेमाल करें:

adb shell cmd sdk_sandbox start [--user <USER_ID> | current] <CLIENT_APP_PACKAGE>

इसी तरह, SDK टूल के रनटाइम की प्रोसेस को रोकने के लिए, इस निर्देश को चलाएं:

adb shell cmd sdk_sandbox stop [--user <USER_ID> | current] <CLIENT_APP_PACKAGE>

देखें कि फ़िलहाल कौनसे SDK टूल लोड हैं

यहां दिए गए लिंक का इस्तेमाल करके, यह देखा जा सकता है कि कौनसे SDK टूल लोड हो रहे हैं getSandboxedSdks फ़ंक्शन के साथ SdkSandboxManager.

सीमाएं

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

कोड सैंपल

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है कॉन्टेंट बनाने SDK टूल के रनटाइम और निजता बनाए रखने वाले एपीआई का डेटा स्टोर करने की जगह GitHub पर अलग-अलग Android Studio प्रोजेक्ट का एक सेट होता है, ताकि शुरू किया. इसमें ऐसे सैंपल शामिल हैं जो बताते हैं कि SDK टूल को शुरू और कॉल कैसे किया जाता है रनटाइम.

गड़बड़ियों और समस्याओं की शिकायत करना

आपके सुझाव, शिकायत या राय, Android पर प्राइवसी सैंडबॉक्स का अहम हिस्सा हैं! हमें बताएं Android पर प्राइवसी सैंडबॉक्स को बेहतर बनाने के लिए, आपको मिली समस्या की

आपके लिए सुझाव

ध्यान दें: JavaScript बंद होने पर लिंक टेक्स्ट दिखता है
SDK टूल का रनटाइम
प्रॉडक्ट की जानकारी
Android डेवलपर गाइड पर, Protected Audience API

SDK टूल का रनटाइम डेवलपर की गाइड

सीमाएं

शुरू करने से पहले

Android Studio में अपना प्रोजेक्ट सेट अप करना

अपना SDK टूल तैयार करना

Kotlin

Java

एसडीकेसैंडबॉक्सकंट्रोल

SDK टूल से SDK टूल के बारे में जानकारी

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

1. SdkSandboxActivityHandler रजिस्टर करें

2. सैंडबॉक्स गतिविधि शुरू करें

SDK टूल के रनटाइम में वीडियो प्लेयर की जांच करें

Kotlin

Java

SDK टूल में स्टोरेज एपीआई इस्तेमाल करना

Kotlin

Java

हर SDK टूल के हिसाब से स्टोरेज

क्लाइंट के SharedPreferences की जानकारी फ़ेच की जा रही है

Google Play services से मिला विज्ञापन आईडी ऐक्सेस करना

Google Play services से मिला ऐप्लिकेशन सेट आईडी ऐक्सेस करें

क्लाइंट ऐप्लिकेशन अपडेट करना

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

अपने ऐप्लिकेशन की जांच करें

Android Studio की मदद से डिप्लॉय करें

कमांड लाइन पर डिप्लॉय करें

अपने ऐप्लिकेशन डीबग करना

कमांड लाइन की मदद से, SDK टूल का रनटाइम शुरू और बंद करें

देखें कि फ़िलहाल कौनसे SDK टूल लोड हैं

सीमाएं

कोड सैंपल

गड़बड़ियों और समस्याओं की शिकायत करना

आपके लिए सुझाव

क्लाइंट के `SharedPreferences` की जानकारी फ़ेच की जा रही है