Inject automatically your Activities & Fragments & ViewModels & Service & BroadcastReceiver & ContentProvider, just with a simple annotation
def dagger_version = "2.14.1"
dependencies {
// aac
implementation "android.arch.lifecycle:extensions:1.1.0"
annotationProcessor "android.arch.lifecycle:compiler:1.1.0"
// dagger auto inject
implementation 'com.github.windsekirun:dagger-auto-inject:1.6.0'
annotationProcessor 'com.github.windsekirun:dagger-auto-inject-compiler:1.6.0'
//dagger2
compile "com.google.dagger:dagger:$dagger_version"
compile "com.google.dagger:dagger-android:$dagger_version"
compile "com.google.dagger:dagger-android-support:$dagger_version"
annotationProcessor "com.google.dagger:dagger-android-processor:$dagger_version"
annotationProcessor "com.google.dagger:dagger-compiler:$dagger_version"
}
Just add generated classes into your Dagger's component
@Singleton
@Component(modules = {
AppModule.class,
AndroidInjectionModule.class,
AndroidSupportInjectionModule.class,
ActivityModule.class,
FragmentModule.class,
ViewModelModule.class,
ServiceModule.class,
BroadcastReceiverModule.class,
ContentProviderModule.class
})
public interface AppComponent {
void inject(MainApplication application);
@Component.Builder
interface Builder {
@BindsInstance
Builder application(Application application);
AppComponent build();
}
}
Just annotate your application with @InjectApplication
givin your Component,
then call DaggerAutoInject.init(this);
Don't forget to implement HasActivityInjector
, HasServiceInjector
, HasBroadcastReceiverInjector
, HasContentProviderInjector
as follow
@InjectApplication(component = AppComponent.class)
public class MainApplication extends Application implements HasActivityInjector, HasServiceInjector,
HasBroadcastReceiverInjector, HasContentProviderInjector {
@Inject DispatchingAndroidInjector<Activity> mActivityDispatchingAndroidInjector;
@Inject DispatchingAndroidInjector<Service> mServiceDispatchingAndroidInjector;
@Inject DispatchingAndroidInjector<BroadcastReceiver> mBroadcastReceiverDispatchingAndroidInjector;
@Inject DispatchingAndroidInjector<ContentProvider> mContentProviderDispatchingAndroidInjector;
@Override
public void onCreate() {
super.onCreate();
final AppComponent appComponent = DaggerAppComponent.builder()
.application(this)
.build();
DaggerAutoInject.init(this, appComponent);
}
@Override
public AndroidInjector<Activity> activityInjector() {
return mActivityDispatchingAndroidInjector;
}
@Override
public AndroidInjector<Service> serviceInjector() {
return mServiceDispatchingAndroidInjector;
}
@Override
public AndroidInjector<BroadcastReceiver> broadcastReceiverInjector() {
return mBroadcastReceiverDispatchingAndroidInjector;
}
@Override
public AndroidInjector<ContentProvider> contentProviderInjector() {
return mContentProviderDispatchingAndroidInjector;
}
}
@InjectActivity
public class MainActivity extends AppCompatActivity {
@Inject
SharedPreferences sharedPreferences;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
protected void onStart() {
super.onStart();
sharedPreferences.edit()
.putString("androidVerions", "O")
.apply();
}
}
@InjectFragment
public class MainFragment extends Fragment {
@Inject
SharedPreferences sharedPreferences;
public static MainFragment newInstance() {
return new MainFragment();
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_main, container, false);
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
System.out.println(sharedPreferences.getAll());
}
}
Then in your Activity / BaseActivity, implements HasSupportFragmentInjector
public class BaseActivity extends AppCompatActivity implements HasSupportFragmentInjector {
@Inject
DispatchingAndroidInjector<Fragment> dispatchingFragmentInjector;
@Override
public AndroidInjector<Fragment> supportFragmentInjector() {
return dispatchingFragmentInjector;
}
}
Inject ViewModel within AAC (Android Architecture Components)
@InjectViewModel
public class MainViewModel extends AndroidViewModel {
@Inject
public MainViewModel(MainApplication application) {
super(application);
}
}
Then add DaggerViewModelFactory.kt in your project, and provides into Dagger
@Module
public abstract class BaseBindsModule {
@Binds
abstract ViewModelProvider.Factory bindViewModelFactory(DaggerViewModelFactory factory);
}
Now, you can get instance of ViewModel with Dagger.
private MainViewModel mViewModel;
@Inject ViewModelProvider.Factory mViewModelFactory;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(this, R.layout.main_activity, BindingComponent.create(this));
mViewModel = ViewModelProviders.of(this, mViewModelFactory).get(MainViewModel.class);
}
@InjectService
public class MainService extends Service {
@Override
public void onCreate() {
AndroidInjection.inject(this);
super.onCreate();
}
}
@InjectBroadcastReceiver
public class MainBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
AndroidInjection.inject(this, context);
}
}
Since AppWidgetProvider is sub-type of BroadcastReceiver, you can inject AppWidgetProvider too!
@InjectContentProvider
public class MainContentProvider extends ContentProvider {
@Override
public boolean onCreate() {
AndroidInjection.inject(this);
return false;
}
}
- Author: Florent Champigny
- Editor: WindSekirun (DongGil, Seo)
Copyright 2017 florent37, Inc.
Copyright 2018 WindSekirun (DongGil, Seo)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.