For `kotlin-inject-anvil`, should I expect `Featu...

# kotlin-inject

[Kirill Zhukov]

For kotlin-inject-anvil, should I expect FeatureFlagService and FeatureFlagSyncWorker to be singletons here?

@Origin(value = FeatureFlagServiceImpl::class)
@ContributesTo(scope = AppScope::class)
public interface FeatureFlagServiceImplComponent {
  @Provides
  @SingleIn(scope = AppScope::class)
  public fun provideFeatureFlagService(implementation: FeatureFlagServiceImpl): FeatureFlagService = implementation

  @Provides
  @SingleIn(scope = AppScope::class)
  public fun provideFeatureFlagSyncWorker(implementation: FeatureFlagServiceImpl): FeatureFlagSyncWorker = implementation
}

[Kirill Zhukov]

In final merged components a new instance is created on each injection -> uses getter property

private val featureFlagServiceImpl: FeatureFlagServiceImpl
    get() = FeatureFlagServiceImpl(
      featureFlags = listFeatureFlagFeatureFlagValue,

[Kirill Zhukov]

featureFlagSyncWorker = _scoped.get("build.wallet.feature.FeatureFlagSyncWorker") {
  provideFeatureFlagSyncWorker(
    implementation = featureFlagServiceImpl
  )
},

[Kirill Zhukov]

I have a custom annotation that generates that component ^

@Inject
@ContributesSingleton(AppScope::class)
class FeatureFlagServiceImpl(
  private val featureFlags: List<FeatureFlag<out FeatureFlagValue>>,
  private val featureFlagSyncer: FeatureFlagSyncer,
) : FeatureFlagService, FeatureFlagSyncWorker

[Kirill Zhukov]

I suspect it's because FeatureFlagServiceImpl itself is not annotated with @SingleIn?

[Kirill Zhukov]

I think I understand now...

[Kirill Zhukov]

any way to make this work without adding scope to implementation class?

[ralf]

I believe you can generate a provider method for FeatureFlagServiceImpl. It should take precedence over the inject constructor and not result in a duplicate binding. At least this was the case with Dagger.

In our custom annotation we avoid adding @Inject to these class altogether, e.g. we have:

@ContributesRobot(AppScope::class)
class MyRobot : Robot

Notice that there’s no @Inject and we generate the provider method instead with the right scope.

[Kirill Zhukov]

So the whole provider?

@Provides
fun provideFeatureFlagServiceImpl(
  a: ..., 
  b: ...
): FeatureFlagServiceImpl = FeatureFlagServiceImpl(a, b)

[Kirill Zhukov]

this works 👌

@Origin(value = FeatureFlagServiceImpl::class)
@ContributesTo(scope = AppScope::class)
public interface FeatureFlagServiceImplComponent {
  @Provides
  @SingleIn(scope = AppScope::class)
  public fun provideFeatureFlagServiceImpl(featureFlags: List<FeatureFlag<out FeatureFlagValue>>, featureFlagSyncer: FeatureFlagSyncer): FeatureFlagServiceImpl = FeatureFlagServiceImpl(featureFlags, featureFlagSyncer)

  @Provides
  public fun provideFeatureFlagService(implementation: FeatureFlagServiceImpl): FeatureFlagService = implementation

  @Provides
  public fun provideFeatureFlagSyncWorker(implementation: FeatureFlagServiceImpl): FeatureFlagSyncWorker = implementation
}

[Kirill Zhukov]

which makes sense