Android: यह क्या है, सिस्टम आर्किटेक्चर और Kotlin में डेवलपमेंट

Android क्या है?

Android एक मोबाइल ऑपरेटिंग सिस्टम है जो Linux कर्नेल पर आधारित है, जिसे Google द्वारा 2007 से विकसित किया गया है। स्रोत कोड Android Open Source Project (AOSP) के भाग के रूप में Apache 2.0 लाइसेंस के तहत खुला है। प्रत्येक निर्माता सिस्टम को संशोधित कर सकता है और अपने उपकरणों पर स्थापित कर सकता है।

StatCounter (2026) के अनुसार, Android वैश्विक मोबाइल OS बाजार का लगभग 72% हिस्सा रखता है। सबसे बड़े निर्माता Samsung, Xiaomi, Oppo, Vivo, Google Pixel हैं। विखंडन प्लेटफ़ॉर्म की एक प्रमुख समस्या है: विभिन्न OS संस्करणों वाले हज़ारों मॉडल एक साथ उपयोग किए जाते हैं।

Android की आर्किटेक्चर अनुमतियों (permissions) के सिद्धांत पर बनी है: प्रत्येक एप्लिकेशन एक अलग Linux UID के तहत चलता है और केवल अपने डेटा तक पहुंच रखता है। सिस्टम संसाधनों (कैमरा, माइक्रोफ़ोन, संपर्क) तक पहुंच Android 6 (API 23) से शुरू होकर रनटाइम पर Android Permissions के माध्यम से अनुरोधित की जाती है।

Android संस्करण इतिहास

Android 1.0 2008 में HTC Dream पर जारी किया गया था। प्रमुख मील के पत्थर: Android 4.0 Ice Cream Sandwich (फोन और टैबलेट के लिए एकीकृत UI), Android 5.0 Lollipop (Material Design), Android 6.0 (रनटाइम अनुमतियाँ), Android 10 (डार्क थीम, जेस्चर), Android 12 (Material You)। 2023 से, Google ने डेज़र्ट नामों के बिना वार्षिक प्रमुख रिलीज़ पर स्विच किया है।

Android आर्किटेक्चर: चार प्रमुख परतें

Android आर्किटेक्चर चार मुख्य परतों से बना है जो हार्डवेयर को उपयोगकर्ता एप्लिकेशन से अलग करती हैं। प्रत्येक परत सख्ती से परिभाषित इंटरफ़ेस के माध्यम से नीचे की परत की सेवाओं का उपयोग करती है।

Linux कर्नेल और HAL

सबसे निचली परत एक संशोधित Linux कर्नेल (LTS, Android 15 में संस्करण 6.x) है। यह मेमोरी प्रबंधन, प्रक्रियाओं, नेटवर्क स्टैक और ड्राइवरों को संभालता है। Hardware Abstraction Layer (HAL) हार्डवेयर के साथ इंटरफ़ेस करने के लिए एक एकीकृत API प्रदान करता है: कैमरा, Bluetooth, Wi-Fi, सेंसर। निर्माता ऊपरी परतों को प्रभावित किए बिना HAL मॉड्यूल लागू करते हैं।

Android Runtime (ART)

ART एप्लिकेशन के DEX बाइटकोड को निष्पादित करता है। Android 5.0 से शुरू होकर, ART ने Dalvik को बदल दिया और प्रदर्शन में सुधार के लिए Ahead-of-Time (AOT) संकलन का उपयोग करता है। प्रत्येक एप्लिकेशन की अपनी प्रक्रिया एक अलग ART इंस्टेंस के साथ होती है। कचरा संग्रह (GC) न्यूनतम ठहराव के साथ चलता है — एक विशिष्ट GC ठहराव 2-4 ms है।

Application Framework

Framework वह परत है जिसके साथ डेवलपर सीधे काम करता है। इसमें Activity Manager (स्क्रीन स्टैक), Content Providers (डेटा एक्सेस), Resource Manager (लोकलाइज़ेशन, संसाधन), Notification Manager, Location Manager शामिल हैं। सभी सिस्टम सेवाएँ Binder IPC — Android के इंटर-प्रोसेस संचार तंत्र के माध्यम से कॉल की जाती हैं।

