एआईडीएल भाषा

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

AIDL भाषा, Java भाषा पर आधारित है. फ़ाइलों में इंटरफ़ेस कॉन्ट्रैक्ट के साथ-साथ, इस कॉन्ट्रैक्ट में इस्तेमाल किए गए अलग-अलग डेटा टाइप और कॉन्स्टेंट की जानकारी होती है.

पैकेज

हर AIDL फ़ाइल, एक वैकल्पिक पैकेज से शुरू होती है. यह पैकेज, अलग-अलग बैकएंड में मौजूद पैकेज के नाम से मेल खाता है. पैकेज का एलान इस तरह दिखता है:

    package my.package;

Java की तरह ही, AIDL फ़ाइलों का स्ट्रक्चर भी उनके पैकेज से मेल खाना चाहिए. पैकेज my.package वाली फ़ाइलें, my/package/ फ़ोल्डर में होनी चाहिए.

प्रकार

AIDL फ़ाइलों में, कई जगहों पर टाइप तय किए जा सकते हैं. AIDL भाषा में काम करने वाले टाइप की सटीक सूची के लिए, AIDL बैकएंड टाइप देखें.

एनोटेशन

एआईडीएल भाषा के कई हिस्सों में ऐनोटेशन काम करते हैं. एनोटेशन की सूची और उन्हें लागू करने की जगहों के बारे में जानने के लिए, AIDL एनोटेशन देखें.

इंपोर्ट

दूसरे इंटरफ़ेस में तय किए गए टाइप का इस्तेमाल करने के लिए, आपको सबसे पहले बिल्ड सिस्टम में डिपेंडेंसी जोड़नी होंगी. cc_* और java_* Soong मॉड्यूल में, .aidl फ़ाइलों का इस्तेमाल Android प्लैटफ़ॉर्म के बिल्ड में srcs के नीचे सीधे तौर पर किया जाता है. ऐसे में, aidl: { include_dirs: ... } फ़ील्ड का इस्तेमाल करके डायरेक्ट्री जोड़ी जा सकती हैं. aidl_interface का इस्तेमाल करके इंपोर्ट करने के लिए, यहां देखें.

इंपोर्ट कुछ ऐसा दिखता है:

    import some.package.Foo;  // explicit import

एक ही पैकेज में किसी टाइप को इंपोर्ट करते समय, पैकेज को छोड़ा जा सकता है. हालांकि, पैकेज को छोड़ने पर, इंपोर्ट से जुड़ी गड़बड़ियां हो सकती हैं. ऐसा तब होता है, जब टाइप को पैकेज के बिना तय किया जाता है और ग्लोबल नेमस्पेस में डाला जाता है. आम तौर पर, सभी टाइप को नेमस्पेस में रखा जाना चाहिए:

    import Foo;  // same as my.package.Foo

टाइप तय करना

आम तौर पर, AIDL फ़ाइलें उन टाइप के बारे में बताती हैं जिनका इस्तेमाल इंटरफ़ेस के तौर पर किया जाता है.

इंटरफ़ेस

यहां AIDL इंटरफ़ेस का उदाहरण दिया गया है:

    interface ITeleport {
        // Location defined elsewhere
        void teleport(Location baz, float speed);
        String getName();

        // ITeleportCallback defined elsewhere
        void methodWithCallback(ITeleportCallback callback);

        // ITeleportSession defined elsewhere
        ITeleportSession getASubInterface();
    }

इंटरफ़ेस, तरीकों की सीरीज़ के साथ किसी ऑब्जेक्ट को परिभाषित करता है. तरीके, oneway (oneway void doFoo()) या सिंक्रोनस हो सकते हैं. अगर किसी इंटरफ़ेस को oneway (oneway interface ITeleport {...}) के तौर पर परिभाषित किया गया है, तो उसमें मौजूद सभी तरीके, oneway के तौर पर काम करते हैं. वन-वे तरीके, एसिंक्रोनस तरीके से डिस्पैच किए जाते हैं और इनसे नतीजा नहीं मिलता. एक ही थ्रेड से एक ही बाइंडर में डेटा भेजने के एकतरफ़ा तरीके भी क्रम से लागू होते हैं. हालांकि, ऐसा अलग-अलग थ्रेड में भी हो सकता है. थ्रेड सेट अप करने का तरीका जानने के लिए, AIDL बैकएंड थ्रेड मैनेजमेंट लेख पढ़ें.

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

तरीकों में शून्य या उससे ज़्यादा आर्ग्युमेंट हो सकते हैं. तरीकों के आर्ग्युमेंट, in, out या inout हो सकते हैं. इस बात पर चर्चा करने के लिए कि इसका आर्ग्युमेंट टाइप पर क्या असर पड़ता है, AIDL बैकएंड की डायरेक्टिव देखें.

पार्सल किए जा सकने वाले आइटम

