Lompat ke konten Lompat ke sidebar Lompat ke footer
Beranda / Android / Kotlin

Panduan Lengkap Belajar Membuat Aplikasi Android Kotlin Untuk Pemula

Posting Komentar
Artikel kali ini menjelaskan mengenai Panduan lengkap untuk belajar menbuat aplikasi android dengan kotlin untuk pemula, tentunya banyak hal yang akan kita pelajari pada artikel kali ini, mengenai dasar pemrograman kotlin sampai membuat aplikasi sederhana dengan android studio dan kotlin. tentunya banyak hal yang akan teman- teman pelajari pada artikel ini mengenai Panduan lengkap belajar membuat aplikasi android kotlin untuk pemula, silahkan simak dan pahami pembahasan dibawah ini.

Pembahasan Awal  

Saat kalian membuat suatu aplikasi Android, kemungkinan hal pertama yang tentunya akan teman- teman lakukan adalah merencanakan dan merencanakan bagaimana kalian akan mengambil alih dunia ini. Hanya bercanda :). Sebenarnya, hal pertama yang harus teman- teman lakukan adalah membuat suatu Aktivitas (activity). Aktivitas merupakan tempat semua tindakan terjadi, karena merupakan layar yang dapat memungkinkan pengguna berinteraksi dengan aplikasi yang telam- teman buat.

Singkatnya, activities merupakan salah satu dasar penyusun aplikasi Android.

Dalam Tutorial Pengantar Aktivitas (activities) Android ini, Teman- teman tentunya akan mempelajari cara bekerja dengan aktivitas. Teman- teman akan membuat suatu aplikasi daftar tugas yang disebut dengan Forget Me Not pada sepanjang waktu belajar:
  • Proses untuk membuat, memulai serta untuk menghentikan suatu activities, dan bagaimana menangani navigasi antar activities.
  • Berbagai tahapan dalam siklus hidup atau sering disebut lifecycle merupakan suatu kegiatan dan bagaimana menangani setiap tahapan dengan baik.
  • Cara mengelola perubahan suatu konfigurasi serta mempertahankan data dalam suatu activity teman-teman.
Selain itu, Teman- teman juga akan menggunakan bahasa pemrograman Kotlin dan juga menggunakan Android Studio 3.3. Teman- teman harus menggunakan Kotlin 1.3.21 atau yang lebih baru dan Android Studio 3.3.2 atau yang lebih baru.

Tutorial ini mengasumsikan teman- teman terbiasa dengan dasar-dasar pengembangan aplikai pada Android. Jika teman- teman benar-benar baru mengenal Kotlin, XML ataupun Android Studio.

Memulai Android Studio dengan Kotlin

Unduh proyek pemula menggunakan suatu tombol Unduh bahan di bagian atas atau bawah tutorial. Buka Android Studio 3.3.2 atau versi yang lebih baru, dan pilih Buka proyek Android Studio yang sudah ada. Kemudian pilih proyek yang baru saja untuk memulainya.
Subjek pada aplikasi yang akan teman- teman buat adalah Forget Me Not, tentunya merupakan aplikasi sederhana yang dapat memungkinkan kalian untuk menambah dan menghapus tugas dari daftar. Ini juga dapat menampilkan tanggal serta waktu saat ini sehingga teman- teman dapat mengetahui waktu dalam pemakaian aplikasi ini

Jalankan proyek seperti sekarang dan Anda akan melihat layar yang sangat mendasar:
Pada gambar diatas tentunya, tidak banyak yang dapat teman- teman lakukan. Daftar tugas masih kosong dan hanya terdapat tombol "ADD A TASK" ketika teman- teman tekan tombol tersebut belum memberikan respon apa- apa. Tujuan teman- teman adalah dapat menghidupkan layar tersebut dengan membuat daftar tugas yang dapat diubah.

Siklus Hidup Aktivitas (Activitas Lifecycle)

Sebelum memulai membuat aplikasinya, silahkan teman- teman baca terlebih dahulu teori dibawah ini:

Seperti yang telah disebutkan sebelumnya, activity merupakan dasar di mana teman- teman dapat membangun suatu layar untuk aplikasi yang teman- teman buat. Mereka dapat mencakup banyak komponen yang dapat berinteraksi dengan penggunanya, serta dapat kemungkinan suatu aplikasi yang teman- teman buat akan memiliki banyak aktivitas untuk dapat menangani berbagai layar yang teman- teman buat.

