Mga Espesyalidad ng Kotlin sa mobile development: ano ito, anong mga konstruksyon at paano ito gumagana

Mga Klase (data class, sealed class, object, companion object)

Kotlin ay nagpapalawak ng mga konsepto ng klase mula sa Java. data class, sealed class, object at companion object — mga konstruksyon na wala sa Java o iba ang implementasyon.

data class vs sealed class

data class — isang klase na awtomatikong bumubuo ng equals(), hashCode(), toString(), copy() at componentN(). Mainam para sa mga data model (DTO, Entity). Mga kinakailangan: kahit isang parameter sa primary constructor, val/var, hindi maaaring open/sealed/inner. sealed class — isang klase na may limitadong hierarchy ng subclass. Lahat ng subclass ay alam sa oras ng kompilasyon at idineklara sa parehong file. Ang expression na when na may sealed class ay hindi nangangailangan ng else branch. sealed interface (Kotlin 1.9+) — kapareho ng sealed class ngunit pinapayagan ang maramihang mana. object — singleton, idineklara gamit ang keyword na object (hindi class). Thread-safe na lazy initialization. companion object — mga static na miyembro ng isang klase. May pangalan (default ay Companion). Maaaring mag-implement ng mga interface at magkaroon ng extension functions.

data class — para sa 90% ng mga modelo. sealed class — para sa UI State at Resulta. object — para sa mga singleton. Inirerekomenda ng IT Sectr ang sealed class para sa lahat ng estado ng screen (Loading, Success, Error).

Sealed class sa praktika

Sealed class — isang makapangyarihang tool para sa pagmomodelo ng mga estado. Halimbawa: UiState<T> na may mga subclass na Loading, Success(data: T), Error(message: String). Ginagarantiyahan ng expression na when ang paghawak sa lahat ng estado. Sealed interface — para sa mga event at aksyon kung saan kailangan ang maramihang implementasyon. Value class (Kotlin 1.5+) — isang wrapper para sa iisang halaga nang walang overhead. Ginagamit para sa type-safe na mga identifier: @JvmInline value class UserId(val id: String).

Mga Function (extension, inline, higher-order, scope functions)

Extension Function — pagdaragdag ng method sa umiiral na klase nang walang mana. fun String.isEmail(): Boolean. Extension Property — pareho para sa mga property (walang backing field). Inline Function — pagpasok ng body ng function sa lugar ng tawag — walang overhead ng tawag. Ginagamit para sa higher-order function na may lambda. Higher-Order Function — isang function na tumatanggap o nagbabalik ng ibang function. Scope Functions — limang function para sa pagtatrabaho sa konteksto ng object: let, run, with, apply, also.

Scope Functions

let — konteksto it, nagbabalik ng resulta ng lambda. Ginagamit para sa null-safe na tawag (?.let {}). apply — konteksto this, nagbabalik ng konteksto. Para sa pagsasaayos ng object. run — konteksto this, nagbabalik ng resulta ng lambda. Para sa pagkalkula na may konteksto. also — konteksto it, nagbabalik ng konteksto. Para sa side effects (pag-log). with — hindi extension, konteksto this, nagbabalik ng resulta ng lambda. Para sa grupo ng mga operasyon sa isang object. Lambda — anonymous function. Destructuring Declaration — pag-unpack ng data class sa mga variable: val (name, age) = person.

Inline + reified

Inline function na may reified — ang tanging paraan upang mapanatili ang generic type sa JVM. Ginagamit para sa: type-safe builder (Gson.fromJson<T>()), pagsusuri ng uri (is T), pagkuha ng klase (T::class). Crossinline at Noinline — mga modifier para sa lambda parameter sa inline function. crossinline — nagbabawal ng non-local return, noinline — nagbabawal ng inlining ng partikular na lambda. Inirerekomenda ng IT Sectr ang inline + reified lamang kapag nagtatrabaho sa mga uri; para sa ordinaryong higher-order function, ang inline ay maaaring magpataas ng laki ng bytecode.

Coroutines (Coroutine Builder, Dispatchers, Scope)

Coroutines — magaang na thread para sa asynchronous programming. Hindi hinaharangan ang thread — nagsususpend. suspend function — isang function na maaaring isuspend nang hindi hinaharangan ang thread. Maaari lamang tawagin mula sa isang coroutine o ibang suspend function.

CoroutineScope

CoroutineScope — isang saklaw para sa coroutines. Naglalaman ng CoroutineContext (Job + Dispatcher). lifecycleScope — para sa Activity/Fragment (Lifecycle-aware). viewModelScope — para sa ViewModel (awtomatikong pagkansela sa onCleared()). GlobalScope — pandaigdigang saklaw (huwag gamitin sa produksyon — pagtagas ng memorya). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (network/disk), Dispatchers.Default (CPU-intensive), Dispatchers.Unconfined (hindi inirerekomenda). launch — magsimula ng coroutine: Job. async — magsimula na may resulta: Deferred<T>. runBlocking — humaharang na tulay. withContext — nagpapalit ng Dispatcher sa loob ng suspend function.

