AVD Android: यह क्या है, Android Virtual Device और एमुलेटर कैसे सेट करें

AVD क्या है

AVD (Android Virtual Device) एक सॉफ़्टवेयर कॉन्फ़िगरेशन है जो एक वर्चुअल Android डिवाइस का वर्णन करता है। भौतिक फ़ोन के विपरीत, AVD को हार्डवेयर की आवश्यकता नहीं होती — यह QEMU पर आधारित Android एमुलेटर के माध्यम से कंप्यूटर पर चलता है। डेवलपर परीक्षण के लिए आवश्यकतानुसार कई AVD बनाता है: विभिन्न Android संस्करणों, स्क्रीन आकारों, मेमोरी क्षमताओं और पिक्सेल घनत्व के लिए।

प्रत्येक AVD एक विशिष्ट SDK Platform से जुड़ा होता है। इसका मतलब है कि Android 14 (API Level 34) के साथ AVD बनाने के लिए, पहले SDK Manager के माध्यम से उस संस्करण की System Image स्थापित करनी होगी। System Image एक ऑपरेटिंग सिस्टम इमेज है जिसमें सभी सिस्टम ऐप, Google सेवाएँ (यदि Google APIs इमेज चुनी गई है) और रनटाइम घटक शामिल हैं। Google अनुशंसा करता है वास्तविक उपकरणों के साथ अधिकतम संगतता के लिए Google Play सेवाओं वाली Google APIs इमेज का उपयोग करें।

AVD डेवलपमेंट में कई कारणों से अपरिहार्य है। पहला, यह दर्जनों उपकरण खरीदे बिना विभिन्न Android संस्करणों पर ऐप का परीक्षण करने की अनुमति देता है। दूसरा, AVD स्नैपशॉट (Snapshots) का समर्थन करता है — सिस्टम स्थिति को सहेजना, जो स्टार्टअप को गति देता है। तीसरा, एमुलेटर Android Studio के साथ एकीकृत है: APK इंस्टॉलेशन, डिबगिंग और लॉगिंग भौतिक उपकरण की तरह ही काम करते हैं।

वर्चुअल डिवाइस के प्रकार

AVD विभिन्न प्रकार के उपकरणों का समर्थन करता है: फ़ोन, टैबलेट, Wear OS घड़ियाँ, Android TV और Android Automotive। प्रत्येक प्रकार के लिए, AVD Manager Google से तैयार प्रोफ़ाइल प्रदान करता है: Pixel 8, Pixel 9 Pro, Nexus 7, Samsung Galaxy Tab और अन्य। डिवाइस प्रोफ़ाइल स्क्रीन आकार, रिज़ॉल्यूशन, पिक्सेल घनत्व (dpi) और नेविगेशन (जेस्चर या बटन) को परिभाषित करती है।

AVD किससे बना है

प्रत्येक AVD कॉन्फ़िगरेशन फ़ाइलों और इमेज का एक सेट है। मुख्य कॉन्फ़िगरेशन फ़ाइल config.ini है, जो वर्चुअल डिवाइस के पैरामीटर संग्रहीत करती है: नाम, प्रकार, API Level, स्क्रीन आकार, RAM और VM heap आकार। फ़ाइल $HOME/.android/avd/AVDनाम.avd/ निर्देशिका में स्थित होती है और इसे मैन्युअल रूप से संशोधित किया जा सकता है, हालाँकि इसे आमतौर पर AVD Manager के माध्यम से संपादित किया जाता है।

config.ini के अलावा, AVD निर्देशिका में संग्रहीत होते हैं: userdata.img (उपयोगकर्ता डेटा इमेज — ऐप, सेटिंग्स, फ़ाइलें), system.img (स्थापित SDK Platform की System Image का लिंक), cache.img (कैश) और sdcard.img (SD कार्ड इमेज)। Wipe Data करने पर, userdata.img हटा दिया जाता है और एक नई खाली इमेज बनाई जाती है। स्नैपशॉट AVD निर्देशिका के अंदर एक अलग snapshots/ फ़ोल्डर में सहेजे जाते हैं।