बैकएंड के हिसाब से पार्सल करने की सुविधा बनाने का तरीका जानने के लिए, AIDL बैकएंड के लिए कस्टम पार्सल करने की सुविधा लेख पढ़ें.

Android 10 और इसके बाद के वर्शन में, AIDL में सीधे तौर पर पार्सल की जा सकने वाली डेफ़िनिशन काम करती हैं. इस तरह के पार्सल किए जा सकने वाले आइटम को स्ट्रक्चर्ड पार्सल किए जा सकने वाले आइटम कहा जाता है. AIDL कंपाइलर और हमारे बिल्ड सिस्टम में, स्ट्रक्चर्ड और स्टैबल AIDL के बीच के संबंध के बारे में ज़्यादा जानने के लिए, स्ट्रक्चर्ड बनाम स्टैबल AIDL देखें.

उदाहरण के लिए:

    package my.package;

    import my.package.Boo;

    parcelable Baz {
        @utf8InCpp String name = "baz";
        Boo boo;
    }

यूनियन

Android 12 और उसके बाद के वर्शन, टैग किए गए यूनियन डिक्लेरेशन के साथ काम करते हैं. उदाहरण के लिए:

    package my.package;

    import my.package.FooSettings;
    import my.package.BarSettings;

    union Settings {
        FooSettings fooSettings;
        BarSettings barSettings;
        @utf8InCpp String str;
        int number;
    }

बैकएंड के बारे में ज़्यादा जानकारी के लिए, AIDL बैकएंड यूनियन देखें.

Enums

Android 11 और उसके बाद के वर्शन में, एनम घोषणाओं की सुविधा काम करती है. उदाहरण के लिए:

    package my.package;

    enum Boo {
        A = 1 * 4,
        B = 3,
    }

नेस्ट किए गए टाइप के एलान

Android 13 और उसके बाद के वर्शन में, नेस्ट किए गए टाइप के एलान की सुविधा काम करती है. उदाहरण के लिए:

    package my.package;

    import my.package.Baz;

    interface IFoo {
        void doFoo(Baz.Nested nested);  // defined in my/package/Baz.aidl
        void doBar(Bar bar);            // defined below

        parcelable Bar { ... }          // nested type definition
    }

कॉन्स्टेंट

कस्टम एआईडीएल इंटरफ़ेस, पार्सल करने लायक ऑब्जेक्ट, और यूनियन में पूर्णांक और स्ट्रिंग कॉन्स्टेंट भी शामिल हो सकते हैं. जैसे:

    const @utf8InCpp String HAPPY = ":)";
    const String SAD = ":(";
    const byte BYTE_ME = 1;
    const int ANSWER = 6 * 7;

कॉन्स्टेंट एक्सप्रेशन

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

true और false लिटरल, बूलियन वैल्यू दिखाते हैं. . वाली वैल्यू, लेकिन 3.8 जैसे सफ़िक्स के बिना, डबल वैल्यू मानी जाती हैं. फ़्लोट वैल्यू में f सफ़िक्स होता है, जैसे कि 2.4f. l या L सफ़िक्स वाली इंटिग्रल वैल्यू से पता चलता है कि वैल्यू 64-बिट की है. अगर ऐसा नहीं किया जाता है, तो इंटिग्रल की वैल्यू को 8-बिट (बाइट), 32-बिट (इंटेजर), और 64-बिट (लॉन्ग) के बीच, वैल्यू को बनाए रखने वाला सबसे छोटा साइन वाला टाइप मिलता है. इसलिए, 256 को int माना जाता है, लेकिन 255 + 1 byte 0 में ओवरफ़्लो हो जाता है. 0x3 जैसी हेक्स वैल्यू को पहले 32-बिट और 64-बिट के बीच, वैल्यू को बनाए रखने वाले सबसे छोटे बिना साइन वाले टाइप के तौर पर समझा जाता है. इसके बाद, उन्हें बिना साइन वाली वैल्यू के तौर पर फिर से समझा जाता है. इसलिए, 0xffffffff की वैल्यू int है -1. Android 13 में, byte वैल्यू दिखाने के लिए, 3u8 जैसे कॉन्स्टेंट में सफ़िक्स u8 जोड़ा जा सकता है. यह सफ़िक्स इसलिए ज़रूरी है, ताकि 0xffu8 * 3 जैसे कैलकुलेशन को -3 के तौर पर समझा जा सके, जिसका टाइप byte है. वहीं, 0xff * 3 को 765 के तौर पर समझा जा सकता है, जिसका टाइप int है.

इस्तेमाल किए जा सकने वाले ऑपरेटर में C++ और Java के सेमेटिक्स होते हैं. प्राथमिकता के हिसाब से, बाइनरी ऑपरेटर का क्रम सबसे कम से सबसे ज़्यादा इस तरह से है: || && | ^ & == != < > <= >= << >> + - * / %. यूनीऐरी ऑपरेटर + - ! ~ होते हैं.