Dalam menangani berbagai tahapan suatu siklus aktivitas teman- teman tentunya sangat penting untuk dapat menciptakan aplikasi yang kuat dan andal. Siklus hidup suatu kegiatan paling baik dapat kita gambarkan sebagai piramida langkah dari berbagai tahapan yang dihubungkan oleh suatu metode inti panggilan balik, coba perhatikan gambar dibawah ini:
Dengan mengikuti diagram di atas, teman- teman tentunya dapat menggambarkan siklus hidup dalam tindakan saat mengikuti kode teman- teman. Silahkan teman- teman simak maksud dari fungsi dibawah ini:
  • onCreate (): Dipanggil oleh OS saat activities pertama kali dibuat. Di sinilah teman- teman dapat menginisialisasi elemen UI ataupun suatu objek data. Teman- teman juga memiliki saveInstanceState dari activities yang berisi keadaan yang sebelumnya disimpan, serta teman- teman dapat menggunakannya untuk membuat suatu kembali keadaan itu.
  • onStart (): Tepat sebelum menyajikan activity kepada penggunanya, metode ini dipanggil. Itu selalu diikuti oleh onResume (). Di sini, teman- teman biasanya harus memulai animasi UI, konten berbasiskan audio ataupun apa pun yang tentunya memerlukan konten aktivitas pada layar.
  • onResume (): Saat activities memasuki latar depan, metode ini dipanggil. Di sini teman- teman memiliki tempat yang baik untuk dapat memulai kembali animasi, memperbarui elemen UI, memulai kembali pratinjau kamera, melanjutkan pemutaran audio / video ataupun menginisialisasi komponen apa pun yang teman- teman lepaskan selama onPause ().
  • onPause (): Metode ini dipanggil sebelum meluncur ke latar belakang. Di sini teman- teman harus menghentikan visual atau audio yang terkait dengan aktivitas seperti animasi UI, pemutaran musik ataupun kamera. Metode ini diikuti oleh onResume () jika aktivitas kembali ke latar depan atau dengan onStop () jika menjadi tersembunyi.
  • onStop (): Metode ini dipanggil tepat setelah onPause (), ketika activity tidak lagi terlihat oleh pengguna, dan ini merupakan tempat yang baik untuk dapat menyimpan data yang ingin teman- teman komit ke disk. Itu diikuti oleh onRestart (), jika activity ini kembali ke latar depan, atau onDestroy () jika dilepaskan dari memori.
  • onRestart (): Dipanggil setelah menghentikan suatu kegiatan, tetapi sesaat sebelum memulai lagi. Selalu diikuti oleh onStart ().
  • onDestroy (): Ini adalah panggilan balik terakhir yang akan teman- teman terima dari OS sebelum aktivitas dihancurkan/ dihapus. Teman- teman dapat memicu penghancuran aktivitas dengan memanggil finish (), atau dapat dipicu oleh sistem saat sistem perlu mengganti memori. Jika aktivitas teman- teman menyertakan utas latar belakang ataupun sumber daya lain yang telah berjalan lama, kerusakan dapat menyebabkan kebocoran memori jika tidak dilepaskan, jadi teman- teman harus ingat untuk menghentikan proses ini di sini
Catatan: Teman -teman tidak memanggil salah satu dari metode panggilan balik di atas secara langsung dalam suatu kode Anda sendiri (selain dari pemanggilan superclass) - Teman- teman hanya menimpanya jika diperlukan dalam subclass aktivitas kalian. Mereka dipanggil oleh OS ketika pengguna membuka, menyembunyikan ataupun keluar dari aktivitas.
Begitu banyak metode untuk diingat! Di bagian berikutnya, teman- teman akan melihat beberapa metode siklus hidup ini dalam aksi, dan kemudian akan jauh lebih mudah untuk mengingat apa yang semuanya lakukan.

Mengkonfigurasi Aktivitas (Configuring an Activity)

Ingatlah siklus hidup aktivitas, lihatlah aktivitas di proyek sampel. Buka MainActivity.kt, dan teman- teman akan melihat bahwa kelas dengan onCreate () override-nya terlihat seperti script dibawh ini :
class MainActivity : AppCompatActivity() {
  // 1
  private val taskList: MutableList<String> = mutableListOf()
  private val adapter by lazy { makeAdapter(taskList) }

