Dagger: Add @SuppressWarnings("unchecked")

[blackberry2016]

Note: DaggerAppComponent.java uses unchecked or unsafe operations.

DaggerAppComponent.java

@Generated(
  value = "dagger.internal.codegen.ComponentProcessor",
  comments = "https://google.github.io/dagger"
)
public final class DaggerAppComponent implements AppComponent {
  private App seedInstance;

  private Provider<AppBinder_MainActivity.MainActivitySubcomponent.Builder>
      mainActivitySubcomponentBuilderProvider;

  private Provider<App> seedInstanceProvider;

  private MainViewModel_Factory mainViewModelProvider;

  private Provider<Map<Class<? extends ViewModel>, Provider<ViewModel>>>
      mapOfClassOfAndProviderOfViewModelProvider;

  private Provider<ViewModelFactory> viewModelFactoryProvider;

  private DaggerAppComponent(Builder builder) {
    initialize(builder);
  }

  public static AppComponent.Builder builder() {
    return new Builder();
  }

  private Map<Class<? extends Activity>, Provider<AndroidInjector.Factory<? extends Activity>>>
      getMapOfClassOfAndProviderOfFactoryOf() {
    return Collections
        .<Class<? extends Activity>, Provider<AndroidInjector.Factory<? extends Activity>>>
            singletonMap(MainActivity.class, (Provider) mainActivitySubcomponentBuilderProvider);
  }

  private DispatchingAndroidInjector<Activity> getDispatchingAndroidInjectorOfActivity() {
    return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(
        getMapOfClassOfAndProviderOfFactoryOf());
  }

  private DispatchingAndroidInjector<BroadcastReceiver>
      getDispatchingAndroidInjectorOfBroadcastReceiver() {
    return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(
        Collections
            .<Class<? extends BroadcastReceiver>,
                Provider<AndroidInjector.Factory<? extends BroadcastReceiver>>>
                emptyMap());
  }

  private DispatchingAndroidInjector<Fragment> getDispatchingAndroidInjectorOfFragment() {
    return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(
        Collections
            .<Class<? extends Fragment>, Provider<AndroidInjector.Factory<? extends Fragment>>>
                emptyMap());
  }

  private DispatchingAndroidInjector<Service> getDispatchingAndroidInjectorOfService() {
    return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(
        Collections
            .<Class<? extends Service>, Provider<AndroidInjector.Factory<? extends Service>>>
                emptyMap());
  }

  private DispatchingAndroidInjector<ContentProvider>
      getDispatchingAndroidInjectorOfContentProvider() {
    return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(
        Collections
            .<Class<? extends ContentProvider>,
                Provider<AndroidInjector.Factory<? extends ContentProvider>>>
                emptyMap());
  }

