DaggerSharpener

DaggerSharpener is an Android library which simplifies the creation of a Dagger2 dependency graph while helping mentain the code more readable. This library comes as an extension for Dagger2.

In this repository you can find an example project showing its usage as well as the library projects. The example is replicating the following dagger2 tutorial project (using Dagger2 + DaggerSharpener): https://github.com/patrick-doyle/dagger2-tutorial

Installation with Android Gradle

// Add DaggerSharpener and Dagger2 dependencies
dependencies {
    implementation 'com.github.alexdochioiu:daggersharpener:0.1.0'
    annotationProcessor 'com.github.alexdochioiu:daggersharpener-processor:0.1.0'
    
    implementation 'com.google.dagger:dagger:2.17'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.17'
}

Usage Example

Step 1: Create a normal dagger2 module

@Module
public class MyModule {
    @Provides
    Object myObject() {
        return new Object();
    }
}

Note: As you can see, no scope has yet been given to the object. This will be addressed in the following steps.

Step 2: Creating the Application (Sharp) Component ()

@SharpComponent(
        modules = MyModule.class // array of multiple modules can be provided as {A.class, B.class, ...}
)
public class MyApplication extends Application {
}

Step 2.1: Build the project

After building, two files are generated:

SharpMyApplicationComponent.java -- (Names is formed as: Sharp + Class Name + Component)

@Component
@SharpMyApplicationScope
public interface SharpMyApplicationComponent {
  MyApplication inject(MyApplication thisClass);
}

SharpMyApplicationScope.java -- (Names is formed as: Sharp + Class Name + Scope)

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface SharpMyApplicationScope {}

Step 2.2 (Optional): Go back to the module and add the scope for the provided object(s)

@Module
public class MyModule {
    @Provides
    @SharpMyApplicationScope
    Object myObject() {
        return new Object();
    }
}

Step 2.3 : Inject the dependencies in MyApplication

@SharpComponent(
        modules = MyModule.class
)
public class MyApplication extends Application {

    private SharpMyApplicationComponent sharpComponent;
    
    @Inject
    Object injectedObject;

    @Override
    public void onCreate() {
        super.onCreate();
        
        // Name is: Dagger + Sharp + Class Name + Component
        sharpComponent = DaggerSharpMyApplicationComponent.builder().build();
        sharpComponent.inject(this);

        Log.d("MyApplication", "onCreate: " + injectedObject.toString());
    }

    public SharpMyApplicationComponent getSharpComponent() {
        return sharpComponent;
    }
}

Note: By running the code and checking logcat, you will see that the injectedObject is non-null. This indicates our object got successfully injected.

Step 3: Creating the Activity (Sharp) Component

@SharpComponent(
        dependencies = SharpMyApplicationComponent.class
)
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Note: The new Sharp Activity Component depends on SharpMyApplicationComponent

Step 3.1: Build the project

After building, two new files are generated:

SharpMainActivityComponent.java

@Component
@SharpMainActivityScope
public interface SharpMainActivityComponent {
  MainActivity inject(MainActivity thisClass);
}

SharpMainActivityScope.java

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface SharpMainActivityScope {}

Step 3.2: Expose dependencies from MyApplication to its dependants

@SharpComponent(
        modules = MyModule.class,
        provides = Object.class // Array of dependencies can be provided as {A.class, B.class, etc.}
)
public class MyApplication extends Application {
  ...
}

Step 3.3 : Inject the dependencies in MainActivity

@SharpComponent(
        sharpDependencies = MyApplication.class // The class(es) annotated with @SharpComponent
)
public class MainActivity extends AppCompatActivity {

    @Inject
    Object myObject;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        DaggerSharpMainActivityComponent.builder()
                .sharpMyApplicationComponent(((MyApplication) getApplication()).getSharpComponent())
                .build()
                .inject(this);

        Log.d("MainActivity", "onCreate: " + myObject.toString());
    }
}

Note: By running the code and checking logcat, you will see that injectedObject from MyApplication and myObject from MainActivity are indeed the same instance (as long as you did the step 2.2). If you did not do step 2.2, the instance will be different for the two objects.

Step 4: Enjoy

Using DaggerSharpener will still allow you to use @Inject on constructors. Also, the generated scopes can be safely used on the classes which inject constructors.

For some docs, keep on reading below!

SharpComponent explained

modules

Takes an array of dagger2 modules

sharpDependencies

Takes an array of classes annotated as @SharpComponent which will serve as dependencies for this new sharp component which is to be generated.

dependencies

Takes an array of dagger2 components which will serve as dependencies for this new sharp component which is to be generated. This is to allow the developer to mix manually created dagger2 components and sharp components. Note: sharpDependencies and dependencies can be used together safely

scope

If you want to use a manually created scope, you can give it there. If you do so, no scope will be generated for this sharp component.

provides

The array of (un-named) classes to be provided to the dependants of this sharp component

providesNamed (to be released in version 0.2.0)

The array of @NamedPair entries. Each entry has a String name and a class (see below)

SharpComponent example (slightly more complex than before)

@SharpComponent(
        modules = {GithubServiceModule.class, PicassoModule.class},
        sharpDependencies = MyApplication.class,
        //dependencies = SomeDaggerComponent.class,
        scope = MyCustomScope.class,
        provides = {GithubService.class, Resources.class},
        providesNamed = {
                @NamedPair(aName = "myPicasso", aClass = Picasso.class),
                @NamedPair(aName = "appContext", aClass = Context.class),
                @NamedPair(aName = "activityContext", aClass = Context.class)
        }
)
public class MyFragment extends Fragment {
  ...
}

The code above would generate the following component

@Component(
    modules = {GithubServiceModule.class, PicassoModule.class},
    dependencies = {SharpMyApplicationComponent.class}
)
@MyCustomScope
public interface SharpMyFragmentComponent {
  MyFragment inject(MyFragment thisClass);

  GithubService provideGithubService();

  Resources provideResources();

  @Named("myPicasso")
  Picasso providePicasso_myPicasso();

  @Named("appContext")
  Context provideContext_appContext();

  @Named("activityContext")
  Context provideContext_activityContext();
}