  override fun onCreate(savedInstanceState: Bundle?) {
    // 2
    super.onCreate(savedInstanceState)
    // 3
    setContentView(R.layout.activity_main)
    // 4
    taskListView.adapter = adapter
    // 5
    taskListView.onItemClickListener =AdapterView.OnItemClickListener{ parent, view, position, id -> }
  }
  // 6
  fun addTaskClicked(view: View) {
  }
  // 7
  private fun makeAdapter(list: List<String>): ArrayAdapter<String> =
      ArrayAdapter(this, android.R.layout.simple_list_item_1, list)
}
Berikut ini merupakan pembahasan tentang apa yang terjadi di atas:
  1. Teman- teman menginisialisasi properti activities, yang mencakup daftar tugas yang dapat diubah yang dapat diubah dan adaptor yang diinisialisasi menggunakan by lazy.
  2. Teman- teman memanggil onCreate () pada superclass - ingat bahwa ini (biasanya) hal pertama yang harus teman- teman lakukan dalam metode panggilan balik. Ada beberapa kasus tingkat lanjut di mana teman- teman dapat memanggil kode sebelum memanggil superclass.
  3. Teman- teman mengatur tampilan konten activities teman- teman dengan sumber daya file tata letak yang sesuai.
  4. Di sini teman- teman mengatur adaptor untuk taskListView. Referensi ke taskListView diinisialisasi menggunakan Kotlin Android Extensions, di mana teman- teman dapat menemukan info lebih lanjut di sini. Ini menggantikan panggilan findViewById () dan kebutuhan untuk pustaka pengikat tampilan lainnya.
  5. Teman- teman menambahkan OnItemClickListener () yang kosong ke ListView untuk dapat menangkap ketukan pengguna pada entri daftar individual. Pendengar merupakan lambda Kotlin.
  6. Metode kosong klik untuk tombol “ADD A TASK”, yang ditentukan oleh tata letak activity_main.xml.
  7. Fungsi pribadi yang menginisialisasi adaptor untuk tampilan daftar. Di sini teman- teman menggunakan sintaks Kotlin = untuk fungsi ekspresi-tunggal.
Implementasi teman- teman mengikuti teori di bagian sebelumnya - kalian melakukan tata letak, adaptor, dan inisialisasi pendengar klik untuk aktivitas teman-teman selama pembuatan.

Memulai suatu Aktivitas (Starting an Activity)

Dalam kondisi saat ini, aplikasi ini merupakan kumpulan yang tidak berguna dari nol serta nol karena teman- teman tidak dapat menambahkan apa pun ke daftar tugas. Teman- teman memiliki kekuatan untuk mengubahnya, serta itulah yang akan teman- teman lakukan selanjutnya.

Di file MainActivity.kt yang telah teman- teman buka, tambahkan properti ke bagian atas kelas:
private val ADD_TASK_REQUEST = 1
Teman-teman akan menggunakan nilai abadi ini untuk referensi permintaan teman- teman untuk menambahkan tugas baru di kemudian hari.

Kemudian tambahkan pernyataan impor ini di bagian atas file:
import android.content.Intent
Dan tambahkan implementasi berikut untuk addTaskClicked ():
val intent = Intent(this, TaskDescriptionActivity::class.java)
startActivityForResult(intent, ADD_TASK_REQUEST)
Saat pengguna mengetuk tombol "ADD A TASK", OS Android memanggil metode addTaskClicked (). Di sini teman- teman membuat Intent untuk dapat meluncurkan TaskDescriptionActivity dari suatu MainActivity.
Catatan: Akan ada kesalahan kompilasi karena teman-teman belum mendefinisikan TaskDescriptionActivity.
Teman- teman dapat memulai aktivitas dengan baik startActivity () atau startActivityForResult (). Mereka serupa kecuali bahwa startActivityForResult () akan menghasilkan onActivityResult () dipanggil setelah TaskDescriptionActivity selesai. teman-teman akan menerapkan panggilan balik ini nanti sehingga kalian dapat mengetahui apakah ada tugas baru untuk ditambahkan ke daftar kalian atau tidak.

