Android: что это такое, архитектура системы и разработка на Kotlin

Что такое Android?

Android — мобильная операционная система на базе ядра Linux, разрабатываемая Google с 2007 года. Исходный код открыт под лицензией Apache 2.0 в рамках проекта Android Open Source Project (AOSP). Каждый производитель может модифицировать систему и устанавливать на свои устройства.

По данным StatCounter (2026), Android занимает около 72% мирового рынка мобильных ОС. Крупнейшие производители — Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Фрагментация — ключевая проблема платформы: одновременно используются тысячи моделей с разными версиями ОС.

Архитектура Android построена на принципе привилегий (permissions): каждое приложение работает под отдельным UID Linux и имеет доступ только к своим данным. Доступ к системным ресурсам (камера, микрофон, контакты) запрашивается через Android Permissions во время выполнения, начиная с Android 6 (API 23).

История версий Android

Android 1.0 вышел в 2008 году на HTC Dream. Ключевые вехи: Android 4.0 Ice Cream Sandwich (единый UI для телефонов и планшетов), Android 5.0 Lollipop (Material Design), Android 6.0 (runtime permissions), Android 10 (тёмная тема, жесты), Android 12 (Material You). С 2023 года Google перешла на ежегодные мажорные релизы без десертных названий.

Архитектура Android: четыре ключевых слоя

Архитектура Android состоит из четырёх основных слоёв, изолирующих аппаратное обеспечение от пользовательских приложений. Каждый слой использует сервисы нижележащего через строго определённые интерфейсы.

Ядро Linux и HAL

Нижний слой — модифицированное ядро Linux (LTS, версия 6.x в Android 15). Оно обеспечивает управление памятью, процессами, сетевым стеком и драйверами. 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 pause составляет 2–4 мс.

Application Framework

Framework — слой, с которым напрямую работает разработчик. Включает Activity Manager (стэк экранов), Content Providers (доступ к данным), Resource Manager (локализация, ресурсы), Notification Manager, Location Manager. Все системные сервисы вызываются через Binder IPC — механизм межпроцессного взаимодействия Android.

// Пример работы с Binder через AIDL-интерфейс
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
}

System Apps

Верхний слой — стандартные системные приложения: Phone, Contacts, Camera, Settings, Browser. Они не имеют привилегий выше пользовательских, но могут быть заменены сторонними приложениями. В Android 15 системные приложения обновляются через Google Play System Updates независимо от OTA-обновлений производителя.

Kotlin — основной язык Android-разработки

Kotlin — статически типизированный язык программирования от JetBrains, работающий поверх JVM. Google объявила Kotlin официальным языком Android в 2017 году на Google I/O. Kotlin полностью совместим с Java, но устраняет её недостатки: null-safety, data классы, функции-расширения и корутины.

Null Safety и типы

Главная особенность Kotlin — встроенная защита от NullPointerException. Типы разделены на nullable (String?) и non-null (String). Компилятор проверяет nullable-доступ на этапе сборки. Safe call (?.) и Elvis-оператор (?:) упрощают работу с опциональными значениями без вложенных проверок.

// Пример Kotlin-кода с корутинами и Flow
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 function) для асинхронного доступа к сети и базе данных, Flow для реактивного наблюдения за изменениями данных и Result для безопасной обработки ошибок. Корутины заменяют callbacks и RxJava без накладных расходов на потоки.

Kotlin Coroutines и Flow

Корутины Kotlin — это легковесные потоки, запускаемые на общем пуле потоков. Dispatchers.IO для сети и диска, Dispatchers.Main для UI, Dispatchers.Default для CPU-интенсивных задач. viewModelScope и lifecycleScope автоматически отменяют корутины при уничтожении компонента.

// ViewModel с корутинами и StateFlow
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 — официальная IDE на базе IntelliJ IDEA, разработанная Google. Включает редактор кода, Layout Inspector, эмулятор устройств, APK Analyzer, Profiler (CPU, Memory, Network, Energy) и интеграцию с Firebase. Android Studio 2024 (Ladybug) поддерживает Kotlin 2.0 с мультиплатформенным режимом KMP.

