Modularization in Android Kotlin - Mini App: Build & Ship

Build: Simple Modular App

Build a simple Android app with two modules: app and greeting. The greeting module provides a function to return a greeting message. The app module uses this function to display the greeting on the main screen.

Target UI

-----------------------
|    Simple Modular    |
|---------------------|
|                     |
|  Greeting: Hello!   |
|                     |
|---------------------|

Create a separate Kotlin module named 'greeting' with a function getGreeting() that returns a String 'Hello!'

In the app module, call getGreeting() from the greeting module and display the returned text in a TextView on the main screen

Ensure proper module dependency setup so app module can use greeting module

Use a simple vertical layout with a TextView centered on the screen

Starter Code

Android Kotlin

/* app module MainActivity.kt */
package com.example.simplemodular

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import android.widget.TextView

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // TODO: Set content view and display greeting text
    }
}

/* greeting module Greeting.kt */
package com.example.greeting

// TODO: Implement getGreeting function

Task 1

Task 2

Task 3

Solution

Android Kotlin

/* greeting module Greeting.kt */
package com.example.greeting

fun getGreeting(): String {
    return "Hello!"
}

/* app module MainActivity.kt */
package com.example.simplemodular

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import android.widget.TextView
import com.example.greeting.getGreeting

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val textView = TextView(this).apply {
            text = getGreeting()
            textSize = 24f
            setPadding(50, 200, 50, 200)
        }
        setContentView(textView)
    }
}

We created a separate Kotlin module named greeting with a function getGreeting() that returns the string "Hello!". This keeps the greeting logic modular and reusable.

In the app module, we imported getGreeting() from the greeting module. In MainActivity, we created a TextView programmatically, set its text to the greeting message, and set it as the content view.

This shows how modularization helps separate concerns and reuse code across modules.

Final Result

Completed Screen

-----------------------
|    Simple Modular    |
|---------------------|
|                     |
|  Greeting: Hello!   |
|                     |
|---------------------|

App launches showing a screen with the text 'Hello!' centered

No buttons or other interactions

Stretch Goal

Add a second module named 'farewell' with a function getFarewell() returning 'Goodbye!'. Display both greeting and farewell messages in the app screen.

💡 Hint

Create a new Kotlin module 'farewell' similar to 'greeting'. Import and call getFarewell() in MainActivity and show both texts in separate TextViews or a vertical layout.

Practice

1. What is the main purpose of modularization in Android Kotlin projects?

easy

A. To avoid using dependencies

B. To write all code in a single file

C. To split the app into smaller, manageable parts

D. To increase app size unnecessarily

Solution

1. Step 1: Understand modularization concept

   Modularization means dividing the app into smaller parts called modules.

2. Step 2: Identify the purpose

   This helps manage code better and makes development easier.

3. Final Answer:

   To split the app into smaller, manageable parts -> Option C

4. Quick Check:

   Modularization = split app into parts [OK]

Hint: Modularization means breaking app into smaller parts [OK]

Common Mistakes:

• Thinking modularization means writing all code in one file
• Believing modularization avoids dependencies
• Assuming modularization increases app size

2. Which of the following is the correct way to add a module dependency in a Kotlin Android project build file?

easy

A. import module ":mylibrary"

B. add dependency ":mylibrary"

C. include module ":mylibrary"

D. implementation project(":mylibrary")

Solution

1. Step 1: Recall Gradle syntax for module dependencies

   In build.gradle.kts, dependencies use implementation(project(":moduleName")) syntax.

2. Step 2: Match correct syntax

   implementation project(":mylibrary") matches this syntax exactly.

3. Final Answer:

   implementation project(":mylibrary") -> Option D

4. Quick Check:

   Module dependency syntax = implementation project(":module") [OK]

Hint: Use implementation project(":moduleName") to add module dependency [OK]

Common Mistakes:

• Using import or include keywords incorrectly
• Forgetting to wrap module name in project()
• Using add dependency which is not Gradle syntax

3. Given two modules: app and utils. If app depends on utils, what happens when you call a function defined in utils from app?

medium

A. The function runs correctly if dependency is set

B. The app crashes at runtime

C. The function is ignored during build

D. The app fails to compile

Solution

1. Step 1: Understand module dependency effect

   If app depends on utils, app can use utils code.

2. Step 2: Predict behavior when calling function

   Calling a function from utils works if dependency is correctly set, so function runs fine.

3. Final Answer:

   The function runs correctly if dependency is set -> Option A

4. Quick Check:

   Dependency set = function runs [OK]

Hint: Module dependency allows code sharing and function calls [OK]

Common Mistakes:

• Assuming app crashes without error
• Thinking function is ignored during build
• Believing app fails to compile without error

4. You added a module dependency in app on library, but the app fails to compile with "Unresolved reference" errors for library classes. What is the most likely cause?

medium

A. The project was not synced after adding dependency

B. The library module has no Kotlin files

C. The app module is missing AndroidManifest.xml

D. The dependency was added in the wrong build.gradle file

Solution

1. Step 1: Identify cause of unresolved references

   Unresolved references after adding dependency usually mean changes haven't taken effect in the IDE.

2. Step 2: Check sync status

   The project must be synced after modifying build.gradle for dependencies to resolve.

3. Final Answer:

   The project was not synced after adding dependency -> Option A

4. Quick Check:

   No sync = unresolved references [OK]

Hint: Sync project after adding dependencies [OK]

Common Mistakes:

• Adding dependency in wrong build.gradle file
• Library module has no Kotlin files
• App module missing AndroidManifest.xml

5. You want to create a modularized Android app with three modules: app, network, and database. The app module should use both network and database, but network should not depend on database. How should you set dependencies?

hard

A. network depends on database; app depends on network

B. app depends on network and database; network has no dependencies

C. database depends on network; app depends on database

D. app depends only on network; network depends on database

Solution

1. Step 1: Analyze dependency requirements

   App needs both network and database modules. Network must not depend on database.

2. Step 2: Set dependencies accordingly

   App depends on both network and database. Network has no dependencies to database.

3. Final Answer:

   app depends on network and database; network has no dependencies -> Option B

4. Quick Check:

   App uses both; network independent [OK]

Hint: Only app depends on both; network stays independent [OK]

Common Mistakes:

• Making network depend on database incorrectly
• Setting app to depend only on network
• Confusing dependency directions