Tetapi pertama-tama, kalian perlu cara untuk memasukkan tugas baru di Forget Me Not - teman- teman akan melakukannya dengan membuat TaskDescriptionActivity.

Membuat Aktivitas

Android Studio membuatnya sangat mudah untuk membuat suatu kegiatan. Cukup klik kanan pada paket tempat Anda ingin menambahkan aktivitas - dalam hal ini, paketnya adalah com.raywenderlich.android.forgetmenot. Lalu navigasikan ke New \ Activity, dan pilih Empty Activity, yang merupakan templat dasar untuk suatu aktivitas:
Buka di Google Terjemahan

Pada layar berikutnya, masukkan TaskDescriptionActivity karena Nama Aktivitas dan Android Studio akan secara otomatis mengisi bidang lain berdasarkan itu.
Klik Selesai, teman- teman baru saja membuat aktivitas pertama!

Android Studio akan secara otomatis menghasilkan sumber daya terkait yang diperlukan untuk membuat aktivitas. Ini adalah:
  • Class: File kelas bernama TaskDescriptionActivity.kt. Di sinilah kalian menerapkan perilaku aktivitas. Class ini harus mensubclass kelas Aktivitas atau subclass yang ada, seperti AppCompatActivity.
  • Layout: File layout terletak di bawah res / layout / dan bernama activity_task_description.xml. Ini menentukan penempatan berbagai elemen UI di layar saat aktivitas dibuat.
File tata letak yang dibuat dari templat Aktivitas Kosong di Android Studio 3.0 dan di atas default untuk menggunakan ConstraintLayout untuk grup tampilan root..

Selain itu, Teman- teman akan melihat tambahan baru untuk file AndroidManifest.xml aplikasi Teman- teman:
<activity android:name=".TaskDescriptionActivity"></activity>
Elemen aktivitas menyatakan aktivitas. Aplikasi Android memiliki rasa ketertiban yang kuat, sehingga semua kegiatan yang tersedia harus dinyatakan dalam manifes untuk memastikan aplikasi hanya memiliki kendali atas kegiatan yang dinyatakan di sini. Teman- teman tidak ingin aplikasi teman-teman secara tidak sengaja menggunakan aktivitas yang salah, atau bahkan lebih buruk, membuatnya menggunakan aktivitas yang digunakan oleh aplikasi lain tanpa izin eksplisit.

Ada beberapa atribut yang dapat Teman- teman sertakan dalam elemen ini untuk menentukan properti untuk aktivitas, seperti label atau ikon, atau tema untuk menata UI aktivitas.

android: name adalah satu-satunya atribut yang diperlukan. Ini menentukan nama kelas aktivitas relatif terhadap paket aplikasi (karenanya periode di awal).

Sekarang bangun dan jalankan aplikasi. Ketika Anda menekan ADD A TASK, teman-teman disajikan dengan aktivitas kalian yang baru dibuat!

Di TaskDescriptionActivity yang baru Anda buat, tempel berikut ini ke file kelas kalian, timpa apa pun selain deklarasi kelas dan kurungnya.
// 1
companion object {
  val EXTRA_TASK_DESCRIPTION = "task"
}
// 2
override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_task_description)
}
// 3
fun doneClicked(view: View) {
}
Catatan: Teman- teman dapat dengan cepat memperbaiki import yang hilang yang dikeluhkan oleh Android Studio dengan menempatkan kursor Anda pada item dan menekan opsi + return pada Mac atau Alt + Enter pada PC.
Di sini, Teman- teman telah mencapai yang berikut:

Menggunakan objek pendamping Kotlin untuk kelas untuk mendefinisikan atribut umum di seluruh kelas, mirip dengan anggota statis di Jawa.
Ganti metode siklus hidup onCreate () untuk mengatur tampilan konten untuk aktivitas dari file tata letak.
Menambahkan handler klik kosong yang akan digunakan untuk menyelesaikan aktivitas.
Beralih ke tata letak terkait di res / tata letak / activity_task_description.xml dan ganti semuanya dengan script berikut ini:
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:padding="@dimen/default_padding"
  tools:context="com.raywenderlich.android.forgetmenot.TaskDescriptionActivity">

  <TextView
    android:id="@+id/descriptionLabel"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:padding="@dimen/default_padding"
    android:text="@string/description"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />

  <EditText
    android:id="@+id/descriptionText"
    android:layout_width="match_parent"
    android:layout_height="100dp"
    android:inputType="textMultiLine"
    android:padding="@dimen/default_padding"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toBottomOf="@+id/descriptionLabel" />

  <Button
    android:id="@+id/doneButton"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="doneClicked"
    android:padding="@dimen/default_padding"
    android:text="@string/done"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintTop_toBottomOf="@+id/descriptionText" />

