Introduction of a Dependency Injection Framework

Current Implementation

Right now, The code uses object Singletons and static methods to access shared data and execute code e.g. [1], [2] and in many more files.

This would make testing so hard as it will make the experience for developers and contributors unpleasant as they would spend more time in writing the mock code rather than testing their actual work. e.g. [3]

Suggested Enhancement

Introduction of a DI framework that will make writing a testable, maintainable and extensible code achievable. The selection of which framework to use is up to the maintainers.

Expected Benefits

These are the points on top of my head, I might be for sure missing some.

• Embracing constructor injected objects rather than the current approach of using object singletons, as using Singletons is considered as anti-pattern.
• Reducing the memory footprint of the application since the DI framework will take care of scoping of the objects, right now everything is declared object and once accessed it will be kept in memory even though it may not be needed anymore after it has served its purpose.
• Instrumentation tests would be easier to write since the created test DI Graph will be responsible to provide the dependencies across all the application layers, right now it is impossible to provide a mock network or a Database for example
• Increasing the test coverage point in the README would be easier to achieve as objects will be able to get instantiated through ctor injection hence providing fakes/mocks would be easier.

[timo-drick]

Please do not introduce more complexity as necessary. It is much more difficult to understand the code when Dagger or similar frameworks are used. And it is also possible to do testing without this frameworks. Btw. in my opinion the testing argument is very weak to justify that the code will be obfuscated. Especially for this porject it is very important to keep every thing as simple as possible.

[svenjacobs]

@timo-drick I don’t see how the dependency injection pattern introduces “unnecessary” complexity? Actually you don’t need a framework like Dagger 2 for implementation. The basic pattern is very simple and can be implemented “by hand”. I see many benefits of this pattern like modularity, reusability and testability for example.