Creating an indigenous dependency injection framework

I am creating an analytics library. I have dozens of classes in it which i need to use via dependency injection to avoid writing boilerplate code. I would have used dagger but i want to keep the library independent of third party SDKs . Can someone guide me through writing our own indigenous dependency injection framework which would efficiently take care of all of class declarations and instatiations on demand in the code?

I tried using Hashmap for class registry for storing instances of all of my classes, but that would mean we would declare all of the classes at once where many of them would be left unused in runtime

You are going in correct direction when using a hash-map for using it as a registry of classes. Just that instead of instance as values you need to pass consumers which would instantiate when called.

Here are steps to implement the same :

Objective 1st : Storing the classes in registry :

Step 1: Create a class where you would keep your Hash-map of registries. Let's name this class as DiConstructor where you would declare the hash-map like one below :

private final Map<Class<T>, ClassFactory> holder = new HashMap<>();

here ClassFactory being Interface to Factories of new instances of type T

Step 2: Write a function that would create registry for all of your classes.

public <T> void registerFactory(Class<T> clazz, ClassFactory<T> factory) {
        holder.put(clazz, factory);
}

Step 3: Create a declaration class where you would add registries for all of your classes and use this method :

registerFactory(MyClassNameToDi.class,
                    new ClassFactory<MyClassNameToDi>() {
                        @NonNull
                        @Override
                        public MyClassNameToDi get(DiConstructor di) {
                            return new MyClassNameToDi();
                        }
                    });

Note : This code to create and declare registries should be done while initialising your library so that the classes will be resolvable on run time later.

Objective 2nd: Retrieving values from registry

There are multiple ways to do so, now that you have the class factory stored as value.

Option 1: When you have DiConstructor reference with you, you can write a getter method which would return the class instance when its reference is passed as argument. It would look something like this :

public <T> T get(Class<T> clazz) {
     ClassFactory classFactory = holder.get(clazz);
     Object instance = null;
     if (classFactory != null) {
        instance = classFactory.get(this);
     }
   return clazz.cast(instance);
}

Note: You will need to try-catch this code as it might throw exception when record is not found in HashMap
Now using this would be pretty much straightforward with DiConstructor instance . Keeping instance name di here.

    di.get(MyClassNameToDi.class);

Option 2: Using annotations, just like dagger

Example of usage in source code :

Declare the dependency with inject annotation .

@Inject
private YourClassToDi classInstance;

Now create a class which would receive all fields with inject annotations from this class to resolve the dependencies. Let's name it as MyAndroidInjector. Inside this class write a function inject which would contain activity context as argument.

Let's see what we need to do in this inject method .

Collect all fields annotated with inject. You will need to use some of the Java reflection concepts here to retrieve the fields here. The code would look something like one below :

Set<Field> result = new HashSet<>();
Class<?> c = classs;
String canonicalName = c.getCanonicalName();
while (c != null && canonicalName != null && canonicalName.startsWith("com.yourpackagename")) {
for (Field field : c.getDeclaredFields())
{
 if (field.isAnnotationPresent(Named.class))
    {
     result.add(field);
    }
}
c = c.getSuperclass();canonicalName = c.getCanonicalName();
}

Now pick every field instance , check its annotation and resolve its dependency using field.set() and do not forget to apply setAccessible as true. Here you would need to get your Di registry class instance in getDiConstructor() method and resolve the dependencies.

for (Field field : result){
            String named = null;
            if (field.isAnnotationPresent(Named.class)) {
                named = field.getAnnotation(Named.class).value();
            }
            field.setAccessible(true);
            field.set(targetObject, getDiConstructor().get(named,
            field.getType()));
    }

At last calling this in your onCreate of activity containing the inject annotations would do the job.

    MyAndroidInjector.inject(this);