Dagger Android для пользовательского класса возможно?

Question

Я пытаюсь заставить dagger-android работать с Conductor (или любым другим классом).Я попытался воспроизвести все, что делает AndroidSupportInjectionModule (и друзья), что, на мой взгляд, аналогично обработке пользовательских классов.

Однако я получаю

C:\Users\ursus\AndroidStudioProjects\...\ControllersModule.java:15: error: com.foo.bar.ChannelsController is not a framework type
    public abstract com.foo.bar.ChannelsController channelsController();

Итак, моя «библиотека»code

package com.foo.bar

import com.bluelinelabs.conductor.Controller;
import dagger.Module;
import dagger.android.AndroidInjectionModule;
import dagger.android.AndroidInjector;
import dagger.internal.Beta;
import dagger.multibindings.Multibinds;

import java.util.Map;

@Beta
@Module(includes = AndroidInjectionModule.class)
public abstract class ConductorInjectionModule {

    private ConductorInjectionModule() {
    }

    @Multibinds
    abstract Map<Class<? extends Controller>, AndroidInjector.Factory<? extends Controller>> controllerInjectorFactories();

    @Multibinds
    abstract Map<String, AndroidInjector.Factory<? extends Controller>> controllerInjectorFactoriesWithStringKeys();
}

Я даже не скомпилирован, поэтому бессмысленно вставлять ConductorInjection & HasControllerInjector

Использование:

@Module
abstract class AppModule {
    @ContributesAndroidInjector abstract fun mainActivity(): MainActivity
    @ContributesAndroidInjector abstract fun channelsController(): ChannelsController
}

class App : Application(), HasActivityInjector, HasControllerInjector {

    @Inject lateinit var activityInjector: DispatchingAndroidInjector<Activity>
    @Inject lateinit var controllerInjector: DispatchingAndroidInjector<Controller>

    private lateinit var appComponent: AppComponent

    override fun onCreate() {
        super.onCreate()

        appComponent = DaggerAppComponent.builder()
            .applicationContext(this)
            .build()
            .apply {
                inject(this@App)
            }
    }

    override fun activityInjector() = activityInjector
    override fun controllerInjector() = controllerInjector
}

@Singleton
@Component(
    modules = [
        AndroidInjectionModule::class,
        ConductorInjectionModule::class,
        AppModule::class,
        NetModule::class
    ]
)
interface AppComponent {

    fun inject(app: App)

    @Component.Builder
    interface Builder {

        @BindsInstance
        fun applicationContext(context: Context): Builder

        fun build(): AppComponent
    }
}


implementation deps.dagger.runtime
implementation deps.dagger.androidRuntime
kapt deps.dagger.compiler
kapt deps.dagger.androidCompiler

, где все версии "2.19" (пробовал 2.16)

AGP "com.android.tools.build:gradle:3.3.0-rc02" (пробовал стабильную 3.2.1)

Есть подсказка?На мой взгляд, все должно работать так же, как и 1018

.

Answer 1

ошибка: com.foo.bar.ChannelsController не является типом фреймворка

Итак, вопрос, на который нужно ответить, "как dagger-android знает, что такое тип фреймворка или нет".

Ответ можно найти в этом коммите для Dagger-Android между 2.19 и 2.20, где они" удалили старый способ работы для лучшей совместимости с AndroidX ".

Итак, как мы можем видеть в https://stackoverflow.com/a/53891780/2413303,

   /**    
    * Returns the Android framework types available to the compiler, keyed by their associated {@code 
    * dagger.android} {@link MapKey}s. This will always contain the types that are defined by the 
    * framework, and only contain the support library types if they are on the classpath of the   
    * current compilation.    
    */    
   static ImmutableMap<Class<? extends Annotation>, TypeMirror> frameworkTypesByMapKey(   
       Elements elements) {   
     return ImmutableMap.copyOf(  
         Stream.of(   
                 elements.getPackageElement("dagger.android"),    
                 elements.getPackageElement("dagger.android.support"))    
             .filter(packageElement -> packageElement != null)    
             .flatMap(packageElement -> typesIn(packageElement.getEnclosedElements()).stream())   
             .filter(AndroidMapKeys::isNotAndroidInjectionKey)    
             .filter(type -> isAnnotationPresent(type, MapKey.class)) 
             .filter(mapKey -> mapKey.getAnnotation(MapKey.class).unwrapValue())  
             .flatMap(AndroidMapKeys::classForAnnotationElement)  
             .collect(toMap(key -> key, key -> mapKeyValue(key, elements)))); 
   }

у них был код, который проверял свои собственные типы @MapKey в dagger.android и dagger.android.support пакеты, которые выглядели так:

// java/dagger/android/support/FragmentKey.java

 @Beta  
 @MapKey    
 @Documented    
 @Target(METHOD)    
 @Deprecated    
 public @interface FragmentKey {    
   Class<? extends Fragment> value();   
 }

Таким образом, они читают типы фреймворков на основе того, что @MapKey s было доступно в пакетах dagger.android и dagger.android.support.

---

Очевидно, они удалили эту проверку в 2.20, так что теперь вы можете вводить все, что хотите.Радуйтесь!

Но в противном случае вы могли бы взломать его таким образом, что бы вы добавили @ControllerKey и @ViewKey in dagger.android в ваш проект, и он, вероятно, действительно работал бы с2.19.

В этом коммите также удаляются тесты, которые проверяли наличие ошибок в «не типе фреймворка».

Ah и

@Multibinds
abstract Map<String, AndroidInjector.Factory<? extends Controller>> controllerInjectorFactoriesWithStringKeys();

Вы можетеудалите эту часть тоже с 2.20, все что вам нужно сейчас это AndroidInjectionModule.

Answer 2

Для будущих путешественников, они жестко запрограммировали кое-что из приложений в аннотпроцессор, поэтому сработали фрагменты appcompat.

обновление до кинжала 2.20, оно будет волшебным образом работать