Why local storage enables offline access in Android Kotlin - Build It to Prove It

Build: Offline Notes

This screen allows users to save notes locally on their device so they can access them even without internet connection.

Target UI

-------------------------
|      Offline Notes     |
|-----------------------|
| [Enter note here...]   |
|                       |
| [Save Note]            |
|                       |
| Saved Notes:           |
| - Note 1               |
| - Note 2               |
|                       |
-------------------------

A TextField for entering a note

A Save button to store the note locally

A list showing all saved notes from local storage

Notes must persist and be visible even when the app restarts or device is offline

Starter Code

Android Kotlin

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import android.widget.Button
import android.widget.EditText
import android.widget.ListView

class OfflineNotesActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_offline_notes)

        val noteInput = findViewById<EditText>(R.id.noteInput)
        val saveButton = findViewById<Button>(R.id.saveButton)
        val notesList = findViewById<ListView>(R.id.notesList)

        // TODO: Load saved notes from local storage and display

        saveButton.setOnClickListener {
            val note = noteInput.text.toString()
            if (note.isNotEmpty()) {
                // TODO: Save note to local storage
                // TODO: Update list view with new note
                noteInput.text.clear()
            }
        }
    }
}

Task 1

Task 2

Task 3

Task 4

Solution

Android Kotlin

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import android.widget.ArrayAdapter
import android.widget.Button
import android.widget.EditText
import android.widget.ListView

class OfflineNotesActivity : AppCompatActivity() {
    private val PREFS_NAME = "offline_notes_prefs"
    private val NOTES_KEY = "notes"
    private lateinit var notesList: MutableList<String>
    private lateinit var adapter: ArrayAdapter<String>

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_offline_notes)

        val noteInput = findViewById<EditText>(R.id.noteInput)
        val saveButton = findViewById<Button>(R.id.saveButton)
        val notesListView = findViewById<ListView>(R.id.notesList)

        // Load saved notes from SharedPreferences
        val prefs = getSharedPreferences(PREFS_NAME, MODE_PRIVATE)
        val savedNotes = prefs.getStringSet(NOTES_KEY, emptySet()) ?: emptySet()
        notesList = savedNotes.toMutableList()

        // Setup adapter to display notes
        adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, notesList)
        notesListView.adapter = adapter

        saveButton.setOnClickListener {
            val note = noteInput.text.toString().trim()
            if (note.isNotEmpty()) {
                notesList.add(note)
                adapter.notifyDataSetChanged()

                // Save updated notes to SharedPreferences
                prefs.edit().putStringSet(NOTES_KEY, notesList.toSet()).apply()

                noteInput.text.clear()
            }
        }
    }
}

This app uses SharedPreferences to save notes locally on the device. When the screen starts, it loads any saved notes from SharedPreferences and shows them in a list. When the user types a note and taps Save, the note is added to the list and saved back to SharedPreferences. This way, notes stay saved on the device and can be accessed even without internet or after restarting the app. Local storage like SharedPreferences enables offline access by keeping data on the device itself.

Final Result

Completed Screen

-------------------------
|      Offline Notes     |
|-----------------------|
| [Enter note here...]   |
|                       |
| [Save Note]            |
|                       |
| Saved Notes:           |
| - Buy groceries        |
| - Call mom             |
|                       |
-------------------------

User types a note in the text field

User taps Save Note button

Note appears in the list below

Notes remain visible after app restart or offline

Stretch Goal

Add a feature to delete a note by tapping on it in the list

💡 Hint

Use ListView's setOnItemClickListener to detect taps and remove the tapped note from the list and SharedPreferences

Practice

1. Why does local storage help mobile apps work offline?

easy

A. Because it deletes data after closing the app

B. Because it requires a constant internet connection

C. Because data is saved on the device and can be accessed without internet

D. Because it only stores temporary data in RAM

Solution

1. Step 1: Understand local storage purpose

   Local storage saves data directly on the device, not on the internet.

2. Step 2: Connect local storage to offline use

   Since data is on the device, the app can access it anytime, even without internet.

3. Final Answer:

   Because data is saved on the device and can be accessed without internet -> Option C

4. Quick Check:

   Local storage = offline access [OK]