// AIDL इंटरफ़ेस के माध्यम से Binder के साथ काम करने का उदाहरण
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// सेवा कार्यान्वयन
class DataService : Service() {
    private val binder = object : IDataService.Stub() {
        override fun getData(): List<DataItem> = repository.getAll()
        override fun saveData(item: DataItem): Boolean = repository.save(item)
    }

    override fun onBind(intent: Intent?): IBinder = binder
}

सिस्टम ऐप्स

शीर्ष परत मानक सिस्टम एप्लिकेशन हैं: फ़ोन, संपर्क, कैमरा, सेटिंग्स, ब्राउज़र। उनके पास उपयोगकर्ता एप्लिकेशन से अधिक विशेषाधिकार नहीं हैं, लेकिन उन्हें तृतीय-पक्ष एप्लिकेशन द्वारा प्रतिस्थापित किया जा सकता है। Android 15 में, सिस्टम एप्लिकेशन निर्माता OTA अपडेट से स्वतंत्र रूप से Google Play System Updates के माध्यम से अपडेट किए जाते हैं।

Kotlin — Android डेवलपमेंट की प्राथमिक भाषा

Kotlin JetBrains की एक स्थिर रूप से टाइप की गई प्रोग्रामिंग भाषा है जो JVM पर चलती है। Google ने 2017 में Google I/O पर Kotlin को आधिकारिक Android भाषा घोषित किया। Kotlin Java के साथ पूरी तरह से संगत है लेकिन इसकी कमियों को दूर करती है: null-safety, डेटा क्लास, एक्सटेंशन फ़ंक्शन और कोरूटीन।

Null Safety और प्रकार

Kotlin की मुख्य विशेषता NullPointerException के खिलाफ अंतर्निहित सुरक्षा है। प्रकार nullable (String?) और non-null (String) में विभाजित हैं। कंपाइलर बिल्ड समय पर nullable एक्सेस की जाँच करता है। Safe call (?.) और Elvis ऑपरेटर (?:) नेस्टेड जाँच के बिना वैकल्पिक मानों के साथ काम को सरल बनाते हैं।