// Halimbawa coroutines: pagkarga ng data sa ViewModel
class MainViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state: StateFlow<UiState> = _state.asStateFlow()

    fun loadData() {
        viewModelScope.launch {
            _state.value = UiState.Loading
            try {
                val data = withContext(Dispatchers.IO) {
                    repository.fetchData()
                }
                _state.value = UiState.Success(data)
            } catch (e: Exception) {
                _state.value = UiState.Error(e.message)
            }
        }
    }
}

// Parallel na kahilingan gamit ang async
suspend fun loadCombinedData(): CombinedData = coroutineScope {
    val users = async(Dispatchers.IO) { api.getUsers() }
    val posts = async(Dispatchers.IO) { api.getPosts() }
    CombinedData(users.await(), posts.await())
}

viewModelScope.launch — karaniwang paglulunsad ng coroutine sa ViewModel. withContext(Dispatchers.IO) — paglipat sa IO thread para sa kahilingan sa network. Dispatchers ay tumutukoy kung saang thread pool isinasagawa ang coroutine. Inirerekomenda ng IT Sectr ang viewModelScope para sa ViewModel at lifecycleScope para sa Activity/Fragment.

Mga Advanced na Tampok (reified, destructuring, lateinit/lazy)

reified — isang modifier ng uri sa inline function. Pinapayagan ang paggamit ng uri: T::class, is T, as T. Kung walang reified, ang generics sa JVM ay nabubura (type erasure). inline fun + reified — isang malakas na kombinasyon para sa type-safe API. Destructuring Declaration — val (x, y) = point. Gumagana para sa data class at mga uri na may componentN(). typealias — alias ng uri: typealias Callback = (String) -> Unit. lateinit — naantalang pagsisimula ng var (para sa dependency injection). Hindi thread-safe. lazy — lazy na pagsisimula ng val (default ay thread-safe). lazy(LazyThreadSafetyMode.NONE) — walang synchronization. Extension function at Extension property — pagdaragdag ng functionality nang walang mana. Ang Kotlin ay isang wika kung saan ang extension functions ay lumulutas ng 90% ng mga gawaing utility.

Mga Delegadong Property

Delegated Properties — pag-delegate ng getter/setter sa ibang object. Mga karaniwang delegado: lazy, observable, vetoable, map. Custom na delegado sa pamamagitan ng getValue/setValue operator. by — keyword ng delegasyon: val name by lazy { loadName() }. Ang mga delegadong property ay pundasyon para sa ViewModel delegado (by viewModels()). Inirerekomenda ng IT Sectr ang lazy para sa naantalang pagsisimula at Delegates.observable para sa pagmamasid ng mga pagbabago.

reified — para sa type-safe API. lazy — para sa naantalang pag-load. delegated properties — para sa muling paggamit ng lohika ng property. Inirerekomenda ng IT Sectr na master ang lahat ng tampok na ito para sa epektibong pag-develop ng Kotlin.

Flow at StateFlow

Flow — malamig na asynchronous data stream sa Kotlin. Naglalabas ng mga halaga ayon sa kahilingan ng collector. StateFlow — mainit na Flow na may iisang kasalukuyang halaga. Ginagamit sa ViewModel para sa UI State. SharedFlow — mainit na Flow para sa mga event (isang beses na event). flowOf, asFlow — paggawa ng Flow mula sa mga koleksyon. catch, retry, debounce — mga operator. stateIn, shareIn — conversion ng malamig na Flow sa mainit. Inirerekomenda ng IT Sectr ang StateFlow para sa UI State at SharedFlow para sa mga event (Snackbar, navigation).

class SearchViewModel : ViewModel() {
    private val _query = MutableStateFlow("")
    val suggestions: StateFlow<List<String>> = _query
        .debounce(300)
        .filter { it.length >= 2 }
        .flatMapLatest { repository.search(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun onQueryChanged(query: String) {
        _query.value = query
    }
}

Serialization (kotlinx.serialization, Parcelize)

kotlinx.serialization — library ng Kotlin para sa JSON serialization. @Serializable — anotasyon. @SerialName — custom na pangalan ng field. Sumusuporta: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize para sa Android Parcelable (nang walang manual na implementasyon). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, compile-safe, walang reflection. Moshi — anotasyon + codegen. Inirerekomenda ng IT Sectr ang kotlinx.serialization para sa mga bagong proyekto at Moshi para sa umiiral na.

@Serializable
data class ApiResponse<T>(
    val success: Boolean,
    @SerialName("data") val data: T? = null,
    val error: String? = null
)

@Serializable
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Deserialization
val json = Json { ignoreUnknownKeys = true }
val response = json.decodeFromString<ApiResponse<List<User>>>(jsonString)
println("Users: ${response.data?.size ?: 0}")