Use cases / Interactors in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a use case class with an invoke operator function.

Android Kotlin

class GetUserNameUseCase {
    operator fun [1](): String {
        return "Alice"
    }
}

Drag options to blanks, or click blank then click option'

Ainvoke

Bexecute

Crun

Dcall

Attempts:

3 left

💡 Hint

Common Mistakes

Using a regular function name like execute instead of invoke.

The invoke operator allows the use case to be called like a function instance.

2fill in blank

medium

Complete the code to inject a repository into the use case constructor.

Android Kotlin

class GetUserAgeUseCase(private val [1]: UserRepository) {
    operator fun invoke(): Int {
        return repository.getAge()
    }
}

Drag options to blanks, or click blank then click option'

Arepo

BuserRepo

CuserRepository

Drepository

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatch between constructor parameter and usage name.

The parameter name repository matches the usage inside the class.

3fill in blank

hard

Fix the error in the use case function to return the user email from repository.

Android Kotlin

class GetUserEmailUseCase(private val repository: UserRepository) {
    operator fun invoke(): String {
        return repository.[1]()
    }
}

Drag options to blanks, or click blank then click option'

Aemail

BfetchEmail

CgetEmail

DretrieveEmail

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name that does not exist in the repository.

The repository method to get email is named getEmail().

4fill in blank

hard

Fill both blanks to create a use case that returns true if user is active.

Android Kotlin

class IsUserActiveUseCase(private val [1]: UserRepository) {
    operator fun [2](): Boolean {
        return [1].isActive()
    }
}

Drag options to blanks, or click blank then click option'

Arepository

Binvoke

CuserRepo

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent parameter names or function names.

The constructor parameter is named repository and the function uses the invoke operator.

5fill in blank

hard

Fill all three blanks to define a use case that takes a userId and returns user details.

Android Kotlin

class GetUserDetailsUseCase(private val [1]: UserRepository) {
    operator fun [2](userId: [3]): User {
        return [1].getUserById(userId)
    }
}

Drag options to blanks, or click blank then click option'

Arepository

Binvoke

CInt

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong parameter names or wrong userId type.

The repository parameter is repository, the function is invoke, and the userId is a String.

Practice

1. What is the main purpose of a use case (interactor) in Android app development?

easy

A. To organize app actions and separate business logic from UI

B. To design the app's user interface layout

C. To handle database migrations automatically

D. To manage app permissions and security

Solution

1. Step 1: Understand the role of use cases

   Use cases focus on organizing the app's business logic and actions clearly.

2. Step 2: Differentiate from UI and other concerns

   They separate this logic from the user interface and other layers like database or security.

3. Final Answer:

   To organize app actions and separate business logic from UI -> Option A

4. Quick Check:

   Use cases = organize logic separate from UI [OK]

Hint: Use cases handle app actions, not UI or database [OK]

Common Mistakes:

• Confusing use cases with UI components
• Thinking use cases manage database directly
• Assuming use cases handle permissions

2. Which Kotlin syntax correctly defines a simple use case class with an invoke operator function?

easy

A. class GetUserUseCase { fun call(id: Int): User { /*...*/ } }

B. class GetUserUseCase { operator fun invoke(id: Int): User { /*...*/ } }

C. fun GetUserUseCase(id: Int): User { /*...*/ }

D. object GetUserUseCase { fun invoke(id: Int): User { /*...*/ } }

Solution

1. Step 1: Identify correct class and operator syntax

   Use cases are often classes with an operator fun invoke to call them like functions.

2. Step 2: Check each option's syntax

   class GetUserUseCase { operator fun invoke(id: Int): User { /*...*/ } } correctly defines a class with operator fun invoke. fun GetUserUseCase(id: Int): User { /*...*/ } is a function, not a class. class GetUserUseCase { fun call(id: Int): User { /*...*/ } } uses fun call, not invoke. object GetUserUseCase { fun invoke(id: Int): User { /*...*/ } } uses object but lacks operator keyword.

3. Final Answer:

   class GetUserUseCase { operator fun invoke(id: Int): User { /*...*/ } } -> Option B

4. Quick Check:

   Use case class with operator invoke = class GetUserUseCase { operator fun invoke(id: Int): User { /*...*/ } } [OK]

Hint: Use operator fun invoke inside class for use cases [OK]

Common Mistakes:

• Defining use case as a simple function instead of class
• Missing operator keyword for invoke function
• Using object without operator fun invoke

3. Given this use case code snippet, what will be printed?

class AddNumbersUseCase {
  operator fun invoke(a: Int, b: Int): Int = a + b
}

fun main() {
  val add = AddNumbersUseCase()
  println(add(3, 4))
}

medium

A. 7

B. 34

C. Error: invoke requires one parameter

D. null

Solution

1. Step 1: Understand operator fun invoke with two parameters

   The invoke function takes two Ints and returns their sum.

2. Step 2: Call add(3, 4) executes invoke(3, 4) returning 7

   Printing this result outputs 7.

3. Final Answer:

   7 -> Option A

4. Quick Check:

   3 + 4 = 7 [OK]

Hint: Invoke operator calls function with parameters directly [OK]

Common Mistakes:

• Thinking parameters concatenate as strings
• Assuming invoke only takes one parameter
• Expecting null or error output

4. Identify the error in this use case implementation:

class MultiplyUseCase {
  operator fun invoke(a: Int, b: Int): Int {
    return a * b
  }
}

fun main() {
  val multiply = MultiplyUseCase()
  println(multiply.invoke(5))
}

medium

A. println cannot print Int values

B. Missing return statement in invoke function

C. MultiplyUseCase should be an object, not a class

D. invoke function called with wrong number of arguments

Solution

1. Step 1: Check invoke function parameters

   invoke expects two Int parameters: a and b.

2. Step 2: Analyze call multiply.invoke(5)

   Only one argument is passed, causing a compile-time error for wrong argument count.

3. Final Answer:

   invoke function called with wrong number of arguments -> Option D

4. Quick Check:

   invoke needs 2 args, call has 1 [OK]

Hint: Check function parameter count matches call arguments [OK]

Common Mistakes:

• Ignoring parameter count mismatch
• Thinking classes must be objects for use cases
• Assuming println can't print Int

5. You want to create a use case that fetches user details and then logs the action. Which approach best follows use case principles?

hard

A. Put fetching logic in UI code and logging in a separate utility class

B. Combine fetching, logging, and UI updates all inside the use case invoke function

C. Create a use case class that fetches user data and calls a logger inside invoke

D. Use a use case only for logging, and fetch data directly in the UI

Solution

1. Step 1: Understand use case responsibility

   Use cases should handle business logic like fetching and related actions such as logging.

2. Step 2: Evaluate options for separation and clarity

   Create a use case class that fetches user data and calls a logger inside invoke keeps fetching and logging together in use case, separating UI concerns. Others mix UI and logic or split related logic incorrectly.

3. Final Answer:

   Create a use case class that fetches user data and calls a logger inside invoke -> Option C

4. Quick Check:

   Use case = business logic + related actions [OK]

Hint: Keep related logic inside use case, UI handles display only [OK]

Common Mistakes:

• Mixing UI code with business logic
• Splitting related logic across unrelated classes
• Using use case only for one small task