Эмулятор Android

Android Emulator использует KVM (Linux) или Hyper-V (Windows) для аппаратного ускорения. Поддерживает симуляцию GPS, датчиков, камеры, звонков и SMS. Google Pixel 9 Pro — рекомендуемая конфигурация для тестирования с API 35 и 8 ГБ RAM эмулятора.

Android Profiler и отладка

Profiler в реальном времени отображает загрузку CPU, выделение памяти, сетевые запросы и энергопотребление. Memory Profiler позволяет дампить heap и анализировать утечки через reference tree. Network Inspector записывает все HTTP/HTTPS запросы с телом и заголовками. Для глубокого анализа используется Android Studio Canary.

Компоненты Android-приложения

Android-приложение состоит из четырёх типов компонентов, каждый из которых имеет собственную точку входа и жизненный цикл. Компоненты регистрируются в манифесте AndroidManifest.xml.

Activity и Intent

Activity — базовый компонент пользовательского интерфейса. Каждый экран — отдельная Activity или Fragment внутри Activity. Навигация между экранами выполняется через Intent — объект, содержащий действие (ACTION_VIEW, ACTION_SEND) и данные (URI). В Jetpack Navigation Graph навигация описывается в XML.

Service и WorkManager

Service выполняет фоновые задачи, но начиная с Android 8, фоновые службы ограничены. WorkManager — рекомендуемая библиотека для отложенных и гарантированных фоновых задач с поддержкой цепочек, ограничений (например, только при зарядке) и перезапуска после краша.

Jetpack Compose vs XML Layouts

Выбор между Jetpack Compose и традиционной XML-вёрсткой — главное архитектурное решение при старте Android-проекта. XML Layouts (RecyclerView, ConstraintLayout, FrameLayout) — стандарт с 2008 года. Jetpack Compose представлен в 2021 году как декларативная альтернатива.

Google рекомендует Jetpack Compose для всех новых проектов. XML Layouts остаются актуальными для поддержки легаси-проектов и для случаев, когда нужна максимальная кастомизация View (Canvas, SurfaceView). Compose-код в среднем на 40% короче эквивалентного XML + ViewBinding.

// 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 — она описывает UI декларативно, без создания экземпляров View. Compose автоматически обновляет экран при изменении user. @Preview показывает результат прямо в IDE без сборки и запуска на эмуляторе.

Жизненный цикл Activity и Fragment

Каждая Activity в Android проходит через шесть состояний жизненного цикла: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment добавляет onAttach, onCreateView, onViewCreated. Понимание жизненного цикла критично для управления памятью и предотвращения утечек.

Основные состояния Activity

onCreate — вызывается один раз при создании Activity. Здесь выполняется инициализация: setContentView, настройка адаптеров, подписка на LiveData. onResume — Activity на переднем плане и взаимодействует с пользователем. onPause — Activity теряет фокус (диалог, другая Activity). onStop — Activity не видна. onDestroy — Activity уничтожается.

// Activity с обработкой жизненного цикла через LifecycleScope
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 на наличие вредоносного кода, нарушений политик и некорректного использования permissions.

Требования к публикации

Google требует подпись приложения через Android App Bundle (AAB) или APK. AAB — рекомендуемый формат, позволяющий генерировать оптимизированные APK для каждой конфигурации устройства. Приложение должно быть подписано ключом (keystore) с валидным сертификатом. Google Play App Signing — опциональное шифрование ключа на стороне Google.

Политика конфиденциальности

Все приложения, запрашивающие доступ к личным данным, обязаны предоставить политику конфиденциальности (Privacy Policy). С 2024 года Google требует декларировать Data Safety — форму с указанием типов собираемых данных и целей обработки. Приложения для Android 14+ должны использовать Declarations API для объявления разрешений.