Hint: Local storage means data stays on device, no internet needed [OK]

Common Mistakes:

• Thinking local storage needs internet
• Confusing local storage with temporary RAM
• Believing data is deleted after app closes

2. Which Kotlin code snippet correctly saves a string value "username" in SharedPreferences?

easy

A. val prefs = SharedPreferences()
prefs.put("username", "user1")

B. val prefs = getSharedPreferences("prefs", MODE_PRIVATE)
prefs.edit().putString("username", "user1").apply()

C. val prefs = getSharedPreferences("prefs", MODE_PRIVATE)
prefs.putString("username", "user1")

D. val prefs = getSharedPreferences("prefs")
prefs.edit().putString("user", "user1")

Solution

1. Step 1: Check SharedPreferences initialization

   Correct way is getSharedPreferences with name and mode.

2. Step 2: Verify saving string syntax

   Use edit(), putString(key, value), then apply() to save changes.

3. Final Answer:

   val prefs = getSharedPreferences("prefs", MODE_PRIVATE)\nprefs.edit().putString("username", "user1").apply() -> Option B

4. Quick Check:

   SharedPreferences save string = val prefs = getSharedPreferences("prefs", MODE_PRIVATE) prefs.edit().putString("username", "user1").apply() [OK]

Hint: Use edit(), putString(), then apply() to save SharedPreferences [OK]

Common Mistakes:

• Forgetting to call edit() before putString()
• Not calling apply() or commit() to save changes
• Using wrong method names or missing mode parameter

3. What will this Kotlin code print if no value was saved before?

val prefs = getSharedPreferences("prefs", MODE_PRIVATE)
val name = prefs.getString("username", "Guest")
println(name)

medium

A. "Guest"

B. "username"

C. Throws an error

D. null

Solution

1. Step 1: Understand getString default value

   If key "username" is missing, getString returns the default "Guest".

2. Step 2: Predict printed output

   Since no value saved, name is "Guest", so println prints "Guest".

3. Final Answer:

   "Guest" -> Option A

4. Quick Check:

   Default value returned = "Guest" [OK]

Hint: getString returns default if key missing [OK]

Common Mistakes:

• Assuming null is returned if key missing
• Expecting an error without saved value
• Confusing key name with value

4. Identify the error in this Kotlin code that tries to save a boolean in SharedPreferences:

val prefs = getSharedPreferences("prefs", MODE_PRIVATE)
prefs.edit().putBoolean("isLoggedIn", true)

medium

A. Missing apply() or commit() to save changes

B. putBoolean() does not exist in SharedPreferences

C. getSharedPreferences requires a third parameter

D. Boolean values cannot be saved in SharedPreferences

Solution

1. Step 1: Check SharedPreferences editing process

   After putBoolean(), you must call apply() or commit() to save changes.

2. Step 2: Confirm method existence and parameters

   putBoolean() exists and getSharedPreferences with two parameters is valid.

3. Final Answer:

   Missing apply() or commit() to save changes -> Option A

4. Quick Check:

   Always call apply() or commit() after edits [OK]

Hint: Always call apply() or commit() after editing SharedPreferences [OK]

Common Mistakes:

• Forgetting to save changes with apply() or commit()
• Thinking putBoolean() is invalid
• Adding unnecessary parameters to getSharedPreferences

5. An app uses local storage to save user settings for offline use. Which approach best ensures data consistency when the app regains internet connection?

hard

A. Delete local data immediately after saving it

B. Require internet for every data change

C. Never sync local data with the server

D. Sync local changes with the server only when internet is available

Solution

1. Step 1: Understand offline data usage

   Local storage allows changes offline, but syncing with server keeps data consistent.

2. Step 2: Choose syncing strategy

   Syncing only when internet is available avoids errors and keeps data updated.

3. Final Answer:

   Sync local changes with the server only when internet is available -> Option D

4. Quick Check:

   Sync offline data when online = Sync local changes with the server only when internet is available [OK]

Hint: Sync local data with server only when online to keep consistent [OK]

Common Mistakes:

• Deleting local data too early
• Ignoring server sync causing outdated data
• Requiring internet for all changes defeats offline use