File access and storage in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

Reading a file from internal storage

What will be the output shown in the TextView after running this code snippet that reads a file named "data.txt" from internal storage?

Android Kotlin

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

A The exact text content stored inside "data.txt" is displayed in the TextView

B The TextView remains empty because openFileInput returns null

C The TextView shows the file path of "data.txt"

D The app crashes with FileNotFoundException if "data.txt" does not exist

💡 Hint

openFileInput reads the file content as a stream, which you convert to text.

openFileInput opens the file for reading. Using bufferedReader and readText() reads the entire file content as a string, which is then set to the TextView.

❓ lifecycle

intermediate

File writing in Activity lifecycle

If you write data to a file in the onPause() method of an Activity, what happens if the app is killed before onPause() is called?

A The data is saved in onCreate() instead

B The data will not be saved because onPause() was never called

C The data is saved only if onStop() is called

D The data is saved automatically by the system

💡 Hint

onPause() is called before the Activity goes to background, but not if the app is killed abruptly.

If the app is killed abruptly (e.g., by the system or user), onPause() may not be called, so any file writing code there will not run and data won't be saved.

📝 Syntax

advanced

Correct syntax for writing text to a file

Which Kotlin code snippet correctly writes the string "Hello World" to a file named "output.txt" in internal storage?

A File("output.txt").writeBytes("Hello World")

B openFileOutput("output.txt", Context.MODE_PRIVATE).writeText("Hello World")

C openFileOutput("output.txt", Context.MODE_PRIVATE).use { it.write("Hello World".toByteArray()) }

D openFileOutput("output.txt").write("Hello World")

💡 Hint

openFileOutput returns a FileOutputStream which you can write bytes to.

Option C correctly uses openFileOutput with mode and writes bytes using use block. Option C is invalid because FileOutputStream has no writeText method. Option C tries to write to a file without path and wrong method. Option C misses mode parameter and write method is invalid.

🔧 Debug

advanced

Diagnosing a FileNotFoundException

An app crashes with FileNotFoundException when trying to read "config.txt" using openFileInput("config.txt"). What is the most likely cause?

A "config.txt" does not exist in the app's internal storage

B The app lacks permission to read external storage

C The file path is incorrect because openFileInput requires absolute path

D The file is open in write mode elsewhere causing a lock

💡 Hint

openFileInput only reads files previously saved in internal storage by the app.

FileNotFoundException occurs if the file does not exist in internal storage. openFileInput does not require absolute paths and does not access external storage, so permissions or path are not the issue here.

🧠 Conceptual

expert

Choosing storage for sensitive data

Which storage option is best for saving sensitive user data like passwords in an Android app?

A External storage public directory

B SharedPreferences without encryption

C Cache directory accessible by other apps

D Internal storage files with MODE_PRIVATE access

💡 Hint

Sensitive data should be stored where only your app can access it.

Internal storage files with MODE_PRIVATE are only accessible by your app, making them suitable for sensitive data. External storage and cache directories can be accessed by other apps. SharedPreferences without encryption is not secure for sensitive data.

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