Android: qué es, arquitectura del sistema y desarrollo en Kotlin

¿Qué es Android?

Android es un sistema operativo móvil basado en el núcleo Linux, desarrollado por Google desde 2007. El código fuente es abierto bajo licencia Apache 2.0 como parte del proyecto Android Open Source Project (AOSP). Cada fabricante puede modificar el sistema e instalarlo en sus dispositivos.

Según StatCounter (2026), Android ocupa aproximadamente el 72% del mercado mundial de SO móviles. Los mayores fabricantes son Samsung, Xiaomi, Oppo, Vivo, Google Pixel. La fragmentación es un problema clave de la plataforma: se utilizan simultáneamente miles de modelos con diferentes versiones del SO.

La arquitectura de Android se basa en el principio de permisos (permissions): cada aplicación funciona bajo un UID de Linux independiente y solo tiene acceso a sus propios datos. El acceso a los recursos del sistema (cámara, micrófono, contactos) se solicita mediante Android Permissions en tiempo de ejecución desde Android 6 (API 23).

Historial de versiones de Android

Android 1.0 se lanzó en 2008 en HTC Dream. Hitos clave: Android 4.0 Ice Cream Sandwich (UI unificada para teléfonos y tabletas), Android 5.0 Lollipop (Material Design), Android 6.0 (permisos en tiempo de ejecución), Android 10 (tema oscuro, gestos), Android 12 (Material You). Desde 2023, Google pasó a lanzamientos mayores anuales sin nombres de postres.

Arquitectura de Android: cuatro capas clave

La arquitectura de Android consta de cuatro capas principales que aíslan el hardware de las aplicaciones de usuario. Cada capa utiliza los servicios de la capa inferior a través de interfaces estrictamente definidas.

Núcleo Linux y HAL

La capa inferior es un núcleo Linux modificado (LTS, versión 6.x en Android 15). Maneja la gestión de memoria, procesos, pila de red y controladores. La capa de abstracción de hardware (HAL) proporciona una API unificada para interactuar con el hardware: cámara, Bluetooth, Wi-Fi, sensores. Los fabricantes implementan módulos HAL sin afectar las capas superiores.

Android Runtime (ART)

ART ejecuta el bytecode DEX de las aplicaciones. Desde Android 5.0, ART reemplazó a Dalvik y utiliza compilación Ahead-of-Time (AOT) para mejorar el rendimiento. Cada aplicación tiene su propio proceso con una instancia independiente de ART. La recolección de basura (GC) funciona con pausas mínimas — una pausa típica de GC es de 2–4 ms.

Application Framework

El Framework es la capa con la que trabaja directamente el desarrollador. Incluye Activity Manager (pila de pantallas), Content Providers (acceso a datos), Resource Manager (localización, recursos), Notification Manager, Location Manager. Todos los servicios del sistema se invocan a través de Binder IPC — el mecanismo de comunicación entre procesos de Android.

// Ejemplo de trabajo con Binder a través de interfaz AIDL
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Implementación del servicio
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
}

Aplicaciones del sistema

La capa superior consta de aplicaciones estándar del sistema: Teléfono, Contactos, Cámara, Ajustes, Navegador. No tienen privilegios superiores a las aplicaciones de usuario, pero pueden ser reemplazadas por aplicaciones de terceros. En Android 15, las aplicaciones del sistema se actualizan mediante Google Play System Updates independientemente de las actualizaciones OTA del fabricante.

Kotlin — lenguaje principal de desarrollo Android

Kotlin es un lenguaje de programación estáticamente tipado de JetBrains que funciona sobre la JVM. Google anunció Kotlin como lenguaje oficial de Android en 2017 en Google I/O. Kotlin es totalmente compatible con Java pero elimina sus deficiencias: null-safety, clases de datos, funciones de extensión y corrutinas.

Seguridad de nulos y tipos

La característica principal de Kotlin es la protección integrada contra NullPointerException. Los tipos se dividen en nullable (String?) y non-null (String). El compilador verifica el acceso nullable en tiempo de compilación. El operador safe call (?.) y el operador Elvis (?:) simplifican el trabajo con valores opcionales sin comprobaciones anidadas.

// Ejemplo de código Kotlin con corrutinas y 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)
    }
}

El ejemplo demuestra corrutinas (función suspend) para acceso asíncrono a red y base de datos, Flow para observación reactiva de cambios de datos y Result para manejo seguro de errores. Las corrutinas reemplazan callbacks y RxJava sin sobrecarga de hilos.

Corrutinas y Flow de Kotlin

Las corrutinas de Kotlin son hilos ligeros que se ejecutan en un grupo de hilos compartido. Dispatchers.IO para red y disco, Dispatchers.Main para UI, Dispatchers.Default para tareas intensivas de CPU. viewModelScope y lifecycleScope cancelan automáticamente las corrutinas cuando se destruye el componente.

// ViewModel con corrutinas y 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 y herramientas de desarrollo

