Android

Android je mobilní operační systém založený na linuxovém jádře, vyvíjený primárně společností Google. Aplikace pro Android se píšou v Javě nebo Kotlinu a běží uvnitř sandboxovaného prostředí Android Runtime (ART). Každá aplikace má vlastní proces, vlastní instanci virtuálního stroje a vlastní sadu oprávnění.

Základní komponenty aplikace

Každá Android aplikace se skládá ze čtyř základních typů komponent. Každá komponenta má svůj účel a vlastní životní cyklus.

Všechny komponenty musí být deklarovány v souboru AndroidManifest.xml – ten říká systému, jaké komponenty aplikace obsahuje, jaká oprávnění potřebuje (CAMERA, INTERNET, …), a jaké zařízení podporuje.

Životní cykly

Životní cyklus Activity

Activity prochází během své existence definovanými stavy. Android volá odpovídající callback metody, které musí vývojář implementovat.

graph TD
    A[onCreate] --> B[onStart]
    B --> C[onResume]
    C --> |Activity běží| C
    C --> |Překrytí jinou aktivitou| D[onPause]
    D --> |Návrat do aktivity| C
    D --> |Aktivita už není vidět| E[onStop]
    E --> |Návrat do aktivity| F[onRestart]
    F --> B
    E --> |Aktivita je ukončena| G[onDestroy]

Životní cyklus Fragmentu

Fragment je znovupoužitelná část UI, která má vlastní životní cyklus navázaný na hostitelskou Activity. Přidává metody pro připojení/odpojení k aktivitě a vytvoření/zničení view.

ViewModel – přežití rotace

ViewModel je komponenta z Android Jetpack navržená tak, aby uchovávala data související s UI přes změny konfigurace (rotace obrazovky, změna jazyka, …). ViewModel zůstává v paměti, i když se Activity zničí a znovu vytvoří.

class MyViewModel : ViewModel() {
    private val _counter = MutableLiveData(0)
    val counter: LiveData<Int> = _counter

    fun increment() {
        _counter.value = (_counter.value ?: 0) + 1
    }
}

ViewModel se zničí až ve chvíli, kdy Activity definitivně končí (finish(), nikoliv rotace).

Intenty

Intent je objekt pro komunikaci mezi komponentami – používá se ke spouštění aktivit, služeb a odesílání broadcastů. Intent může nést data (extras) ve formě klíč–hodnota.

Explicitní vs. implicitní intenty

// Odeslání
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user_id", 42)
intent.putExtra("user_name", "Jan Novák")
startActivity(intent)

// Příjem v DetailActivity
val userId = intent.getIntExtra("user_id", -1)
val userName = intent.getStringExtra("user_name")

Intent filtry

Aby mohla komponenta reagovat na implicitní intenty, musí v AndroidManifest.xml deklarovat intent filter – jaké akce, kategorie a datové typy přijímá:

<activity android:name=".ShareActivity">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <category android:name="android.intent.category.DEFAULT" />
        <data android:mimeType="text/plain" />
    </intent-filter>
</activity>

Persistentní ukládání dat

Android nabízí několik způsobů, jak ukládat data trvale. Volba závisí na struktuře dat, velikosti a požadavcích na dotazování.

SharedPreferences

Nejjednodušší úložiště – synchronní (starší) API pro ukládání primitivních typů pod řetězcovým klíčem.

val prefs = getSharedPreferences("app_prefs", MODE_PRIVATE)
// Zápis
prefs.edit().putString("username", "jan.novak").apply()
// Čtení
val username = prefs.getString("username", "")

Room

Room je abstrakční vrstva nad SQLite, součást Android Jetpack. Poskytuje compile-time ověření SQL dotazů, podporu LiveData/Flow a anotace pro mapování entit na tabulky.

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    @ColumnInfo(name = "name") val name: String,
    @ColumnInfo(name = "email") val email: String
)

@Dao
interface UserDao {
    @Query("SELECT * FROM users WHERE id = :id")
    suspend fun getUser(id: Int): User

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertUser(user: User)
}

@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

Práce s vlákny

Android je single-threaded UI framework – všechny UI operace musí probíhat na hlavním (UI) vlákně. Dlouhé operace (síť, databáze, výpočty) musí běžet na pozadí, jinak dojde k zamrznutí UI (Application Not Responding – ANR po ~5 sekundách).

Kotlin Coroutines

Coroutines jsou doporučený způsob pro asynchronní programování v Kotlinu. Umožňují psát asynchronní kód sekvenčním stylem pomocí suspend funkcí.

// Dispatchers.Main = UI vlákno (pro aktualizaci UI)
// Dispatchers.IO = síť, soubory, databáze
// Dispatchers.Default = výpočetně náročné operace

viewModelScope.launch(Dispatchers.IO) {
    val user = repository.getUser(42)     // síťový dotaz na pozadí
    withContext(Dispatchers.Main) {
        textView.text = user.name          // UI aktualizace na hlavním vlákně
    }
}

Services

Service je komponenta, která běží na pozadí bez uživatelského rozhraní. Používá se pro dlouhotrvající operace, které mají pokračovat, i když uživatel opustí aplikaci.

WorkManager

WorkManager je knihovna Jetpack pro garantované spouštění práce na pozadí – přežije restart zařízení i ukončení aplikace. Systém sám vybere nejvhodnější způsob provedení (JobScheduler, AlarmManager, Firebase JobDispatcher).

val uploadWork = OneTimeWorkRequestBuilder<UploadWorker>()
    .setConstraints(
        Constraints.Builder()
            .setRequiredNetworkType(NetworkType.UNMETERED) // jen na WiFi
            .build()
    )
    .build()

WorkManager.getInstance(context).enqueue(uploadWork)

Notifikace

Notifikace jsou zprávy zobrazované uživateli mimo UI aplikace – ve stavové liště, na zamčené obrazovce, nebo jako heads-up popup. Jsou hlavním způsobem, jak aplikace komunikuje s uživatelem, když není v popředí.

val channel = NotificationChannel(
    "chat_messages",
    "Chat Messages",
    NotificationManager.IMPORTANCE_HIGH
)
notificationManager.createNotificationChannel(channel)

val notification = NotificationCompat.Builder(this, "chat_messages")
    .setSmallIcon(R.drawable.ic_message)
    .setContentTitle("Nová zpráva")
    .setContentText("Jan: Ahoj, jak se máš?")
    .setPriority(NotificationCompat.PRIORITY_HIGH)
    .addAction(R.drawable.ic_reply, "Odpovědět", replyPendingIntent)
    .build()

notificationManager.notify(1, notification)

Broadcast Receiver

Broadcast Receiver je komponenta, která naslouchá broadcastům – systémovým nebo aplikačním událostem. Když je broadcast odeslán, systém doručí zprávu všem registrovaným receiverům.

// Dynamická registrace
val receiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        when (intent.action) {
            Intent.ACTION_BATTERY_LOW -> showBatteryWarning()
            Intent.ACTION_AIRPLANE_MODE_CHANGED -> updateConnectivityStatus()
        }
    }
}
val filter = IntentFilter().apply {
    addAction(Intent.ACTION_BATTERY_LOW)
    addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED)
}
registerReceiver(receiver, filter)

// Před zničením aktivity
unregisterReceiver(receiver)

LocalBroadcastManager

Pro komunikaci uvnitř vlastní aplikace (bez opuštění procesu) se používá LocalBroadcastManager – je rychlejší a bezpečnější, protože data neopouští aplikaci.

Výměna dat mezi komponentami

Při předávání dat mezi aktivitami, fragmenty nebo procesy existuje několik mechanismů: