File access and storage in Android Kotlin

Introduction

Files let your app save and read information on the device. This helps keep data even when the app is closed.

Saving user notes or documents locally on the phone.

Storing app settings or preferences that need to persist.

Caching images or data to load faster next time.

Logging app events for debugging or support.

Reading configuration files bundled with the app.

Syntax

Android Kotlin

val fileOutput = openFileOutput("filename.txt", Context.MODE_PRIVATE)
fileOutput.write("Hello World".toByteArray())
fileOutput.close()

val fileInput = openFileInput("filename.txt")
val content = fileInput.bufferedReader().use { it.readText() }
fileInput.close()

openFileOutput creates or opens a file for writing inside your app's private storage.

openFileInput opens a file for reading from your app's private storage.

Examples

Write text to a private file safely using use to auto-close the stream.

Android Kotlin

openFileOutput("data.txt", Context.MODE_PRIVATE).use {
  it.write("Sample text".toByteArray())
}

Read all text from a private file using a buffered reader.

Android Kotlin

val text = openFileInput("data.txt").bufferedReader().use {
  it.readText()
}

Use File class with filesDir to write and read text files.

Android Kotlin

val file = File(filesDir, "myfile.txt")
file.writeText("Hello")
val content = file.readText()

Sample App

This app writes a message to a private file and then reads it back to show on screen.

Android Kotlin

import android.app.Activity
import android.content.Context
import android.os.Bundle
import android.widget.TextView
import java.io.File

class MainActivity : Activity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val filename = "example.txt"
    val fileContents = "Welcome to file storage!"

    openFileOutput(filename, Context.MODE_PRIVATE).use {
      it.write(fileContents.toByteArray())
    }

    val readText = openFileInput(filename).bufferedReader().use {
      it.readText()
    }

    val textView = TextView(this).apply {
      text = readText
      textSize = 24f
    }

    setContentView(textView)
  }
}

Important Notes

Files saved with MODE_PRIVATE are only accessible by your app.

Always close streams or use use to avoid leaks.

For large files or complex data, consider using databases or shared preferences instead.

Summary

File access lets apps save and read data on the device.

Use openFileOutput and openFileInput for private app files.

Always handle files carefully to avoid crashes or data loss.

Practice

1. Which method is used in Android Kotlin to write data to a private file within the app's internal storage?

easy

A. writeExternalStorage

B. openFileInput

C. readFile

D. openFileOutput

Solution

1. Step 1: Understand file writing methods

   openFileOutput is the method designed to write data to a private file in internal storage.

2. Step 2: Differentiate from reading methods

   openFileInput is used for reading, not writing files.

3. Final Answer:

   openFileOutput -> Option D

4. Quick Check:

   Write file = openFileOutput [OK]

Hint: Writing files uses openFileOutput, reading uses openFileInput [OK]

Common Mistakes:

• Confusing openFileInput with writing method
• Using external storage methods for internal files
• Assuming readFile is a valid Android method

2. Which of the following is the correct Kotlin syntax to open a file named "data.txt" for reading in an Android app?

easy

A. val input = openFileOutput("data.txt", Context.MODE_PRIVATE)

B. val input = openFileInput("data.txt")

C. val input = openFile("data.txt", Context.MODE_PRIVATE)

D. val input = readFile("data.txt")

Solution

1. Step 1: Identify the correct method for reading files

   openFileInput is the correct method to open a file for reading in Android Kotlin.

2. Step 2: Check syntax correctness

   openFileInput takes only the filename as a parameter, no mode needed.

3. Final Answer:

   val input = openFileInput("data.txt") -> Option B

4. Quick Check:

   Read file = openFileInput(filename) [OK]

Hint: openFileInput(filename) opens file for reading [OK]

Common Mistakes:

• Using openFileOutput for reading
• Adding mode parameter to openFileInput
• Using non-existent readFile method

3. What will be the output of the following Kotlin code snippet in an Android app?

val filename = "note.txt"
val fileContents = "Hello World"
openFileOutput(filename, Context.MODE_PRIVATE).use {
  it.write(fileContents.toByteArray())
}
val input = openFileInput(filename).bufferedReader().use { it.readText() }
println(input)

medium

A. note.txt

B. null

C. Hello World

D. FileNotFoundException

Solution

1. Step 1: Write text to file

   The code writes "Hello World" to "note.txt" using openFileOutput.

2. Step 2: Read text from the same file

   openFileInput reads the file content back as a string.

3. Final Answer:

   Hello World -> Option C

4. Quick Check:

   Write then read file = "Hello World" [OK]

Hint: Write then read file returns the original string [OK]

Common Mistakes:

• Expecting filename instead of content
• Assuming file is empty or null
• Not closing streams causing errors

4. Consider this Kotlin code snippet in an Android app:

val input = openFileInput("config.txt")
val text = input.bufferedReader().readText()
input.close()

What is the main issue with this code?

medium

A. Not using 'use' block to safely close the stream

B. The input stream is closed before reading text

C. bufferedReader() cannot be called on input streams

D. openFileInput should be called with Context.MODE_PRIVATE

Solution

1. Step 1: Check resource management

   The code manually closes the input stream but risks exceptions if readText() fails.

2. Step 2: Use 'use' block for safety

   Using 'use' automatically closes the stream safely even if errors occur.

3. Final Answer:

   Not using 'use' block to safely close the stream -> Option A

4. Quick Check:

   Safe stream closing = use block [OK]

Hint: Always use 'use' to auto-close streams safely [OK]

Common Mistakes:

• Adding mode parameter to openFileInput
• Closing stream before reading
• Believing bufferedReader() is invalid here

5. You want to save user preferences as a JSON string in a private file named "prefs.json" and then read it back safely. Which Kotlin code snippet correctly writes and reads this file in an Android app?

hard

A. openFileOutput("prefs.json", Context.MODE_PRIVATE).use { it.write(jsonString.toByteArray()) }
val json = openFileInput("prefs.json").bufferedReader().use { it.readText() }

B. openFileInput("prefs.json").use { it.write(jsonString.toByteArray()) }
val json = openFileOutput("prefs.json", Context.MODE_PRIVATE).bufferedReader().use { it.readText() }

C. val file = File("prefs.json")
file.writeText(jsonString)
val json = file.readText()

D. val fos = openFileOutput("prefs.json")
fos.write(jsonString.toByteArray())
fos.close()
val fis = openFileInput("prefs.json")
val json = fis.bufferedReader().readText()
fis.close()

Solution

1. Step 1: Write file using openFileOutput with 'use'

   openFileOutput("prefs.json", Context.MODE_PRIVATE).use { it.write(jsonString.toByteArray()) } val json = openFileInput("prefs.json").bufferedReader().use { it.readText() } correctly writes the JSON string to "prefs.json" using openFileOutput and safely closes the stream with 'use'.

2. Step 2: Read file using openFileInput with 'use'

   It then reads the file back safely using openFileInput and 'use' to auto-close the stream.

3. Final Answer:

   openFileOutput("prefs.json", Context.MODE_PRIVATE).use { it.write(jsonString.toByteArray()) } val json = openFileInput("prefs.json").bufferedReader().use { it.readText() } -> Option A

4. Quick Check:

   Write/read private file safely = openFileOutput/input + use [OK]

Hint: Use openFileOutput/input with 'use' to safely write/read files [OK]

Common Mistakes:

• Mixing up openFileInput and openFileOutput
• Using File class for internal storage without context
• Not closing streams properly causing leaks