Activity — vad är det, app-skärm i Android och dess Lifecycle

Vad är Activity?

Activity — den viktigaste komponenten i en Android-app som tillhandahåller ett fönster för interaktion med användaren. Varje Activity hanterar en separat skärm: uppgiftslista, inloggningsformulär, fotovisning. Android-systemet skapar Activity på begäran och förstör det när minnet behövs för andra appar.

Activity dök först upp i Android 1.0 (2008) och förblir den viktigaste byggstenen i gränssnittet. Enligt Google (2026) innehåller 98% av apparna i Google Play minst en Activity. I modern arkitektur rekommenderar Google en Activity med många Fragment, men den klassiska flerskärmsappen förblir en vanlig praxis.

Activity stack (back stack) — uppgiftsstacken som lagrar navigeringshistorik. När användaren trycker på „Tillbaka“ förstörs den aktuella Activity och den föregående återställs. Systemet hanterar stacken automatiskt, men utvecklaren kan kontrollera beteendet genom launchMode och Intent-flaggor.

Activitys livscykel

Livscykeln för Activity — uppsättningen tillstånd och callbacks som skärmen går igenom från skapande till förstöring. Att förstå Lifecycle är avgörande: felaktigt arbete med tillstånd leder till minnesläckor, dataförlust och appkrascher.

Android-systemet anropar callbacks i strikt ordning. Utvecklaren åsidosätter nödvändiga metoder för att initiera resurser, spara data och frigöra minne. Varje callback har ett par: onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

Activitys tillstånd

Fyra tillstånd för Activity särskiljs: Running (onResume aktiv), Paused (synligt men utan fokus), Stopped (osynligt), Destroyed (förstört). Systemet kan döda Activity i tillståndet Stopped vid minnesbrist — data måste sparas i onSaveInstanceState.

Livscykelmetoder: onCreate, onStart, onResume

Låt oss undersöka tre viktiga metoder i Activitys livscykel med ett exempel i Kotlin. onCreate — startpunkt, anropas en gång. Här sker kopplingen av layout via setContentView, initiering av RecyclerView, prenumeration på LiveData. onStart — Activity blir synligt för användaren. onResume — Activity får fokus och är redo för interaktion.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val recyclerView = findViewById<RecyclerView>(R.id.rv_items)
        recyclerView.layoutManager = LinearLayoutManager(this)
        loadItems()
    }

    override fun onStart() {
        super.onStart()
        startLocationUpdates()
    }

    override fun onResume() {
        super.onResume()
        resumeVideoPlayer()
    }
}

I exemplet initierar onCreate RecyclerView och laddar data. onStart startar geolokaliseringsuppdatering — en resurs som endast ska fungera när skärmen är synlig. onResume återupptar videon som stoppades i onPause. Sådan uppdelning förhindrar onödigt arbete i bakgrunden.

Deklarera Activity i AndroidManifest.xml

Varje Activity måste deklareras i filen AndroidManifest.xml. Utan registrering hittar systemet inte skärmen och kastar ett undantag ActivityNotFoundException. I manifestet anges klassnamn, tema, orientering, launchMode och Intent-filter.

<application
    android:allowBackup="true"
    android:label="@string/app_name"
    android:theme="@style/Theme.MyApp">

    <activity
        android:name=".MainActivity"
        android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <activity
        android:name=".DetailActivity"
        android:parentActivityName=".MainActivity" />
</application>

Flaggan exported avgör om andra appar kan starta Activity. För huvudskärmen exported=true, för interna skärmar — false. Attributet parentActivityName aktiverar standardnavigeringen „Upp“ (Up Navigation).

Starta Activity via Intent

Intent — ett objekt som beskriver en åtgärd som ska utföras. I Activity-sammanhang används Intent för att starta en annan skärm med dataöverföring. Intent kan vara explicit (pekar på en specifik klass) och implicit (pekar på en åtgärd, systemet väljer lämplig komponent).

// Explicit Intent — starta DetailActivity med data
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Ta emot data i DetailActivity
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

För att ta emot resultat från den startade Activity används Activity Result API, som ersatte den föråldrade startActivityForResult. Det nya API:t är typsäkert, deklarativt och fungerar med Jetpack Compose.

private val getResult = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val data = result.data?.getStringExtra("result_key")
    }
}

fun openPicker() {
    val intent = Intent(this, PickerActivity::class.java)
    getResult.launch(intent)
}

Spara tillstånd vid återskapning

Vid skärmrotation eller konfigurationsändring återskapar Android Activity — det anropar sekventiellt onDestroy och onCreate. Utan att spara tillstånd förlorar användaren inmatade data, scrollposition och valda element. För att lösa detta problem tillhandahåller Android två mekanismer: onSaveInstanceState och ViewModel.

onSaveInstanceState sparar enkla data i Bundle före anropet av onDestroy. ViewModel från Jetpack motstår återskapning av Activity och lagrar data i minnet, vilket är effektivare för komplexa objekt och nätverksförfrågningar.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // ViewModel sparar automatiskt data
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("scroll_position", recyclerView.computeVerticalScrollOffset())
    }
}

Single Activity-arkitektur och Jetpack

Googles moderna tillvägagångssätt — Single Activity-arkitektur med en Activity och många Fragment. Appen använder en MainActivity och all navigering utförs av Navigation Component via NavHostFragment. Fördelar: centraliserad navigering, delad ViewModel per skärm, korrekt arbete med Deep Links.

Jetpack Navigation Component automatiserar arbetet med back stack, övergångsanimationer och argumentöverföring. NavHostFragment placeras i Activitys layout och navigeringsgrafen (NavGraph) beskriver alla skärmar och kopplingar mellan dem. Detta tillvägagångssätt rekommenderas av Google för nya projekt och överensstämmer med Material Design-principerna.

class MainActivity : AppCompatActivity() {

    private val navController by lazy {
        findViewById<NavHostFragment>(R.id.nav_host_fragment)
            .navController
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Konfiguration av NavigationUI för AppBar
        setupActionBarWithNavController(navController)
    }

    override fun onSupportNavigateUp() = 
        navController.navigateUp() || super.onSupportNavigateUp()
}