Google berkomitmen untuk mendorong terwujudnya keadilan ras bagi komunitas Kulit Hitam. Lihat caranya.

Android KTX   Bagian dari Android Jetpack.

Android KTX adalah kumpulan ekstensi Kotlin yang disertakan dengan Android Jetpack dan library Android lainnya. Ekstensi KTX menyediakan Kotlin yang ringkas dan idiomatis untuk Jetpack, platform Android, serta API lainnya. Untuk melakukannya, ekstensi ini memanfaatkan beberapa fitur bahasa Kotlin, termasuk yang berikut:

  • Fungsi ekstensi
  • Properti ekstensi
  • Lambda
  • Parameter bernama
  • Nilai default parameter
  • Coroutine

Sebagai contoh, saat menangani SharedPreferences, Anda harus membuat editor sebelum dapat memodifikasi data preferensi. Anda juga harus menerapkan atau melakukan commit perubahan tersebut setelah selesai mengedit, seperti yang ditunjukkan pada contoh berikut:

sharedPreferences
        .edit()  // create an Editor
        .putBoolean("key", value)
        .apply() // write to disk asynchronously

Lambda Kotlin sangat cocok untuk kasus penggunaan ini. Hal ini memungkinkan Anda melakukan pendekatan lebih singkat dengan meneruskan blok kode untuk dijalankan setelah editor dibuat, memungkinkan kode dieksekusi, dan memungkinkan SharedPreferences API menerapkan perubahan secara atomic.

Berikut adalah contoh salah satu fungsi Inti Android KTX, SharedPreferences.edit, yang menambahkan fungsi edit ke SharedPreferences. Fungsi ini menggunakan flag boolean opsional sebagai argumen pertamanya yang menunjukkan apakah akan melakukan commit atau menerapkan perubahan. Fungsi tersebut juga menerima tindakan untuk dilakukan pada editor SharedPreferences dalam bentuk lambda.

// SharedPreferences.edit extension function signature from Android KTX - Core
// inline fun SharedPreferences.edit(
//         commit: Boolean = false,
//         action: SharedPreferences.Editor.() -> Unit)

// Commit a new value asynchronously
sharedPreferences.edit { putBoolean("key", value) }

// Commit a new value synchronously
sharedPreferences.edit(commit = true) { putBoolean("key", value) }

Pemanggil dapat memilih apakah akan melakukan commit atau menerapkan perubahan. Lambda action sendiri merupakan fungsi ekstensi anonim pada SharedPreferences.Editor yang menampilkan Unit, seperti yang ditunjukkan oleh tanda tangannya. Inilah sebabnya mengapa di dalam blok Anda bisa melakukan pekerjaan langsung di SharedPreferences.Editor.

Terakhir, tanda tangan SharedPreferences.edit() berisi kata kunci inline. Kata kunci ini memberi tahu compiler Kotlin agar menyalin dan menempelkan (atau inline) bytecode yang dikompilasi untuk fungsi setiap kali fungsi tersebut digunakan. Hal ini demi menghindari overhead membuat instance class baru untuk masing-masing action setiap kali fungsi ini dipanggil.

Pola kode penerusan ini menggunakan lambda, menerapkan default logis yang dapat diganti, dan menambahkan perilaku ini ke API yang ada menggunakan fungsi ekstensi inline adalah penyempurnaan standar yang disediakan oleh library Android KTX.

Menggunakan Android KTX di project Anda

Untuk mulai menggunakan Android KTX, tambahkan dependensi berikut ke file build.gradle project Anda:

repositories {
    google()
}

Modul AndroidX

Android KTX diatur dalam beberapa modul, yang masing-masing berisi satu atau beberapa paket.

Anda harus menyertakan dependensi untuk setiap artefak modul pada file build.gradle aplikasi Anda. Ingat untuk menambahkan nomor versi ke artefak. Anda dapat menemukan nomor versi terbaru di setiap bagian yang terkait dengan artefak dalam topik ini.

Android KTX berisi satu modul inti yang menyediakan ekstensi Kotlin untuk API framework umum dan beberapa ekstensi khusus domain.