</android.support.constraint.ConstraintLayout>
Di sini teman- teman mengubah tata letak sehingga ada TextView meminta deskripsi tugas, EditText bagi pengguna untuk memasukkan deskripsi, dan tombol Selesai untuk menyimpan tugas baru.

Jalankan lagi aplikasi, ketuk ADD A TASK dan layar baru kalian akan terlihat jauh lebih menarik.

Menghentikan Aktivitas

Sama pentingnya dengan memulai aktivitas dengan semua metode yang tepat juga menghentikannya.

Di TaskDescriptionActivity.kt, tambahkan impor ini, termasuk import untuk Kotlin Android Extensions:
import android.app.Activity
import android.content.Intent
import kotlinx.android.synthetic.main.activity_task_description.*
Kemudian tambahkan berikut ini ke doneClicked (), yang dipanggil saat tombol Selesai diketuk dalam aktivitas ini:
// 1
val taskDescription = descriptionText.text.toString()
if (!taskDescription.isEmpty()) {
  // 2
  val result = Intent()
  result.putExtra(EXTRA_TASK_DESCRIPTION, taskDescription)
  setResult(Activity.RESULT_OK, result)
} else {
  // 3
  setResult(Activity.RESULT_CANCELED)
}
// 4
finish()

Teman-teman dapat melihat beberapa hal yang terjadi di sini:
  1. Kalian mengambil deskripsi tugas dari descriptionText EditText, tempat Kotlin Android Extensions telah digunakan lagi untuk mendapatkan referensi untuk melihat bidang.
  2. Teman- teman membuat hasil yang ingin kembali ke MainActivity jika deskripsi tugas diambil pada langkah satu tidak kosong. Kemudian teman- teman bundel uraian tugas dengan maksud dan atur hasil aktivitas ke RESULT_OK, yang menunjukkan bahwa pengguna berhasil memasukkan tugas.
  3. Jika pengguna belum memasukkan deskripsi tugas, teman- teman mengatur hasil aktivitas ke RESULT_CANCELED.
  4. Di sini teman- teman menutup aktivitas.
Setelah teman-teman memanggil finish() pada langkah empat, panggilan balik onActivityResult () akan dipanggil di MainActivity - pada gilirannya, teman- teman Anda perlu menambahkan tugas ke daftar yang harus dilakukan.

Tambahkan metode berikut ke MainActivity.kt, tepat setelah onCreate:
override fun onActivityResult (requestCode: Int,resultCode: Int,data: Intent?) {
  // 1
  if (requestCode == ADD_TASK_REQUEST) {
    // 2
    if (resultCode == Activity.RESULT_OK) {
      // 3
      val task = data?.getStringExtra(TaskDescriptionActivity.EXTRA_TASK_DESCRIPTION)
      task?.let {
        taskList.add(task)
        // 4
        adapter.notifyDataSetChanged()
      }
    }
  }
}
Mari kita selangkah demi selangkah:
  1. Teman-teman  memeriksa requestCode untuk memastikan hasil aktivitas memang untuk permintaan tugas tambahan kalian, kalian mulai dengan TaskDescriptionActivity.
  2. Kalian memastikan resultCode merupakan RESULT_OK - hasil aktivitas standar untuk operasi yang sukses.
  3. Di sini kalian mengekstrak deskripsi tugas dari maksud hasil, setelah pemeriksaan nol dengan fungsi let, tambahkan ke daftar yang kalian buat.
  4. Akhirnya, Anda memanggil notifyDataSetChanged () pada adaptor daftar kalian. Pada gilirannya, ini memberi tahu ListView tentang perubahan dalam model data kalian sehingga dapat memicu penyegaran tampilan.