System Image AVD से अलग डाउनलोड की जाती है — एक इमेज का उपयोग कई वर्चुअल डिवाइसों द्वारा किया जा सकता है। सिस्टम इमेज Android SDK निर्देशिका में संग्रहीत होती हैं: $ANDROID_SDK/system-images/android-{API}/{type}/{arch}/। इमेज प्रकार: google_apis (Google सेवाओं के साथ), google_apis_playstore (Google Play Store के साथ) और default (Google सेवाओं के बिना शुद्ध AOSP)।

System Images के प्रकार

AVD Manager के माध्यम से AVD बनाना

AVD Manager Android Studio में वर्चुअल डिवाइस बनाने और प्रबंधित करने के लिए एक ग्राफिकल उपकरण है। इसे Tools → Device Manager मेनू या टूलबार आइकन के माध्यम से खोला जा सकता है। AVD Manager बनाए गए उपकरणों की सूची, उनकी स्थिति (चल रहा/बंद), Android संस्करण और उपलब्ध क्रियाएँ (प्रारंभ, रोकें, डेटा मिटाएँ, संपादित करें) दिखाता है।

नया AVD बनाने के लिए, Create device बटन पर क्लिक करें। तैयार सूची से एक डिवाइस प्रोफ़ाइल चुनें — Google सभी लोकप्रिय उपकरणों के लिए प्रोफ़ाइल प्रदान करता है। प्रोफ़ाइल चुनने के बाद, System Image निर्दिष्ट करें: Android संस्करण और इमेज प्रकार। नई परियोजनाओं के लिए, Google APIs इमेज के साथ नवीनतम स्थिर संस्करण चुनें। फिर AVD नाम, स्क्रीन ओरिएंटेशन, RAM और VM heap आकार कॉन्फ़िगर करें। बनाने के बाद, AVD लॉन्च करने के लिए तैयार है।

कमांड लाइन से चरण-दर-चरण AVD निर्माण

# 1. उपलब्ध System Images की सूची
sdkmanager --list | grep system-images

# 2. Google APIs के साथ API 35 के लिए System Image स्थापित करें
sdkmanager "system-images;android-35;google_apis;x86_64"

# 3. pixel8_api35 नाम से AVD बनाएँ
avdmanager create avd -n pixel8_api35 \
    -k "system-images;android-35;google_apis;x86_64" \
    -d pixel_8

# 4. बनाए गए AVD को लॉन्च करें
emulator -avd pixel8_api35 -gpu host -memory 2048

# 5. सभी AVD की सूची
avdmanager list avd

AVD की हार्डवेयर विशेषताओं को कॉन्फ़िगर करना

AVD Manager वर्चुअल डिवाइस की हार्डवेयर विशेषताओं के विस्तृत कॉन्फ़िगरेशन की अनुमति देता है। मुख्य पैरामीटर: RAM (रैंडम एक्सेस मेमोरी, अनुशंसित मान 2048–4096 MB), VM heap (वर्चुअल मशीन हीप आकार, 256–512 MB), Internal Storage (आंतरिक संग्रहण, 2–8 GB) और SD Card (वर्चुअल SD कार्ड)। ये पैरामीटर एप्लिकेशन के प्रदर्शन और कम मेमोरी स्थितियों में उसके व्यवहार को प्रभावित करते हैं।

अतिरिक्त सेटिंग्स में शामिल हैं: कैमरा (एमुलेटेड या होस्ट वेबकैम कनेक्शन), सेंसर (एक्सेलेरोमीटर, जाइरोस्कोप), NFC, Bluetooth और बैटरी। उदाहरण के लिए, स्थान का पता लगाने वाले ऐप्स के परीक्षण के लिए, एमुलेटर नियंत्रण बटन या ADB के माध्यम से डिवाइस रोटेशन का अनुकरण किया जा सकता है। सेंसर अनुकरण उन परिदृश्यों का परीक्षण करने की अनुमति देता है जिन्हें भौतिक उपकरण पर पुन: उत्पन्न करना कठिन है।

मुख्य config.ini पैरामीटर

एमुलेटर के प्रदर्शन को अनुकूलित करना