Dengan pengecualian modul inti, semua artefak modul KTX menggantikan dependensi Java yang mendasarinya pada file build.gradle. Misalnya, Anda dapat mengganti dependensi androidx.fragment:fragment dengan androidx.fragment:fragment-ktx. Sintaksis ini membantu mengelola pembuatan versi yang lebih optimal dan tidak menambahkan persyaratan deklarasi dependensi tambahan.

KTX Inti

Modul KTX Inti menyediakan ekstensi untuk library umum yang merupakan bagian dari framework Android. Library ini tidak memiliki dependensi berbasis Java yang perlu Anda tambahkan ke build.gradle.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

dependencies {
    implementation "androidx.core:core-ktx:1.3.1"
}

Berikut daftar paket yang terdapat dalam modul KTX Inti:

KTX Collection

Ekstensi Collection berisi fungsi utilitas untuk menangani library koleksi Android yang hemat memori, termasuk ArrayMap, LongParseArray, LruCache, dan lainnya.

Untuk menggunakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.collection:collection-ktx:1.1.0"
    }
    

Ekstensi Collection memanfaatkan overload operator Kotlin untuk menyederhanakan hal-hal seperti penyambungan koleksi, seperti pada contoh berikut:

// Combine 2 ArraySets into 1.
val combinedArraySet = arraySetOf(1, 2, 3) + arraySetOf(4, 5, 6)

// Combine with numbers to create a new sets.
val newArraySet = combinedArraySet + 7 + 8

KTX Fragmen

Modul KTX Fragmen menyediakan sejumlah ekstensi untuk menyederhanakan API fragmen.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

dependencies {
    implementation "androidx.fragment:fragment-ktx:1.2.5"
}

Dengan modul KTX Fragmen, Anda dapat menyederhanakan transaksi fragmen dengan lambda, misalnya:

fragmentManager().commit {
   addToBackStack("...")
   setCustomAnimations(
           R.anim.enter_anim,
           R.anim.exit_anim)
   add(fragment, "...")
}

Anda juga dapat mengikat ke ViewModel dalam satu baris menggunakan delegasi properti viewModels dan activityViewModels:

// Get a reference to the ViewModel scoped to this Fragment
val viewModel by viewModels<MyViewModel>()

// Get a reference to the ViewModel scoped to its Activity
val viewModel by activityViewModels<MyViewModel>()

KTX Siklus Proses

KTX Siklus Proses menentukan LifecycleScope untuk setiap objek Lifecycle. Setiap coroutine yang diluncurkan dalam cakupan ini dibatalkan saat Lifecycle dihapus. Anda dapat mengakses CoroutineScope dari Lifecycle menggunakan properti lifecycle.coroutineScope atau lifecycleOwner.lifecycleScope.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0"
    }
    

Contoh berikut menunjukkan cara menggunakan lifecycleOwner.lifecycleScope untuk membuat teks yang telah melalui prakomputasi secara asinkron:

class MyFragment: Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewLifecycleOwner.lifecycleScope.launch {
            val params = TextViewCompat.getTextMetricsParams(textView)
            val precomputedText = withContext(Dispatchers.Default) {
                PrecomputedTextCompat.create(longTextContent, params)
            }
            TextViewCompat.setPrecomputedText(textView, precomputedText)
        }
    }
}

KTX LiveData

Saat menggunakan LiveData, Anda mungkin perlu menghitung nilai secara asinkron. Misalnya, Anda mungkin ingin mengambil preferensi pengguna dan menayangkannya ke UI Anda. Untuk situasi ini, KTX LiveData menyediakan fungsi builder liveData yang memanggil fungsi suspend dan menayangkan hasilnya sebagai objek LiveData.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0"
    }
    

Dalam contoh berikut, loadUser() adalah fungsi penangguhan yang dideklarasikan di tempat lain. Anda dapat menggunakan fungsi builder liveData untuk memanggil loadUser() secara asinkron, lalu menggunakan emit() untuk menampilkan hasilnya:

val user: LiveData<User> = liveData {
    val data = database.loadUser() // loadUser is a suspend function.
    emit(data)
}

Untuk informasi selengkapnya tentang cara menggunakan coroutine dengan LiveData, lihat Menggunakan coroutine Kotlin dengan komponen Arsitektur.

Setiap komponen library Navigation memiliki versi KTX-nya sendiri yang menyesuaikan API agar Kotlin lebih ringkas dan idiomatis.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

dependencies {
    implementation "androidx.navigation:navigation-runtime-ktx:2.3.0"
    implementation "androidx.navigation:navigation-fragment-ktx:2.3.0"
    implementation "androidx.navigation:navigation-ui-ktx:2.3.0"
}

Gunakan fungsi ekstensi dan delegasi properti untuk mengakses argumen tujuan dan beralih ke tujuan, seperti pada contoh berikut:

class MyDestination : Fragment() {

    // Type-safe arguments are accessed from the bundle.
    val args by navArgs<MyDestinationArgs>()

    ...
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        view.findViewById<Button>(R.id.next)
            .setOnClickListener {
                // Fragment extension added to retrieve a NavController from
                // any destination.
                findNavController().navigate(R.id.action_to_next_destination)
            }
     }
     ...

}

KTX Palet

Modul KTX Palet menawarkan dukungan Kotlin idiomatis untuk menangani palet warna.

Untuk menggunakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.palette:palette-ktx:1.0.0"
    }
    

Sebagai contoh, saat menangani instance Palette, Anda dapat mengambil swatch selected untuk target tertentu menggunakan operator get ([ ]):

val palette = Palette.from(bitmap).generate()
val swatch = palette[target]

KTX Aliran Reaktif

Modul KTX Aliran Reaktif memungkinkan Anda membuat aliran LiveData yang dapat diamati dari penerbit ReactiveStreams.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.2.0"
    }
    

Sebagai contoh, asumsikan database dengan daftar pengguna yang kecil. Di aplikasi, Anda memuat database ke dalam memori lalu menampilkan data pengguna di UI Anda. Untuk mencapainya, Anda dapat menggunakan RxJava. Komponen Jetpack Room dapat mengambil daftar pengguna sebagai Flowable. Dalam skenario ini, Anda juga harus mengelola langganan penerbit Rx sepanjang umur fragmen atau aktivitas Anda.

Namun, dengan LiveDataReactiveStreams, Anda dapat memperoleh manfaat dari RxJava dan kumpulan operator yang beragam serta kemampuan penjadwalan kerjanya sekaligus menangani kemudahan LiveData, seperti pada contoh berikut:

val fun getUsersLiveData() : LiveData<List<User>> {
    val users: Flowable<List<User>> = dao.findUsers()
    return LiveDataReactiveStreams.fromPublisher(users)
}

KTX Room

Ekstensi Room menambahkan dukungan coroutine untuk transaksi database.

Untuk menggunakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.room:room-ktx:2.2.5"
    }
    

Berikut adalah beberapa contoh untuk Room yang kini menggunakan coroutine. Contoh pertama menggunakan fungsi suspend untuk menampilkan daftar objek User, sedangkan contoh kedua menggunakan Flow Kotlin untuk menampilkan daftar User secara asinkron. Perlu diketahui bahwa saat menggunakan Flow, Anda juga akan diberi tahu tentang perubahan dalam tabel yang sedang diminta.

@Query("SELECT * FROM Users")
suspend fun getUsers(): List<User>

@Query("SELECT * FROM Users")
fun getUsers(): Flow<List<User>>

KTX SQLite

Ekstensi SQLite menggabungkan kode yang terkait dengan SQL dalam transaksi sehingga kode boilerplate tidak lagi diperlukan.

Untuk menggunakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.sqlite:sqlite-ktx:2.1.0"
    }
    

Berikut adalah contoh penggunaan ekstensi transaction untuk melakukan transaksi database:

db.transaction {
    // insert data
}

KTX ViewMode