// कोरूटीन और Flow के साथ Kotlin कोड का उदाहरण
data class User(
    val id: Long,
    val name: String,
    val email: String
)

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao
) {
    suspend fun getUser(id: Long): Result<User> {
        return try {
            val cached = dao.getUser(id)
            if (cached != null) {
                return Result.success(cached)
            }
            val remote = api.fetchUser(id)
            dao.insertUser(remote)
            Result.success(remote)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun observeUsers(): Flow<List<User>> {
        return dao.observeAll()
            .map { list -> list.sortedBy { it.name } }
            .flowOn(Dispatchers.Default)
    }
}

उदाहरण एसिंक्रोनस नेटवर्क और डेटाबेस एक्सेस के लिए कोरूटीन (suspend फ़ंक्शन), डेटा परिवर्तनों के रिएक्टिव अवलोकन के लिए Flow, और सुरक्षित त्रुटि प्रबंधन के लिए Result प्रदर्शित करता है। कोरूटीन कॉलबैक और RxJava को थ्रेड ओवरहेड के बिना बदलते हैं।

Kotlin कोरूटीन और Flow

Kotlin कोरूटीन हल्के थ्रेड हैं जो साझा थ्रेड पूल पर चलते हैं। नेटवर्क और डिस्क के लिए Dispatchers.IO, UI के लिए Dispatchers.Main, CPU-गहन कार्यों के लिए Dispatchers.Default। viewModelScope और lifecycleScope घटक नष्ट होने पर कोरूटीन को स्वचालित रूप से रद्द करते हैं।

// कोरूटीन और StateFlow के साथ ViewModel
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    private val _loading = MutableStateFlow(false)
    val loading: StateFlow<Boolean> = _loading.asStateFlow()

    init {
        viewModelScope.launch {
            repository.observeUsers().collect { userList ->
                _users.value = userList
            }
        }
    }

    fun refresh() {
        viewModelScope.launch {
            _loading.value = true
            repository.getUser(42).onSuccess { user ->
                _users.value = listOf(user)
            }
            _loading.value = false
        }
    }
}

Android Studio और डेवलपमेंट टूल्स

Android Studio IntelliJ IDEA पर आधारित आधिकारिक IDE है, जिसे Google द्वारा विकसित किया गया है। इसमें कोड एडिटर, Layout Inspector, डिवाइस एमुलेटर, APK Analyzer, Profiler (CPU, मेमोरी, नेटवर्क, ऊर्जा) और Firebase एकीकरण शामिल है। Android Studio 2024 (Ladybug) मल्टीप्लेटफ़ॉर्म KMP मोड के साथ Kotlin 2.0 का समर्थन करता है।

Android एमुलेटर

Android एमुलेटर हार्डवेयर त्वरण के लिए KVM (Linux) या Hyper-V (Windows) का उपयोग करता है। यह GPS, सेंसर, कैमरा, कॉल और SMS के सिमुलेशन का समर्थन करता है। Google Pixel 9 Pro API 35 और 8 GB एमुलेटर RAM के साथ परीक्षण के लिए अनुशंसित कॉन्फ़िगरेशन है।

Android Profiler और डिबगिंग

Profiler वास्तविक समय में CPU लोड, मेमोरी आवंटन, नेटवर्क अनुरोध और ऊर्जा खपत प्रदर्शित करता है। Memory Profiler रेफरेंस ट्री के माध्यम से heap डंपिंग और लीक विश्लेषण की अनुमति देता है। Network Inspector बॉडी और हेडर के साथ सभी HTTP/HTTPS अनुरोधों को रिकॉर्ड करता है। गहन विश्लेषण के लिए Android Studio Canary का उपयोग किया जाता है।

Android एप्लिकेशन के घटक

एक Android एप्लिकेशन चार प्रकार के घटकों से बना होता है, जिनमें से प्रत्येक का अपना प्रवेश बिंदु और जीवनचक्र होता है। घटक AndroidManifest.xml फ़ाइल में पंजीकृत होते हैं।

Activity और Intent

Activity उपयोगकर्ता इंटरफ़ेस का मूल घटक है। प्रत्येक स्क्रीन एक अलग Activity या Activity के अंदर Fragment है। स्क्रीन के बीच नेविगेशन Intent के माध्यम से की जाती है — एक ऑब्जेक्ट जिसमें एक क्रिया (ACTION_VIEW, ACTION_SEND) और डेटा (URI) होता है। Jetpack Navigation Graph में, नेविगेशन XML में वर्णित है।

Service और WorkManager

Service बैकग्राउंड कार्य करता है, लेकिन Android 8 से शुरू होकर, बैकग्राउंड सेवाएँ प्रतिबंधित हैं। WorkManager श्रृंखलाओं, बाधाओं (जैसे, केवल चार्ज करते समय) और क्रैश के बाद पुनरारंभ के समर्थन के साथ विलंबित और गारंटीकृत बैकग्राउंड कार्यों के लिए अनुशंसित लाइब्रेरी है।

Jetpack Compose बनाम XML Layouts

Jetpack Compose और पारंपरिक XML लेआउट के बीच चुनाव Android प्रोजेक्ट शुरू करते समय मुख्य आर्किटेक्चरल निर्णय है। XML Layouts (RecyclerView, ConstraintLayout, FrameLayout) 2008 से मानक रहे हैं। Jetpack Compose को 2021 में एक घोषणात्मक विकल्प के रूप में पेश किया गया था।

Google सभी नए प्रोजेक्ट्स के लिए Jetpack Compose की सिफारिश करता है। XML Layouts लीगेसी प्रोजेक्ट समर्थन और उन मामलों के लिए प्रासंगिक बने हुए हैं जहां अधिकतम View अनुकूलन (Canvas, SurfaceView) की आवश्यकता होती है। Compose कोड समतुल्य XML + ViewBinding की तुलना में औसतन 40% छोटा होता है।

// Jetpack Compose — उपयोगकर्ता प्रोफ़ाइल स्क्रीन
@Composable
fun ProfileScreen(
    user: User,
    onEditClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AsyncImage(
            model = user.avatarUrl,
            contentDescription = "उपयोगकर्ता अवतार",
            modifier = Modifier
                .size(120.dp)
                .clip(CircleShape)
        )

        Spacer(modifier = Modifier.height(16.dp))

        Text(
            text = user.name,
            style = MaterialTheme.typography.headlineMedium
        )

        Text(
            text = user.email,
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(onClick = onEditClick) {
            Icon(Icons.Default.Edit, contentDescription = null)
            Spacer(modifier = Modifier.width(8.dp))
            Text("प्रोफ़ाइल संपादित करें")
        }
    }
}

@Preview(showBackground = true, showSystemUi = true)
@Composable
fun ProfileScreenPreview() {
    MaterialTheme {
        ProfileScreen(
            user = User(1, "अन्ना पेत्रोवा", "anna@example.com"),
            onEditClick = {}
        )
    }
}

ProfileScreen फ़ंक्शन को @Composable के रूप में घोषित किया गया है — यह View इंस्टेंस बनाए बिना UI को घोषणात्मक रूप से वर्णित करता है। Compose user बदलने पर स्वचालित रूप से स्क्रीन अपडेट करता है। @Preview एमुलेटर पर बिल्ड और रन किए बिना सीधे IDE में परिणाम दिखाता है।

Activity और Fragment का जीवनचक्र

Android में प्रत्येक Activity जीवनचक्र की छह अवस्थाओं से गुज़रती है: onCreate, onStart, onResume, onPause, onStop, onDestroy। Fragment onAttach, onCreateView, onViewCreated जोड़ता है। जीवनचक्र को समझना मेमोरी प्रबंधन और लीक को रोकने के लिए महत्वपूर्ण है।

Activity की मुख्य अवस्थाएँ

onCreate — Activity बनने पर एक बार कॉल किया जाता है। यहां इनिशियलाइज़ेशन किया जाता है: setContentView, एडेप्टर सेटअप, LiveData सब्सक्रिप्शन। onResume — Activity अग्रभूमि में है और उपयोगकर्ता के साथ बातचीत कर रही है। onPause — Activity फोकस खो देती है (डायलॉग, दूसरी Activity)। onStop — Activity दिखाई नहीं देती। onDestroy — Activity नष्ट हो जाती है।

// LifecycleScope के माध्यम से जीवनचक्र प्रबंधन के साथ Activity
class MainActivity : ComponentActivity() {
    private val viewModel: UserViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            MaterialTheme {
                lifecycleScope.launch {
                    repeatOnLifecycle(Lifecycle.State.STARTED) {
                        viewModel.users.collect { users ->
                            updateUi(users)
                        }
                    }
                }
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("last_search", searchQuery)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        searchQuery = savedInstanceState.getString("last_search", "")
    }
}

repeatOnLifecycle का उपयोग सुनिश्चित करता है कि डेटा संग्रह तब रुक जाता है जब Activity बैकग्राउंड में जाती है और अग्रभूमि में लौटने पर फिर से शुरू हो जाती है। यह लीक और अनावश्यक नेटवर्क अनुरोधों को रोकता है। onSaveInstanceState स्क्रीन रोटेशन पर अस्थायी स्थिति सहेजता है।

Google Play: प्रकाशन और आवश्यकताएँ

Google Play आधिकारिक Android ऐप स्टोर है। डेवलपर खाता पंजीकरण की लागत $25 एकमुश्त है। प्रत्येक एप्लिकेशन दुर्भावनापूर्ण कोड, नीति उल्लंघन और गलत अनुमति उपयोग के लिए स्वचालित Google Play Integrity जांच से गुज़रता है।

प्रकाशन आवश्यकताएँ

Google को Android App Bundle (AAB) या APK के माध्यम से एप्लिकेशन हस्ताक्षर की आवश्यकता है। AAB अनुशंसित प्रारूप है, जो प्रत्येक डिवाइस कॉन्फ़िगरेशन के लिए अनुकूलित APK जनरेशन सक्षम करता है। एप्लिकेशन पर एक वैध प्रमाणपत्र के साथ एक कुंजी (keystore) के साथ हस्ताक्षर होना चाहिए। Google Play App Signing Google की ओर से वैकल्पिक कुंजी एन्क्रिप्शन है।

गोपनीयता नीति

व्यक्तिगत डेटा तक पहुंच का अनुरोध करने वाले सभी एप्लिकेशन को गोपनीयता नीति प्रदान करनी होगी। 2024 से, Google को Data Safety घोषणा की आवश्यकता है — एक फ़ॉर्म जो एकत्रित डेटा के प्रकार और प्रसंस्करण उद्देश्यों को निर्दिष्ट करता है। Android 14+ को लक्षित करने वाले एप्लिकेशन को अनुमतियाँ घोषित करने के लिए Declarations API का उपयोग करना चाहिए।