  private DispatchingAndroidInjector<android.support.v4.app.Fragment>
      getDispatchingAndroidInjectorOfFragment2() {
    return DispatchingAndroidInjector_Factory.newDispatchingAndroidInjector(
        Collections
            .<Class<? extends android.support.v4.app.Fragment>,
                Provider<AndroidInjector.Factory<? extends android.support.v4.app.Fragment>>>
                emptyMap());
  }

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.mainActivitySubcomponentBuilderProvider =
        new Provider<AppBinder_MainActivity.MainActivitySubcomponent.Builder>() {
          @Override
          public AppBinder_MainActivity.MainActivitySubcomponent.Builder get() {
            return new MainActivitySubcomponentBuilder();
          }
        };
    this.seedInstanceProvider = InstanceFactory.create(builder.seedInstance);
    this.mainViewModelProvider = MainViewModel_Factory.create(seedInstanceProvider);
    this.mapOfClassOfAndProviderOfViewModelProvider =
        MapProviderFactory.<Class<? extends ViewModel>, ViewModel>builder(1)
            .put(MainViewModel.class, (Provider) mainViewModelProvider)
            .build();
    this.viewModelFactoryProvider =
        DoubleCheck.provider(
            ViewModelFactory_Factory.create(mapOfClassOfAndProviderOfViewModelProvider));
    this.seedInstance = builder.seedInstance;
  }

  @Override
  public void inject(App arg0) {
    injectApp(arg0);
  }

  @Override
  public void inject(AGlideModule glideModule) {}

  @CanIgnoreReturnValue
  private App injectApp(App instance) {
    DaggerApplication_MembersInjector.injectActivityInjector(
        instance, getDispatchingAndroidInjectorOfActivity());
    DaggerApplication_MembersInjector.injectBroadcastReceiverInjector(
        instance, getDispatchingAndroidInjectorOfBroadcastReceiver());
    DaggerApplication_MembersInjector.injectFragmentInjector(
        instance, getDispatchingAndroidInjectorOfFragment());
    DaggerApplication_MembersInjector.injectServiceInjector(
        instance, getDispatchingAndroidInjectorOfService());
    DaggerApplication_MembersInjector.injectContentProviderInjector(
        instance, getDispatchingAndroidInjectorOfContentProvider());
    DaggerApplication_MembersInjector.injectSetInjected(instance);
    dagger.android.support.DaggerApplication_MembersInjector.injectSupportFragmentInjector(
        instance, getDispatchingAndroidInjectorOfFragment2());
    return instance;
  }

  private static final class Builder extends AppComponent.Builder {
    private App seedInstance;

    @Override
    public AppComponent build() {
      if (seedInstance == null) {
        throw new IllegalStateException(App.class.getCanonicalName() + " must be set");
      }
      return new DaggerAppComponent(this);
    }

    @Override
    public void seedInstance(App arg0) {
      this.seedInstance = Preconditions.checkNotNull(arg0);
    }
  }

  private final class MainActivitySubcomponentBuilder
      extends AppBinder_MainActivity.MainActivitySubcomponent.Builder {
    private MainActivity seedInstance;

    @Override
    public AppBinder_MainActivity.MainActivitySubcomponent build() {
      if (seedInstance == null) {
        throw new IllegalStateException(MainActivity.class.getCanonicalName() + " must be set");
      }
      return new MainActivitySubcomponentImpl(this);
    }

    @Override
    public void seedInstance(MainActivity arg0) {
      this.seedInstance = Preconditions.checkNotNull(arg0);
    }
  }

  private final class MainActivitySubcomponentImpl
      implements AppBinder_MainActivity.MainActivitySubcomponent {
    private MainActivitySubcomponentImpl(MainActivitySubcomponentBuilder builder) {}

    @Override
    public void inject(MainActivity arg0) {
      injectMainActivity(arg0);
    }

    @CanIgnoreReturnValue
    private MainActivity injectMainActivity(MainActivity instance) {
      DaggerAppCompatActivity_MembersInjector.injectSupportFragmentInjector(
          instance, DaggerAppComponent.this.getDispatchingAndroidInjectorOfFragment2());
      DaggerAppCompatActivity_MembersInjector.injectFrameworkFragmentInjector(
          instance, DaggerAppComponent.this.getDispatchingAndroidInjectorOfFragment());
      Activity_MembersInjector.injectOkBroadcastReceiver(instance, new OkBroadcastReceiver());
      Activity_MembersInjector.injectViewModelFactory(
          instance, DaggerAppComponent.this.viewModelFactoryProvider.get());
      MainActivity_MembersInjector.injectApp(instance, DaggerAppComponent.this.seedInstance);
      return instance;
    }
  }
}

[ronshapiro]

This is a duplicate of a few other issues

[y0sh33]

What are some of the duplicated issues? Can you please link to them?

[HariAlexiev]

I'm interest in this too ? Where are those tasks ?

Seems to me there are coming from Provider interface

private Map, Provider>>
getMapOfClassOfAndProviderOfFactoryOf() {
return MapBuilder
., Provider>>
newMapBuilder(8)
.put(MainActivity.class, (Provider) mainActivitySubcomponentBuilderProvider)
.put(MissionListActivity.class, (Provider) missionListActivitySubcomponentBuilderProvider)
.put(MissionActivity.class, (Provider) missionActivitySubcomponentBuilderProvider)
.put(LoginActivity.class, (Provider) loginActivitySubcomponentBuilderProvider)
.put(
OperationSelectionActivity.class,
(Provider) operationSelectionActivitySubcomponentBuilderProvider)
.put(PreparationActivity.class, (Provider) preparationActivitySubcomponentBuilderProvider)
.put(
MissionSummaryActivity.class,
(Provider) missionSummaryActivitySubcomponentBuilderProvider)
.put(
ArticleSelectionActivity.class,
(Provider) articleSelectionActivitySubcomponentBuilderProvider)
.build();
}