AVD की गति सीधे हार्डवेयर वर्चुअलाइज़ेशन पर निर्भर करती है। Windows पर Windows Hypervisor Platform (WHPX) का उपयोग किया जाता है, macOS पर — Hypervisor.Framework, Linux पर — KVM। यदि वर्चुअलाइज़ेशन अक्षम है, तो AVD शुद्ध सॉफ़्टवेयर एमुलेशन मोड में काम करता है, जो 10–20 गुना धीमा है। यह जाँचने के लिए कि वर्चुअलाइज़ेशन सक्षम है या नहीं, एमुलेटर को -accel-check फ्लैग के साथ चलाएँ।

दूसरा प्रमुख कारक System Image आर्किटेक्चर का चुनाव है। x86_64 इमेज Intel और AMD प्रोसेसर वाले कंप्यूटरों पर arm64-v8a की तुलना में काफी तेज़ काम करती हैं, क्योंकि उन्हें ARM निर्देशों के गतिशील अनुवाद की आवश्यकता नहीं होती। Intel प्रोसेसर वाले Windows और macOS पर डेवलपमेंट के लिए हमेशा x86_64 इमेज का उपयोग करें। Mac ARM प्रोसेसर (Apple Silicon) पर, देशी arm64-v8a इमेज का उपयोग करें।

त्वरण के लिए कमांड लाइन फ्लैग

# हार्डवेयर वर्चुअलाइज़ेशन और GPU त्वरण के साथ लॉन्च करें
emulator -avd pixel8_api35 -gpu host -memory 4096 -cores 4

# वर्चुअलाइज़ेशन समर्थन की जाँच करें
emulator -accel-check

# GUI के बिना चलाएँ (CI के लिए)
emulator -avd pixel8_api35 -no-window -no-audio -gpu off

# त्वरित स्टार्टअप के लिए स्नैपशॉट का उपयोग करें
emulator -avd pixel8_api35 -snapshot mysnapshot -no-snapshot-save

एमुलेटर प्रदर्शन युक्तियाँ

अधिकतम AVD प्रदर्शन के लिए: एमुलेटर को कम से कम 2–4 GB RAM आवंटित करें, GPU Host सक्षम करें (रेंडरिंग के लिए कंप्यूटर के ग्राफ़िक्स कार्ड का उपयोग करता है), यदि आवश्यक न हो तो ध्वनि बंद करें (फ्लैग -no-audio), और स्वच्छ स्थिति में त्वरित वापसी के लिए स्नैपशॉट का उपयोग करें। स्नैपशॉट पूर्ण सिस्टम स्थिति सहेजते हैं — स्नैपशॉट से लॉन्च करने में 30–60 सेकंड के पूर्ण बूट के बजाय 2–5 सेकंड लगते हैं।

AVD को SSD ड्राइव पर संग्रहीत करने की भी अनुशंसा की जाती है — सिस्टम बूट और APK इंस्टॉलेशन के दौरान I/O संचालन काफी तेज़ होते हैं। एक साथ कई AVD चलाने के लिए, कंप्यूटर पर RAM की कुल मात्रा बढ़ाएँ और अपरिवर्तनीय एमुलेटर के लिए -read-only फ्लैग का उपयोग करें।

कमांड लाइन से AVD प्रबंधित करना

Android Studio के बिना कमांड लाइन से AVD पर पूर्ण नियंत्रण संभव है। avdmanager और emulator उपकरण Android SDK का हिस्सा हैं और सभी कार्य करते हैं: AVD बनाना, हटाना, लॉन्च करना और कॉन्फ़िगर करना। कमांड लाइन विशेष रूप से CI/CD पाइपलाइनों में उपयोगी है, जहाँ कोई ग्राफिकल इंटरफ़ेस नहीं है, और परीक्षण स्वचालन के लिए।

बुनियादी AVD प्रबंधन कमांड

# कस्टम पैरामीटर के साथ AVD बनाएँ
avdmanager create avd -n test_device \
    -k "system-images;android-34;google_apis;x86_64" \
    --device "pixel_8" \
    --force

