依赖注入 - Dagger 2 注入 Android 应用程序上下文 - dependency injection - Dagger 2 injecting Android Application Context 小贝子编程网

我正在使用Dagger 2并让它工作，但是我现在需要访问Android应用程序上下文。

我不清楚如何注入和访问上下文。我尝试这样做如下：

@Module
public class MainActivityModule {    
    private final Context context;
    
    MainActivityModule(Context context) {
        this.context = context;
    }
    @Provides @Singleton
    Context provideContext() {
        return context;
    }
}

但是，这会导致以下异常：

java.lang.RuntimeException：无法创建应用程序： java.lang.IllegalStateException：必须设置 mainActivityModule

如果我检查dagger生成的代码，则会在此处引发此异常：

public Graph build() {  
    if (mainActivityModule == null) {
        throw new IllegalStateException("mainActivityModule must be set");
    }
    return new DaggerGraph(this);
}

我不确定这是否是注入上下文的正确方法 - 任何帮助将不胜感激。

@Module
public class MainActivityModule {    
    private final Context context;
    public MainActivityModule (Context context) {
        this.context = context;
    }
    @Provides //scope is not necessary for parameters stored within the module
    public Context context() {
        return context;
    }
}
@Component(modules={MainActivityModule.class})
@Singleton
public interface MainActivityComponent {
    Context context();
    void inject(MainActivity mainActivity);
}

然后

MainActivityComponent mainActivityComponent = DaggerMainActivityComponent.builder()
    .mainActivityModule(new MainActivityModule(MainActivity.this))
    .build();