Android Studio es el IDE oficial basado en IntelliJ IDEA, desarrollado por Google. Incluye editor de código, Layout Inspector, emulador de dispositivos, APK Analyzer, Profiler (CPU, Memoria, Red, Energía) e integración con Firebase. Android Studio 2024 (Ladybug) es compatible con Kotlin 2.0 con modo multiplataforma KMP.

Emulador de Android

El emulador de Android utiliza KVM (Linux) o Hyper-V (Windows) para aceleración por hardware. Admite simulación de GPS, sensores, cámara, llamadas y SMS. Google Pixel 9 Pro es la configuración recomendada para pruebas con API 35 y 8 GB de RAM de emulador.

Android Profiler y depuración

El Profiler muestra en tiempo real la carga de CPU, asignación de memoria, solicitudes de red y consumo de energía. Memory Profiler permite volcados de heap y análisis de fugas a través del árbol de referencias. Network Inspector registra todas las solicitudes HTTP/HTTPS con cuerpo y encabezados. Para análisis en profundidad se usa Android Studio Canary.

Componentes de una app Android

Una app Android consta de cuatro tipos de componentes, cada uno con su propio punto de entrada y ciclo de vida. Los componentes se registran en el archivo AndroidManifest.xml.

Activity e Intent

Activity es el componente básico de la interfaz de usuario. Cada pantalla es una Activity independiente o un Fragment dentro de una Activity. La navegación entre pantallas se realiza mediante Intent — un objeto que contiene una acción (ACTION_VIEW, ACTION_SEND) y datos (URI). En Jetpack Navigation Graph, la navegación se describe en XML.

Service y WorkManager

Service ejecuta tareas en segundo plano, pero desde Android 8, los servicios en segundo plano están restringidos. WorkManager es la biblioteca recomendada para tareas en segundo plano diferidas y garantizadas con soporte para cadenas, restricciones (por ejemplo, solo durante la carga) y reinicio tras fallo.

Jetpack Compose vs XML Layouts

La elección entre Jetpack Compose y los diseños XML tradicionales es la decisión arquitectónica principal al iniciar un proyecto Android. Los XML Layouts (RecyclerView, ConstraintLayout, FrameLayout) han sido el estándar desde 2008. Jetpack Compose se introdujo en 2021 como alternativa declarativa.

Google recomienda Jetpack Compose para todos los proyectos nuevos. Los XML Layouts siguen siendo relevantes para el soporte de proyectos heredados y para casos donde se necesita máxima personalización de View (Canvas, SurfaceView). El código Compose es en promedio un 40% más corto que el XML + ViewBinding equivalente.

// Jetpack Compose — pantalla de perfil de usuario
@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 = "Avatar del usuario",
            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("Editar perfil")
        }
    }
}

@Preview(showBackground = true, showSystemUi = true)
@Composable
fun ProfileScreenPreview() {
    MaterialTheme {
        ProfileScreen(
            user = User(1, "Anna Petrova", "anna@example.com"),
            onEditClick = {}
        )
    }
}

La función ProfileScreen se declara como @Composable — describe la UI de forma declarativa sin crear instancias de View. Compose actualiza automáticamente la pantalla cuando cambia user. @Preview muestra el resultado directamente en el IDE sin compilar ni ejecutar en el emulador.

Ciclo de vida de Activity y Fragment

Cada Activity en Android pasa por seis estados del ciclo de vida: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment añade onAttach, onCreateView, onViewCreated. Comprender el ciclo de vida es fundamental para la gestión de la memoria y la prevención de fugas.

Estados principales de Activity

onCreate — se llama una vez al crear la Activity. Aquí se realiza la inicialización: setContentView, configuración de adaptadores, suscripción a LiveData. onResume — la Activity está en primer plano e interactúa con el usuario. onPause — la Activity pierde el foco (diálogo, otra Activity). onStop — la Activity no es visible. onDestroy — la Activity se destruye.

// Activity con manejo del ciclo de vida mediante 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", "")
    }
}

El uso de repeatOnLifecycle garantiza que la recopilación de datos se detiene cuando la Activity pasa a segundo plano y se reanuda al volver al primer plano. Esto evita fugas y solicitudes de red innecesarias. onSaveInstanceState guarda el estado temporal al girar la pantalla.

Google Play: publicación y requisitos

Google Play es la tienda oficial de aplicaciones Android. El registro de cuenta de desarrollador cuesta $25 una sola vez. Cada aplicación pasa una verificación automática de Google Play Integrity para detectar código malicioso, violaciones de políticas y uso incorrecto de permisos.

Requisitos de publicación

Google exige la firma de la aplicación mediante Android App Bundle (AAB) o APK. AAB es el formato recomendado, que permite generar APK optimizados para cada configuración de dispositivo. La aplicación debe estar firmada con una clave (keystore) con un certificado válido. Google Play App Signing es un cifrado opcional de la clave por parte de Google.

Política de privacidad

Todas las aplicaciones que solicitan acceso a datos personales deben proporcionar una Política de privacidad. Desde 2024, Google exige una declaración de Data Safety — un formulario que especifica los tipos de datos recopilados y los fines del procesamiento. Las aplicaciones para Android 14+ deben usar la API de Declaraciones para declarar permisos.