带有暂停 function 块的接口类 Hilt 的依赖注入

Question

I declare a class that uses suspend function. This class is meant to be a singleton dependency injected by Hilt library on Android:

interface Foo {
   suspend fun send(v: Int)
   suspend fun receive(): Int
}
class FooImpl @Inject () {
   var channel: Channel<Int>(2, BufferOverflow.DROP_OLDEST)
   override suspend fun send(v: Int) {
       channel.send(v)
   }
   override suspend fun receive(): Int {
       channel.receive()
   }
}

//FIRST CASE:
@Module
@InstallIn(SingletonComponent::class)
abstract class FooModule {
  @Binds
  abstract fun bindFoo(foo: FooImpl): Foo
 }

Then if when I call the receive function it get blocked forever. No data is received, example:

@AndroidEntryPoint
class Bar: Service {
  @Inject
  lateinit var foo: Foo
  private val scope = CoroutineScope(Job() + Dispatchers.Default)
  //...
  fun doSomething() {
    scope.launch() {
      foo.receive()
      //coroutine execution never reach this line
    }
  }
}

In this simple case, as Foo is a singleton I could implement a simple work around. If Foo is implemented this way within Hilt, I have no trouble:

//SECOND_CASE:
val FOO: Foo = FooImpl()

@Module
@InstallIn(SingletonComponent::class)
object FooModule {
   @Provides
   fun providesFoo(): Foo {
      return FOO
   }
}

I am wondering weither it is a Hilt bug or my FIRST_CASE hilt module implementation is wrong?

Answer 1

You never declare FooImpl as a singleton, so every time it is injected, you get a fresh instance.
In case you assumed that this is what @InstallIn(SingletonComponent::class) does, it is not. This annotation only tells hilt that FooModule itself should be a singleton and is not scoped to the lifecycle of an Activity, ViewModel or Fragment.

You need to add @Singleton to either FooImpl or the method binding it:

Option 1

interface Foo {
   suspend fun send(v: Int)
   suspend fun receive(): Int
}

@Singleton
class FooImpl @Inject constructor() : Foo {
   ...
}

@Module
@InstallIn(SingletonComponent::class)
abstract class FooModule {
    @Binds
    abstract fun bindFoo(foo: FooImpl): Foo
}

Option 2

interface Foo {
   suspend fun send(v: Int)
   suspend fun receive(): Int
}

class FooImpl @Inject constructor() : Foo {
   ...
}

@Module
@InstallIn(SingletonComponent::class)
abstract class FooModule {
    @Singleton
    @Binds
    abstract fun bindFoo(foo: FooImpl): Foo
}