Library KTX ViewModel menyediakan fungsi viewModelScope() yang menjadikannya mudah untuk meluncurkan coroutine dari ViewModel Anda. CoroutineScope diikat ke Dispatchers.Main dan otomatis dibatalkan jika ViewModel dihapus. Anda dapat menggunakan viewModelScope(), bukan membuat cakupan baru untuk setiap ViewModel.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

    dependencies {
        implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0"
    }
    

Sebagai contoh, fungsi viewModelScope() berikut meluncurkan coroutine yang membuat permintaan jaringan di thread latar belakang. Library menangani semua penyiapan dan pembersihan cakupan yang sesuai:

class MainViewModel : ViewModel() {
    // Make a network request without blocking the UI thread
    private fun makeNetworkRequest() {
        // launch a coroutine in viewModelScope
        viewModelScope.launch  {
            remoteApi.slowFetch()
            ...
        }
    }

    // No need to override onCleared()
}

KTX WorkManager

KTX WorkManager memberikan dukungan utama untuk coroutine.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

dependencies {
    implementation "androidx.work:work-runtime-ktx:2.4.0"
}

Tidak perlu lagi memperluas Worker, Anda kini dapat memperluas CoroutineWorker yang memiliki API yang sedikit berbeda. Misalnya, jika ingin membuat CoroutineWorker sederhana untuk melakukan beberapa operasi jaringan, Anda dapat melakukan langkah berikut:

class CoroutineDownloadWorker(context: Context, params: WorkerParameters)
        : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result = coroutineScope {
        val jobs = (0 until 100).map {
            async {
                downloadSynchronously("https://www.google.com")
            }
        }

        // awaitAll will throw an exception if a download fails, which
        // CoroutineWorker will treat as a failure
        jobs.awaitAll()
        Result.success()
    }
}

Untuk informasi selengkapnya tentang penggunaan CoroutineWorker, lihat Threading di CoroutineWorker.

KTX WorkManager juga menambahkan fungsi ekstensi ke Operations dan ListenableFutures untuk menangguhkan coroutine saat ini.

Berikut adalah contoh yang menangguhkan Operation yang ditampilkan oleh enqueue():

// Inside of a coroutine...

// Run async operation and suspend until completed.
WorkManager.getInstance()
        .beginWith(longWorkRequest)
        .enqueue().await()

// Resume after work completes...

Modul KTX lainnya

Anda juga dapat menyertakan modul KTX tambahan yang ada di luar AndroidX.

KTX Firebase

Beberapa Firebase SDK untuk Android memiliki library ekstensi Kotlin yang memungkinkan Anda menulis kode Kotlin idiomatis saat menggunakan Firebase dalam aplikasi. Untuk informasi selengkapnya, lihat topik berikut:

Google Maps Platform KTX

Ada ekstensi KTX yang tersedia untuk SDK Android Google Maps Platform yang memungkinkan Anda memanfaatkan beberapa fitur bahasa Kotlin seperti fungsi ekstensi, parameter bernama dan argumen default, deklarasi penataan, dan coroutine. Untuk informasi selengkapnya, lihat topik berikut:

KTX Play Core

KTX Play Core menambahkan dukungan pada coroutine Kotlin untuk permintaan satu kali dan Alur untuk memantau pembaruan status dengan menambahkan fungsi ekstensi ke SplitInstallManager dan AppUpdateManager di library Play Core.

Untuk menyertakan modul ini, tambahkan kode berikut ke file build.gradle aplikasi Anda:

dependencies {
    implementation "com.google.android.play:core-ktx:1.8.1"
}

Berikut adalah contoh Flow pemantauan status:

// Inside of a coroutine...

// Request in-app update status updates.
manager.requestUpdateFlow().collect { updateResult ->
    when (updateResult) {
        is AppUpdateResult.Available -> TODO()
        is AppUpdateResult.InProgress -> TODO()
        is AppUpdateResult.Downloaded -> TODO()
        AppUpdateResult.NotAvailable -> TODO()
    }
}

Informasi selengkapnya

Untuk mempelajari lebih lanjut tentang Android KTX, lihat video DevBytes.

Untuk melaporkan masalah atau menyarankan fitur, gunakan Issue tracker Android KTX.