Lesson 9 - App Architecture (Persistence)

Lesson 9:
App architecture
(persistence)
Android Development with Kotlin v1.0 This work is licensed under the Apache 2 license. 1
About this lesson
Lesson 9: App architecture (persistence)
● Storing data
● Room persistence library
● Asynchronous programming
● Coroutines
● Testing databases
● Summary
Android Development with Kotlin This work is licensed under the Apache 2 license. 2
Storing data
Ways to store data in an Android app
● App-specific storage
● Shared storage (files to be shared with other apps)
● Preferences
● Databases
What is a database?
Collection of structured data that can be easily accessed,
searched, and organized, consisting of:
● Tables Example Database
person car
● Rows
_id _id
● Columns name make
age model
email year
5
Android Development with Kotlin This work is licensed under the Apache 2 license.
Structured Query Language (SQL)
Use SQL to access and modify a relational database.
● Create new tables

● Query for data
● Insert new data
● Update data
● Delete data
SQLite in Android
Store data
Your app
SQLite database
Example SQLite commands
Create INSERT INTO colors VALUES ("red", "#FF0000");
Read SELECT * from colors;
Update UPDATE colors SET hex="#DD0000" WHERE name="red";
Delete DELETE FROM colors WHERE name = "red";
Interacting directly with a database
● No compile-time verification of raw SQL queries
● Need lots of boilerplate code to convert between

SQL queries data objects
Room persistence library
Add Gradle dependencies
Room
Rest of the app code
Color("#FF0000", "red")
Room
Colors Data access object Color("#4CAF50", "green")

database
Color("#1155CC", "blue")
ColorValue app
Room
● Entity Color
● DAO ColorDao
● Database ColorDatabase
Color class
Annotations
● Provide extra information to the compiler

@Entity marks entity class, @Dao for DAO, @Database for database
● Can take parameters
@Entity(tableName = "colors")
● Can autogenerate code for you
Entity
Class that maps to a SQLite database table

● @Entity
● @PrimaryKey
● @ColumnInfo
Example entity
colors
Data access object (DAO)
Work with DAO classes instead of accessing database directly:

● Define database interactions in the DAO.
● Declare DAO as an interface or abstract class.
● Room creates DAO implementation at compile time.
● Room verifies all of your DAO queries at compile-time.
Example DAO
Query
Insert
Update
Delete
Create a Room database
● Annotate class with @Database and include list of entities:

@Database(entities = [Color::class], version = 1)
● Declare abstract class that extends RoomDatabase:

abstract class ColorDatabase : RoomDatabase() {
○ Declare abstract method with no args that returns the DAO:

abstract fun colorDao(): ColorDao
Example Room database
Create database instance
Get and use a DAO
Get the DAO from the database:

val colorDao = ColorDatabase.getInstance(application).colorDao()
Create new Color and use DAO to insert it into database:

val newColor = Color(hex = "#6200EE", name = "purple")
colorDao.insert(newColor)
Asynchronous
programming
Long-running tasks
● Download information
● Sync with a server
● Write to a file
● Heavy computation
● Read from, or write to, a database
Need for async programming
● Limited time to do tasks and remain responsive

● Balanced with the need to execute long-running tasks
● Control over how and where tasks are executed
Async programming on Android
● Threading
● Callbacks
● Plus many other options
What is the recommended way?
Coroutines
Coroutines
● Keep your app responsive while managing long-running tasks.

● Simplify asynchronous code in your Android app.
● Write code in sequential way
● Handle exceptions with try/catch block
Benefits of coroutines
● Lightweight
● Fewer memory leaks
● Built-in cancellation support
● Jetpack integration
Suspend functions
● Add suspend modifier

● Must be called by other suspend functions or coroutines
Suspend and resume
● suspend
Pauses execution of current coroutine and saves local variables
● resume
Automatically loads saved state and continues execution from
the point the code was suspended
Example
Add suspend modifier to DAO methods
Control where coroutines run
Dispatcher Description of work Examples of work
Dispatchers.Main UI and nonblocking Updating LiveData, calling

(short) tasks suspend functions
Dispatchers.IO Network and disk tasks Database, file IO
Dispatchers.Default CPU intensive Parsing JSON
withContext
CoroutineScope
Coroutines must run in a CoroutineScope:
● Keeps track of all coroutines started in it (even suspended ones)
● Provides a way to cancel coroutines in a scope
● Provides a bridge between regular functions and coroutines
Examples: GlobalScope
ViewModel has viewModelScope
Lifecycle has lifecycleScope
Start new coroutines
● launch - no result needed
● async - can return a result
ViewModelScope
Example viewModelScope
Testing databases
Add Gradle dependencies
Testing Android code
● @RunWith(AndroidJUnit4::class)
● @Before
● @After
● @Test
Create test class
Create and close database for each test
In DatabaseTest.kt:
Test insert and retrieve from a database
In DatabaseTest.kt:
Summary
Summary
In Lesson 9, you learned how to:
● Set up and configure a database using the Room library
● Use coroutines for asynchronous programming
● Use coroutines with Room
● Test a database
Learn more
● 7 Pro-tips for Room
● Room Persistence Library
● SQLite Home Page
● Save data using SQLite
● Coroutines Guide
● Dispatchers - kotlinx-coroutines-core
● Coroutines on Android (part I): Getting the background
● Coroutines on Android (part II): Getting started
● Easy Coroutines in Android: viewModelScope
● Kotlin Coroutines 101
Pathway
Practice what you’ve learned by

completing the pathway:
Lesson 9: App architecture
(persistence)

Lesson 9 - App Architecture (Persistence)

Uploaded by

Copyright:

Available Formats

Lesson 9 - App Architecture (Persistence)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lesson 9 - App Architecture (Persistence)

Uploaded by

Copyright:

Available Formats

Lesson 9:

● Tables Example Database

● Create new tables

Create INSERT INTO colors VALUES ("red", "#FF0000");

Read SELECT * from colors;

Update UPDATE colors SET hex="#DD0000" WHERE name="red";

Delete DELETE FROM colors WHERE name = "red";

● No compile-time veriﬁcation of raw SQL queries

● Need lots of boilerplate code to convert between

Rest of the app code

Colors Data access object Color("#4CAF50", "green")

● Provide extra information to the compiler

Class that maps to a SQLite database table

Work with DAO classes instead of accessing database directly:

● Annotate class with @Database and include list of entities:

● Declare abstract class that extends RoomDatabase:

○ Declare abstract method with no args that returns the DAO:

Get the DAO from the database:

Create new Color and use DAO to insert it into database:

● Limited time to do tasks and remain responsive

What is the recommended way?

● Keep your app responsive while managing long-running tasks.

● Add suspend modiﬁer

Dispatcher Description of work Examples of work

Dispatchers.Main UI and nonblocking Updating LiveData, calling

Dispatchers.IO Network and disk tasks Database, ﬁle IO

Dispatchers.Default CPU intensive Parsing JSON

● launch - no result needed

● async - can return a result

Practice what you’ve learned by

You might also like