Android Room とビュー - Kotlin

apply plugin: 'kotlin-kapt' 

android {     // other configuration (buildTypes, defaultConfig, etc.)      packagingOptions {         exclude 'META-INF/atomicfu.kotlin_module'     }      kotlinOptions {         jvmTarget = "1.8"     }  } 

dependencies {     implementation "androidx.appcompat:appcompat:$rootProject.appCompatVersion"     implementation "androidx.activity:activity-ktx:$rootProject.activityVersion"      // Dependencies for working with Architecture components     // You'll probably have to update the version numbers in build.gradle (Project)      // Room components     implementation "androidx.room:room-ktx:$rootProject.roomVersion"     kapt "androidx.room:room-compiler:$rootProject.roomVersion"     androidTestImplementation "androidx.room:room-testing:$rootProject.roomVersion"      // Lifecycle components     implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$rootProject.lifecycleVersion"     implementation "androidx.lifecycle:lifecycle-livedata-ktx:$rootProject.lifecycleVersion"     implementation "androidx.lifecycle:lifecycle-common-java8:$rootProject.lifecycleVersion"      // Kotlin components     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"     api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$rootProject.coroutines"     api "org.jetbrains.kotlinx:kotlinx-coroutines-android:$rootProject.coroutines"      // UI     implementation "androidx.constraintlayout:constraintlayout:$rootProject.constraintLayoutVersion"     implementation "com.google.android.material:material:$rootProject.materialVersion"      // Testing     testImplementation "junit:junit:$rootProject.junitVersion"     androidTestImplementation "androidx.arch.core:core-testing:$rootProject.coreTestingVersion"     androidTestImplementation ("androidx.test.espresso:espresso-core:$rootProject.espressoVersion", {         exclude group: 'com.android.support', module: 'support-annotations'     })     androidTestImplementation "androidx.test.ext:junit:$rootProject.androidxJunitVersion" } 

ext {     activityVersion = '1.1.0'     appCompatVersion = '1.2.0'     constraintLayoutVersion = '2.0.2'     coreTestingVersion = '2.1.0'     coroutines = '1.3.9'     lifecycleVersion = '2.2.0'     materialVersion = '1.2.1'     roomVersion = '2.2.5'     // testing     junitVersion = '4.13.1'     espressoVersion = '3.1.0'     androidxJunitVersion = '1.1.2' } 

data class Word(val word: String) 

@Entity(tableName = "word_table") class Word(@PrimaryKey @ColumnInfo(name = "word") val word: String) 

@Dao interface WordDao {      @Query("SELECT * FROM word_table ORDER BY word ASC")     fun getAlphabetizedWords(): List<Word>      @Insert(onConflict = OnConflictStrategy.IGNORE)     suspend fun insert(word: Word)      @Query("DELETE FROM word_table")     suspend fun deleteAll() } 

   @Query("SELECT * FROM word_table ORDER BY word ASC")    fun getAlphabetizedWords(): Flow<List<Word>> 

// Annotates class to be a Room Database with a table (entity) of the Word class @Database(entities = arrayOf(Word::class), version = 1, exportSchema = false) public abstract class WordRoomDatabase : RoomDatabase() {     abstract fun wordDao(): WordDao     companion object {         // Singleton prevents multiple instances of database opening at the         // same time.         @Volatile         private var INSTANCE: WordRoomDatabase? = null          fun getDatabase(context: Context): WordRoomDatabase {             // if the INSTANCE is not null, then return it,             // if it is, then create the database             return INSTANCE ?: synchronized(this) {                 val instance = Room.databaseBuilder(                         context.applicationContext,                         WordRoomDatabase::class.java,                         "word_database"                     ).build()                 INSTANCE = instance                 // return instance                 instance             }         }    } } 

// Declares the DAO as a private property in the constructor. Pass in the DAO // instead of the whole database, because you only need access to the DAO class WordRepository(private val wordDao: WordDao) {      // Room executes all queries on a separate thread.     // Observed Flow will notify the observer when the data has changed.     val allWords: Flow<List<Word>> = wordDao.getAlphabetizedWords()      // By default Room runs suspend queries off the main thread, therefore, we don't need to     // implement anything else to ensure we're not doing long running database work     // off the main thread.     @Suppress("RedundantSuspendModifier")     @WorkerThread     suspend fun insert(word: Word) {         wordDao.insert(word)     } } 

class WordViewModel(private val repository: WordRepository) : ViewModel() {      // Using LiveData and caching what allWords returns has several benefits:     // - We can put an observer on the data (instead of polling for changes) and only update the     //   the UI when the data actually changes.     // - Repository is completely separated from the UI through the ViewModel.     val allWords: LiveData<List<Word>> = repository.allWords.asLiveData()      /**      * Launching a new coroutine to insert the data in a non-blocking way      */     fun insert(word: Word) = viewModelScope.launch {         repository.insert(word)     } }  class WordViewModelFactory(private val repository: WordRepository) : ViewModelProvider.Factory {     override fun <T : ViewModel> create(modelClass: Class<T>): T {         if (modelClass.isAssignableFrom(WordViewModel::class.java)) {             @Suppress("UNCHECKED_CAST")             return WordViewModel(repository) as T         }         throw IllegalArgumentException("Unknown ViewModel class")     } } 

<resources>      <!-- Base application theme. -->     <style name="AppTheme" parent="Theme.MaterialComponents.Light.DarkActionBar">         <!-- Customize your theme here. -->         <item name="colorPrimary">@color/colorPrimary</item>         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>         <item name="colorAccent">@color/colorAccent</item>     </style>      <!-- The default font for RecyclerView items is too small.     The margin is a simple delimiter between the words. -->     <style name="word_title">         <item name="android:layout_marginBottom">8dp</item>         <item name="android:paddingLeft">8dp</item>         <item name="android:background">@android:color/holo_orange_light</item>         <item name="android:textAppearance">@android:style/TextAppearance.Large</item>     </style> </resources> 

<dimen name="big_padding">16dp</dimen> 

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"     android:orientation="vertical"     android:layout_width="match_parent"     android:layout_height="wrap_content">      <TextView         android:id="@+id/textView"         style="@style/word_title"         android:layout_width="match_parent"         android:layout_height="wrap_content"         android:background="@android:color/holo_orange_light" /> </LinearLayout> 

<androidx.constraintlayout.widget.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"     tools:context=".MainActivity">      <androidx.recyclerview.widget.RecyclerView         android:id="@+id/recyclerview"         android:layout_width="0dp"         android:layout_height="0dp"         tools:listitem="@layout/recyclerview_item"         android:padding="@dimen/big_padding"         app:layout_constraintBottom_toBottomOf="parent"         app:layout_constraintLeft_toLeftOf="parent"         app:layout_constraintRight_toRightOf="parent"         app:layout_constraintTop_toTopOf="parent" />      <com.google.android.material.floatingactionbutton.FloatingActionButton         android:id="@+id/fab"         app:layout_constraintBottom_toBottomOf="parent"         app:layout_constraintEnd_toEndOf="parent"         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:layout_margin="16dp"         android:contentDescription="@string/add_word"/>  </androidx.constraintlayout.widget.ConstraintLayout> 

<com.google.android.material.floatingactionbutton.FloatingActionButton         android:id="@+id/fab"         app:layout_constraintBottom_toBottomOf="parent"         app:layout_constraintEnd_toEndOf="parent"         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:layout_margin="16dp"         android:contentDescription="@string/add_word"         android:src="@drawable/ic_add_black_24dp"/> 

class WordListAdapter : ListAdapter<Word, WordViewHolder>(WordsComparator()) {      override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): WordViewHolder {         return WordViewHolder.create(parent)     }      override fun onBindViewHolder(holder: WordViewHolder, position: Int) {         val current = getItem(position)         holder.bind(current.word)     }      class WordViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {         private val wordItemView: TextView = itemView.findViewById(R.id.textView)          fun bind(text: String?) {             wordItemView.text = text         }          companion object {             fun create(parent: ViewGroup): WordViewHolder {                 val view: View = LayoutInflater.from(parent.context)                     .inflate(R.layout.recyclerview_item, parent, false)                 return WordViewHolder(view)             }         }     }      class WordsComparator : DiffUtil.ItemCallback<Word>() {         override fun areItemsTheSame(oldItem: Word, newItem: Word): Boolean {             return oldItem === newItem         }          override fun areContentsTheSame(oldItem: Word, newItem: Word): Boolean {             return oldItem.word == newItem.word         }     } } 

   val recyclerView = findViewById<RecyclerView>(R.id.recyclerview)    val adapter = WordListAdapter()    recyclerView.adapter = adapter    recyclerView.layoutManager = LinearLayoutManager(this) 

class WordsApplication : Application() {     // Using by lazy so the database and the repository are only created when they're needed     // rather than when the application starts     val database by lazy { WordRoomDatabase.getDatabase(this) }     val repository by lazy { WordRepository(database.wordDao()) } } 

<application         android:name=".WordsApplication"         android:allowBackup="true"         android:icon="@mipmap/ic_launcher"         android:label="@string/app_name"         android:roundIcon="@mipmap/ic_launcher_round"         android:supportsRtl="true"         android:theme="@style/AppTheme"> ... 

fun getDatabase(        context: Context,        scope: CoroutineScope   ): WordRoomDatabase { ... } 

class WordsApplication : Application() {     // No need to cancel this scope as it'll be torn down with the process     val applicationScope = CoroutineScope(SupervisorJob())      // Using by lazy so the database and the repository are only created when they're needed     // rather than when the application starts     val database by lazy { WordRoomDatabase.getDatabase(this, applicationScope) }     val repository by lazy { WordRepository(database.wordDao()) } } 

private class WordDatabaseCallback(     private val scope: CoroutineScope ) : RoomDatabase.Callback() {      override fun onCreate(db: SupportSQLiteDatabase) {         super.onCreate(db)         INSTANCE?.let { database ->             scope.launch {                 populateDatabase(database.wordDao())             }         }     }      suspend fun populateDatabase(wordDao: WordDao) {         // Delete all content here.         wordDao.deleteAll()          // Add sample words.         var word = Word("Hello")         wordDao.insert(word)         word = Word("World!")         wordDao.insert(word)          // TODO: Add your own words!     } } 

.addCallback(WordDatabaseCallback(scope)) 

@Database(entities = arrayOf(Word::class), version = 1, exportSchema = false) abstract class WordRoomDatabase : RoomDatabase() {     abstract fun wordDao(): WordDao     private class WordDatabaseCallback(        private val scope: CoroutineScope    ) : RoomDatabase.Callback() {         override fun onCreate(db: SupportSQLiteDatabase) {            super.onCreate(db)            INSTANCE?.let { database ->                scope.launch {                    var wordDao = database.wordDao()                     // Delete all content here.                    wordDao.deleteAll()                     // Add sample words.                    var word = Word("Hello")                    wordDao.insert(word)                    word = Word("World!")                    wordDao.insert(word)                     // TODO: Add your own words!                    word = Word("TODO!")                    wordDao.insert(word)                }            }        }    }     companion object {        @Volatile        private var INSTANCE: WordRoomDatabase? = null         fun getDatabase(            context: Context,            scope: CoroutineScope        ): WordRoomDatabase {             // if the INSTANCE is not null, then return it,             // if it is, then create the database             return INSTANCE ?: synchronized(this) {                 val instance = Room.databaseBuilder(                         context.applicationContext,                         WordRoomDatabase::class.java,                         "word_database"                 )                  .addCallback(WordDatabaseCallback(scope))                  .build()                 INSTANCE = instance                 // return instance                 instance         }      }    } } 

<string name="hint_word">Word...</string> <string name="button_save">Save</string> <string name="empty_not_saved">Word not saved because it is empty.</string> <string name="add_word">Add word</string> 

<color name="buttonLabel">#FFFFFF</color> 

<dimen name="min_height">48dp</dimen> 

<activity android:name=".NewWordActivity"></activity> 

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"     android:orientation="vertical"     android:layout_width="match_parent"     android:layout_height="match_parent">      <EditText         android:id="@+id/edit_word"         android:layout_width="match_parent"         android:layout_height="wrap_content"         android:minHeight="@dimen/min_height"         android:fontFamily="sans-serif-light"         android:hint="@string/hint_word"         android:inputType="textAutoComplete"         android:layout_margin="@dimen/big_padding"         android:textSize="18sp" />      <Button         android:id="@+id/button_save"         android:layout_width="match_parent"         android:layout_height="wrap_content"         android:background="@color/colorPrimary"         android:text="@string/button_save"         android:layout_margin="@dimen/big_padding"         android:textColor="@color/buttonLabel" />  </LinearLayout> 

class NewWordActivity : AppCompatActivity() {      private lateinit var editWordView: EditText      public override fun onCreate(savedInstanceState: Bundle?) {         super.onCreate(savedInstanceState)         setContentView(R.layout.activity_new_word)         editWordView = findViewById(R.id.edit_word)          val button = findViewById<Button>(R.id.button_save)         button.setOnClickListener {             val replyIntent = Intent()             if (TextUtils.isEmpty(editWordView.text)) {                 setResult(Activity.RESULT_CANCELED, replyIntent)             } else {                 val word = editWordView.text.toString()                 replyIntent.putExtra(EXTRA_REPLY, word)                 setResult(Activity.RESULT_OK, replyIntent)             }             finish()         }     }      companion object {         const val EXTRA_REPLY = "com.example.android.wordlistsql.REPLY"     } } 

private val wordViewModel: WordViewModel by viewModels {     WordViewModelFactory((application as WordsApplication).repository) } 

wordViewModel.allWords.observe(this, Observer { words ->             // Update the cached copy of the words in the adapter.             words?.let { adapter.submitList(it) } }) 

private val newWordActivityRequestCode = 1 

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {     super.onActivityResult(requestCode, resultCode, data)      if (requestCode == newWordActivityRequestCode && resultCode == Activity.RESULT_OK) {         data?.getStringExtra(NewWordActivity.EXTRA_REPLY)?.let {             val word = Word(it)             wordViewModel.insert(word)         }     } else {         Toast.makeText(             applicationContext,             R.string.empty_not_saved,             Toast.LENGTH_LONG).show()     } } 

val fab = findViewById<FloatingActionButton>(R.id.fab) fab.setOnClickListener {   val intent = Intent(this@MainActivity, NewWordActivity::class.java)   startActivityForResult(intent, newWordActivityRequestCode) } 

class MainActivity : AppCompatActivity() {      private val newWordActivityRequestCode = 1     private val wordViewModel: WordViewModel by viewModels {         WordViewModelFactory((application as WordsApplication).repository)     }      override fun onCreate(savedInstanceState: Bundle?) {         super.onCreate(savedInstanceState)         setContentView(R.layout.activity_main)          val recyclerView = findViewById<RecyclerView>(R.id.recyclerview)         val adapter = WordListAdapter()         recyclerView.adapter = adapter         recyclerView.layoutManager = LinearLayoutManager(this)          // Add an observer on the LiveData returned by getAlphabetizedWords.         // The onChanged() method fires when the observed data changes and the activity is         // in the foreground.         wordViewModel.allWords.observe(owner = this) { words ->             // Update the cached copy of the words in the adapter.             words.let { adapter.submitList(it) }         }          val fab = findViewById<FloatingActionButton>(R.id.fab)         fab.setOnClickListener {             val intent = Intent(this@MainActivity, NewWordActivity::class.java)             startActivityForResult(intent, newWordActivityRequestCode)         }     }      override fun onActivityResult(requestCode: Int, resultCode: Int, intentData: Intent?) {         super.onActivityResult(requestCode, resultCode, intentData)          if (requestCode == newWordActivityRequestCode && resultCode == Activity.RESULT_OK) {             intentData?.getStringExtra(NewWordActivity.EXTRA_REPLY)?.let { reply ->                 val word = Word(reply)                 wordViewModel.insert(word)             }         } else {             Toast.makeText(                 applicationContext,                 R.string.empty_not_saved,                 Toast.LENGTH_LONG             ).show()         }     } }