# AVD हटाएँ
avdmanager delete avd -n test_device

# AVD क्लोन करें (फ़ाइलों की प्रतिलिपि बनाकर)
cp -r ~/.android/avd/pixel8_api35.avd ~/.android/avd/pixel8_clone.avd

# AVD डेटा रीसेट करें
emulator -avd test_device -wipe-data

# चल रहे AVD पर APK स्थापित करें
adb -s emulator-5554 install app-release.apk

ADB और AVD: प्रमुख कमांड

AVD लॉन्च करने के बाद, इसके साथ ADB (Android Debug Bridge) के माध्यम से भौतिक उपकरण की तरह ही काम किया जा सकता है। ADB एप्लिकेशन इंस्टॉल करने, इंटेंट लॉन्च करने, इवेंट (कॉल, SMS, GPS) का अनुकरण करने, स्क्रीनशॉट लेने और स्क्रीन वीडियो रिकॉर्ड करने की अनुमति देता है। यह AVD को स्वचालित परीक्षण के लिए एक पूर्ण वातावरण बनाता है।

# कनेक्टेड डिवाइसों की सूची (AVD सहित)
adb devices

# इनकमिंग कॉल का अनुकरण
adb emu gsm call +15551234567

# GPS निर्देशांक का अनुकरण
adb emu geo fix -122.084 37.422

# स्क्रीनशॉट लें
adb exec-out screencap -p > screenshot.png

# SMS भेजें
adb emu sms send +15551234567 "Hello from AVD"

एप्लिकेशन कोड में एमुलेटर की जाँच करना

कभी-कभी डेवलपर को कोड में यह निर्धारित करने की आवश्यकता होती है कि एप्लिकेशन एमुलेटर पर चल रहा है या भौतिक उपकरण पर। यह एनालिटिक्स को अक्षम करने (उत्पादन डेटा को दूषित होने से बचाने के लिए), विस्तारित लॉगिंग सक्षम करने, या हार्डवेयर-निर्भर सुविधाओं को अक्षम करने के लिए आवश्यक हो सकता है जो एमुलेटर पर काम नहीं करती हैं। Google Build वर्ग और सिस्टम गुणों के माध्यम से जाँच के मानक तरीके प्रदान करता है।

Build गुणों के माध्यम से जाँच विधि

object EmulatorDetector {
    fun isEmulator(): Boolean {
        return (Build.BRAND.startsWith("generic") &&
                Build.DEVICE.startsWith("generic")) ||
                Build.FINGERPRINT.startsWith("generic") ||
                Build.FINGERPRINT.startsWith("unknown") ||
                Build.HARDWARE.contains("goldfish") ||
                Build.HARDWARE.contains("ranchu") ||
                Build.MODEL.contains("google_sdk") ||
                Build.MODEL.contains("Emulator") ||
                Build.MODEL.contains("Android SDK")
    }
}

// उपयोग
if (EmulatorDetector.isEmulator()) {
    Log.d("App", "Running on emulator — enable debug mode")
}

सिस्टम गुणों के माध्यम से जाँच करना

एक अतिरिक्त तरीका Build.getRadioVersion() के माध्यम से सिस्टम गुणों को पढ़ना और ro.kernel.qemu की जाँच करना है। एमुलेटर पर, radio version null लौटाता है और qemu गुण 1 पर सेट होता है। यह विधि पुराने Android संस्करणों पर अधिक विश्वसनीय है जहाँ Build.FINGERPRINT डिवाइस निर्माता द्वारा नकली हो सकता है।

fun isRunningOnEmulator(): Boolean {
    // रेडियो संस्करण के माध्यम से जाँच — एमुलेटर पर हमेशा null
    val radioVersion = try {
        Build.getRadioVersion()
    } catch (e: Exception) {
        null
    }
    if (radioVersion.isNullOrBlank()) return true

    // सिस्टम गुणों के माध्यम से जाँच
    return try {
        val props = ProcessBuilder()
            .command("getprop", "ro.kernel.qemu")
            .start()
            .inputStream.bufferedReader().readText().trim()
        props == "1"
    } catch (e: Exception) {
        false
    }
}