Bangun dan jalankan proyek untuk melihatnya hasilnya. Setelah aplikasi dimulai, ketuk ADD A TASK. Ini akan memunculkan layar baru yang memungkinkan teman- teman memasukkan tugas. Sekarang tambahkan deskripsi serta ketuk Selesai. Layar akan ditutup dan tugas baru akan ada di daftar kalian:

Mendaftarkan Penerima Siaran

Setiap daftar tugas harus memiliki pemahaman yang baik tentang tanggal dan waktu, jadi tampilan waktu harus menjadi hal berikutnya yang teman- teman tambahkan ke aplikasi yang teman- teman buat. Buka MainActivity.kt dan tambahkan yang berikut setelah deklarasi properti yang ada di atas:
private val tickReceiver by lazy { makeBroadcastReceiver() }
Kemudian tambahkan objek pendamping di dekat bagian atas MainActivity:
companion object {
  private const val LOG_TAG = "MainActivityLog"

  private fun getCurrentTimeStamp(): String {
    val simpleDateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.US)
    val now = Date()
    return simpleDateFormat.format(now)
  }
}
Dan inisialisasi tickReceiver dengan menambahkan yang berikut ke bagian bawah MainActivity:
private fun makeBroadcastReceiver(): BroadcastReceiver {
  return object : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent?) {
      if (intent?.action == Intent.ACTION_TIME_TICK) {
        dateTimeTextView.text = getCurrentTimeStamp()
      }
    }
  }
}
Di sini, Anda membuat BroadcastReceiver yang menetapkan tanggal dan waktu di layar jika menerima siaran perubahan waktu dari sistem. Kalian menggunakan getCurrentTimeStamp (), yang merupakan metode utilitas dalam aktivitas kalian, untuk memformat tanggal dan waktu saat ini.

Selanjutnya tambahkan metode berikut ke MainActivity di bawah onCreate ():
override fun onResume() {
  // 1
  super.onResume()
  // 2
  dateTimeTextView.text = getCurrentTimeStamp()
  // 3
  registerReceiver(tickReceiver, IntentFilter(Intent.ACTION_TIME_TICK))
}

override fun onPause() {
  // 4
  super.onPause()
  // 5
  try {
    unregisterReceiver(tickReceiver)
  } catch (e: IllegalArgumentException) {
    Log.e(MainActivity.LOG_TAG, "Time tick Receiver not registered", e)
  }
}
Di sini Anda melakukan beberapa hal:
  1. Teman- teman memanggil Resume () pada superclass.
  2. Teman- teman memperbarui tanggal dan waktu TextView dengan cap waktu saat ini, karena penerima siaran saat ini tidak terdaftar.
  3. Kalian kemudian mendaftarkan penerima siaran di onResume (). Ini memastikan ia akan menerima siaran untuk ACTION_TIME_TICK. Ini dikirim setiap menit setelah perubahan waktu.
  4. Di onPause (), Kalian pertama kali memanggil onPause () pada superclass.
  5. Teman- teman kemudian membatalkan registrasi penerima siaran di onPause (), sehingga aktivitas tidak lagi menerima waktu mengubah siaran saat dijeda. Ini mengurangi overhead sistem yang tidak perlu.
Bangun dan jalankan aplikasi. Sekarang kalian seharusnya melihat tanggal dan waktu saat ini di bagian atas layar. Bahkan jika kalian menavigasi ke layar tambahkan tugas dan kembali, waktu masih diperbarui.

Persisting State

Setiap daftar kegiatan harus pandai mengingat apa yang perlu kalian lakukan, kecuali teman kalian Forget Me Not. Sayangnya, aplikasi ini cukup pelupa saat ini. Lihat sendiri.

Buka aplikasi dan ikuti langkah-langkah ini.
  • Ketuk ADD A TASK.
  • Masukkan "Ganti biasa dengan decaf di ruang istirahat" sebagai deskripsi tugas dan ketuk Selesai. Kalian akan melihat tugas baru kalian dalam daftar.
  • Tutup aplikasi dari aplikasi terbaru.
  • Buka aplikasi lagi.

Data yang Ada Di Antara Peluncuran