我花了一段时间才找到合适的解决方案，所以认为这可能会为其他人节省一些时间，据我所知，这是当前 Dagger 版本 (2.22.1( 的首选解决方案。

在下面的示例中，我需要Application的Context来创建RoomDatabase(发生在StoreModule年(。

如果您看到任何错误或错误，请告诉我，以便我也会学习:)

元件：

// We only need to scope with @Singleton because in StoreModule we use @Singleton
// you should use the scope you actually need
// read more here https://google.github.io/dagger/api/latest/dagger/Component.html
@Singleton
@Component(modules = { AndroidInjectionModule.class, AppModule.class, StoreModule.class })
public interface AwareAppComponent extends AndroidInjector<App> {
    // This tells Dagger to create a factory which allows passing 
    // in the App (see usage in App implementation below)
    @Component.Factory
    interface Factory extends AndroidInjector.Factory<App> {
    }
}

应用模块：

@Module
public abstract class AppModule {
    // This tell Dagger to use App instance when required to inject Application
    // see more details here: https://google.github.io/dagger/api/2.22.1/dagger/Binds.html
    @Binds
    abstract Application application(App app);
}

商店模块：

@Module
public class StoreModule {
    private static final String DB_NAME = "aware_db";
    // App will be injected here by Dagger
    // Dagger knows that App instance will fit here based on the @Binds in the AppModule    
    @Singleton
    @Provides
    public AppDatabase provideAppDatabase(Application awareApp) {
        return Room
                .databaseBuilder(awareApp.getApplicationContext(), AppDatabase.class, DB_NAME)
                .build();
    }
}

应用程序：

public class App extends Application implements HasActivityInjector {
    @Inject
    DispatchingAndroidInjector<Activity> dispatchingAndroidInjector;
    @Override
    public void onCreate() {
        super.onCreate();
        // Using the generated factory we can pass the App to the create(...) method
        DaggerAwareAppComponent.factory().create(this).inject(this);
    }
    @Override
    public AndroidInjector<Activity> activityInjector() {
        return dispatchingAndroidInjector;
    }
}

我读过这篇文章，它非常有帮助。

https://medium.com/tompee/android-dependency-injection-using-dagger-2-530aa21961b4

示例代码。

更新：我从AppComponent.kt中删除了这些行，因为不是必需的

fun context(): Context
fun applicationContext(): Application

AppComponent.kt

   @Singleton
    @Component(
        modules = [
            NetworkModule::class,
            AppModule::class
        ]
    )
    interface AppComponent {
        fun inject(viewModel: LoginUserViewModel)
    }

AppModule.kt

@Module
class AppModule(private val application: Application) {
    @Provides
    @Singleton
    fun providesApplication(): Application = application
    @Provides
    @Singleton
    fun providesApplicationContext(): Context = application
    @Singleton
    @Provides
    fun providesNetworkConnectivityHelper(): NetworkConnectivityHelper{
        return NetworkConnectivityHelper(application.applicationContext)
    }
}

NetworkConnectivityHelper.kt

并且只添加了@Inject构造函数来传递上下文

class NetworkConnectivityHelper @Inject constructor(context: Context) {
    private val connectivityManager =
        context.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager
    @Suppress("DEPRECATION")
    fun isNetworkAvailable(): Boolean {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val nc = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
            nc != null
                    && nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                    && nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
        }
        val networkInfo = connectivityManager.activeNetworkInfo
        return networkInfo != null && networkInfo.isConnected
    }
}

App class.kt

class App : Application() {
    lateinit var appComponent: AppComponent
    override fun onCreate() {
        super.onCreate()
        this.appComponent = this.initDagger()
    }
    private fun initDagger() = DaggerAppComponent.builder()
        .appModule(AppModule(this))
        .build()
}

终于在我的活动中，我注射了我的助手

 @Inject lateinit var networkConnectivity: NetworkConnectivityHelper

耶！它对我有用。

未正确构建应用程序组件，需要传入应用程序。这个dagger 2 示例完美地展示了如何做到这一点： https://github.com/google/dagger/tree/master/examples/android-simple/src/main/java/com/example/dagger/simple

更新：
工作链接：https://github.com/yongjhih/dagger2-sample/tree/master/examples/android-simple/src/main/java/com/example/dagger/simple

@Singleton
@Component(modules = [YourModule::class, ThatOtherModule::class])
interface ApplicationComponent {
    @Component.Builder
    interface Builder {
        @BindsInstance fun applicationContext(applicationContext: Context): Builder
        fun build(): ApplicationComponent
    }
}
class YourApplication : Application() {
    val component: ApplicationComponent by lazy {
        DaggerApplicationComponent.builder()
            .applicationContext(applicationContext)
            .build()
    }
}

使用 @BindInstance 声明一个提供上下文依赖关系的抽象函数，即@BindsInstance fun applicationContext(applicationContext: Context): Builder
使用 .applicationContext(applicationContext) 设置上下文

也许我们可以注入如下所示的上下文：

应用程序组件

@Component(
    modules = [
        (ApplicationModule::class),
        (AndroidSupportInjectionModule::class),
        (UiBindingModule::class)
    ]
)
interface ApplicationComponent : AndroidInjector<AndroidApplication> {
    override fun inject(application: AndroidApplication)
    @Component.Builder
    interface Builder {
        @BindsInstance
        fun application(application: AndroidApplication): Builder
        @BindsInstance
        fun context(context: Context): Builder
        fun build(): ApplicationComponent
    }
}

自定义应用程序扩展dagger应用程序

class AndroidApplication : DaggerApplication() {
    override fun applicationInjector(): AndroidInjector<out DaggerApplication> {
        return DaggerApplicationComponent.builder().application(this).context(this).build()
    }
}

示例应用模块

@Module
abstract class ApplicationModule {
    /**
     * Binds a background thread executor, which executes threads from a thread pool
     * @param jobExecutor
     * @return
     */
    @Binds
    internal abstract fun provideThreadExecutor(jobExecutor: JobExecutor): ThreadExecutor
    /**
     * Binds main ui looper thread
     * @param uiThread
     * @return
     */
    @Binds
    internal abstract fun providePostExecutionThread(uiThread: UIThread): PostExecutionThread
}

示例 UI 绑定模块

@Module
abstract class UiBindingModule {
    @ContributesAndroidInjector(modules = [(MainActivityModule::class)])
    internal abstract fun mainActivity(): MainActivity
    @ContributesAndroidInjector(modules = [(MapFragmentModule::class)])
    internal abstract fun mapFragment(): MapFragment
}

依赖注入 - Dagger 2 注入 Android 应用程序上下文

相关内容

最新更新

热门标签：