Buka MainActivity.kt, dan tambahkan properti berikut ke atas kelas:
private val PREFS_TASKS = "prefs_tasks"
private val KEY_TASKS_LIST = "tasks_list"
Dan tambahkan berikut ini di bawah sisa metode siklus aktivitas Kalian.
override fun onStop() {
  super.onStop()

  // Save all data which you want to persist.
  val savedList = StringBuilder()
  for (task in taskList) {
    savedList.append(task)
    savedList.append(",")
  }

  getSharedPreferences(PREFS_TASKS, Context.MODE_PRIVATE).edit()
      .putString(KEY_TASKS_LIST, savedList.toString()).apply()
}
Di sini kalian membuat string yang dipisahkan koma dengan semua deskripsi tugas di daftar kalian, dan kemudian kalian menyimpan string ke SharedPreferences di callback onStop (). Seperti disebutkan sebelumnya, onStop () merupakan tempat yang baik untuk menyimpan data yang ingin kalian pertahankan di seluruh penggunaan aplikasi.

Selanjutnya tambahkan yang berikut ke onCreate () di bawah kode inisialisasi yang ada:
val savedList = getSharedPreferences(PREFS_TASKS, Context.MODE_PRIVATE).getString(KEY_TASKS_LIST, null)
if (savedList != null) {
  val items = savedList.split(",".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
  taskList.addAll(items)
}
Di sini Teman- teman membaca daftar tersimpan dari SharedPreferences serta menginisialisasi daftar tugas dengan mengonversi string yang dipisahkan koma yang diambil menjadi array yang diketik.
Catatan: Kalian menggunakan SharedPreferences karena kalian hanya menyimpan tipe data primitif. Untuk data yang lebih kompleks, kalian dapat menggunakan berbagai opsi penyimpanan yang tersedia di Android.
Sekarang, bangun dan jalankan aplikasi. Tambahkan tugas, tutup dan buka kembali aplikasi. Apakah kalian melihat perbedaan? kalian sekarang dapat mempertahankan tugas dalam daftar Anda!

Perubahan Konfigurasi

Anda memerlukan kemampuan untuk menghapus entri dari Forget Me Not.

Masih di MainActivity.kt, di bagian bawah kelas tambahkan:
private fun taskSelected(position: Int) {
  // 1
  AlertDialog.Builder(this)
    // 2
    .setTitle(R.string.alert_title)
    // 3
    .setMessage(taskList[position])
    .setPositiveButton(R.string.delete, { _, _ ->
      taskList.removeAt(position)
      adapter.notifyDataSetChanged()
    })
    .setNegativeButton(R.string.cancel, {
      dialog, _ -> dialog.cancel()
    })
    // 4
    .create()
    // 5
    .show()
}
Singkatnya, Teman- teman membuat serta menampilkan dialog peringatan ketika kalian memilih tugas dari daftar. Berikut ini penjelasan langkah demi langkah:
  • Kalian membuat AlertDialog.Builder yang memfasilitasi pembuatan AlertDialog.
  • Kalian mengatur judul dialog lansiran.
  • Kalian mengatur pesan dialog lansiran menjadi deskripsi tugas yang dipilih. Lalu kalian juga menerapkan PositiveButton untuk menghapus item dari daftar dan menyegarkannya, dan Tombol Negatif untuk mengabaikan dialog.
  • Kalian membuat dialog lansiran.
  • Kalian menampilkan dialog lansiran kepada pengguna.
Perbarui OnItemClickListener dari taskListView di onCreate ():
taskListView.onItemClickListener = AdapterView.OnItemClickListener { _, _, position, _ ->
  taskSelected(position)
}
Aplikasi Kalian tidak akan dikompilasi sampai kalian menentukan beberapa string. Merupakan praktik yang baik untuk memisahkan teks yang kalian inginkan di aplikasi dari kode. Alasannya adalah agar kalian dapat dengan mudah mengubahnya, yang sangat berguna untuk teks yang kalian gunakan di banyak tempat. Ini juga berguna saat kalian perlu menerjemahkan aplikasi ke bahasa lain.

Untuk mengkonfigurasi string, buka res / values ​​/ strings.xml dan di dalam elemen sumber daya tambahkan:
<string name="alert_title">Task</string>
<string name="delete">Delete</string>
<string name="cancel">Cancel</string>
Bangun dan jalankan aplikasi. Ketuk salah satu tugas. Anda akan melihat dialog lansiran dengan opsi untuk CANCEL atau DELETE tugas dari daftar:
Sekarang coba putar perangkat. (Pastikan kalian memiliki rotasi dalam pengaturan perangkat yang diatur ke auto-rotate.)

Segera setelah kalain memutar perangkat, dialog peringatan dibubarkan. Ini membuat pengalaman pengguna yang tidak dapat diandalkan dan tidak diinginkan - pengguna tidak menyukainya ketika hal-hal hilang begitu saja dari layar mereka tanpa alasan.

Menangani Perubahan Konfigurasi

Perubahan konfigurasi, seperti rotasi, visibilitas keyboard, dan sebagainya, menyebabkan aktivitas mati dan hidup kembali. Teman- teman dapat menemukan daftar lengkap peristiwa sistem yang menyebabkan aktivitas diciptakan kembali di sini.

Ada beberapa cara untuk menangani perubahan konfigurasi.

Salah satu caranya adalah sebagai berikut. Di AndroidManifest.xml, cari tag awal:
<activity android:name=".MainActivity">
ubah script diatas menjadi:
<activity android:name=".MainActivity" android:configChanges="orientation|screenSize">
Di sini, kalian menyatakan bahwa MainActivity kalian akan menangani setiap perubahan konfigurasi yang muncul dari perubahan orientasi atau ukuran layar. Baris sederhana ini mencegah restart aktivitas kalian oleh sistem, dan meneruskan pekerjaan ke MainActivity.

kalian kemudian dapat menangani perubahan konfigurasi ini dengan menerapkan onConfigurationChanged (). Di MainActivity.kt, tambahkan metode berikut setelah onStop ():
override fun onConfigurationChanged(newConfig: Configuration?) {
  super.onConfigurationChanged(newConfig)
}
Di sini kalian hanya memanggil metode superclass onConfigurationChanged () karena kalian tidak memperbarui atau mengatur ulang elemen apa pun berdasarkan rotasi atau ukuran layar.

onConfigurationChanged () meneruskan objek Konfigurasi yang berisi konfigurasi perangkat yang diperbarui.

Dengan membaca bidang dalam konfigurasi baru ini, kalian dapat menentukan konfigurasi baru dan membuat perubahan yang sesuai untuk memperbarui sumber daya yang digunakan di antarmuka kalian.

Sekarang, bangun dan jalankan aplikasi dan putar perangkat lagi. Kali ini, dialog tetap di tempatnya sampai kalian mengabaikannya.
Cara alternatif untuk menangani perubahan konfigurasi adalah mempertahankan objek stateful yang diteruskan ke instance aktivitas yang dibuat ulang. kalian dapat melakukannya dengan menerapkan panggilan balik onSaveInstanceState ().

Ketika kalian melakukan ini, sistem menyimpan status aktivitas kalian dalam sebuah Bundle, dan kalian dapat mengembalikannya ketika kalian menerapkan panggilan balik onRestoreInstanceState () yang sesuai. Namun, Bundle tidak dirancang untuk menampung set data besar seperti bitmap, dan itu hanya bisa menyimpan data yang serial.

Kelemahan dari solusi objek stateful adalah bahwa serialisasi dan deserialisasi data selama perubahan konfigurasi dapat datang dengan biaya tinggi. Itu dapat menghabiskan banyak memori dan memperlambat proses memulai kembali aktivitas.

Kesimpulan

Selamat! Teman- teman baru saja mempelajari dasar-dasar penggunaan aktivitas di Android dan sekarang memiliki pemahaman yang sangat baik tentang siklus hidup aktivitas yang sangat penting.

Kalian membahas beberapa konsep, termasuk:
  • Cara membuat aktivitas
  • Bagaimana cara menghentikan suatu kegiatan
  • Cara mempertahankan data saat suatu aktivitas berhenti
  • Cara mengatasi perubahan konfigurasi
Saya harap teman-teman menikmati pengantar tutorial kegiatan Android ini

Terimakasih telah berkunjung dan membaca artikel ini mengenai Panduan Lengkap Belajar Membuat Aplikasi Android Kotlin Untuk Pemula, semoga teman- teman dapat memahami dan mengikuti artikel ini . semoga bermanfaat -- salam success :)

Writer By: Steve Smith

 Content Writer By: Muhammad Rizal Supriadi  

Anda mungkin menyukai postingan ini