The document discusses dependency injection (DI) using RoboGuice in Android applications. DI makes code more concise, modular, and easier to test by allowing classes to declare dependencies without knowing how they are satisfied. RoboGuice uses annotations to inject dependencies into activities and services. It allows for loose coupling, high cohesion, and centralized configuration through bindings. DI improves testability by increasing controllability, observability, and isolation of units under test.

1. Dependency Injection
with
RoboGuice
©2013 Tom Braun <tom.braun@apps4use.com>

3. {concept}
Inversion of Control (IoC)
{concept}
Dependency Injection (DI)
Googe Guice Spring core PicoContainer Plexus
Android
RoboGuice Dagger
Annotations

4. Dependency Injection (DI)
Makes code ...
● more concise
● more modular
● easier to test

5. public class GuicelessActivity extends Activity {
…
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
@ContentView(R.layout.main)
public class GuicyActivity extends RoboActivity {

6. ...
TextView outputText;
...
outputText =(TextView)findViewById(R.id.text_output);
@InjectView(R.id.text_output) TextView outputText;

7. String appName;
...
appName = getString(R.string.app_name);
@InjectView(R.id.text_output) TextView outputText;

8. SensorManager sensorManager;
...
sensorManager
= (SensorManager)getSystemService(SENSOR_SERVICE);
@Inject SensorManager sensorManager;

9. SomeController someController;
..
someController = new SomeController(this);
@Inject SomeController someController;
public class SomeController {
Activity hostActivity;
@Inject
public SomeController(Activity hostActivity) {
this.hostActivity = hostActivity;
}
}

10. public class GuicelessActivity extends Activity {
TextView outputText;
String appName;
SensorManager sensorManager;
SomeController someController;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
outputText = (TextView)findViewById(R.id.text_output);
appName = getString(R.string.app_name);
sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
someController = new SomeController(this);
}
}
@ContentView(R.layout.main)
public class GuicyActivity extends RoboActivity {
@InjectView(R.id.text_output) TextView outputText;
@InjectResource(R.string.app_name) String appName;
@Inject SensorManager sensorManager;
@Inject SomeController someController;
}

11. 15 LOC → 7 LOC
= more concisene

12. Dependency Injection (DI)
Makes code ...
● more concise
● more modular
● easier to test

13. Bindings
public class MyModule extends AbstractModule {
@Override
protected void configure() {
// custom binding go here
}
}

14. bind(ISomeService.class).to(SomeServiceDummy.class);

15. bind(ISomeService.class)
.toInstance(new SomeServiceReal("yes", 1));

16. @Inject
@Provides
public AnotherService provideAnotherService(
ISomeService someService
) {
return new AnotherService(someService, "bla");
}

17. Bindings allows for
● wiring up components
● configuring components

18. Adding
Google Analytics to an Activity
● onCreate → startNewSession
● onResume → trackPageView
● onDestroy → stopSession
● Attributes
● Support code

19. Component Bloat-Up
● anti pattern: God Class
● low coherence
● tight coupling
● low separation of concernes

20. public void onCreate(@Observes OnCreateEvent onCreateEvent)

21. @Inject protected AnalyticsMixin analyticsMixin;

22. We get:
● loose coupling
● high coherence
● centralized wiring
● centralized configuration

23. Testability (see wikipedia)
● controllability: The degree to which it is possible to control the state of the
component under test (CUT) as required for testing.
● observability: The degree to which it is possible to observe (intermediate
and final) test results.
● isolateability: The degree to which the CUT can be tested in isolation.
● separation of concerns: The degree to which the CUT has a single,
well defined responsibility.
● understandability: The degree to which the CUT is documented or
self-explaining.
● automatability: The degree to which it is possible to automate testing of
the CUT.
● heterogeneity: The degree to which the use of diverse technologies
requires to use diverse test methods and tools in parallel.

24. @RunWith(RobolectricTestRunner.class)
public class SomeServiceTest {
@Mock private SomeDAO mockDao;
@Mock private Logger mockLogger;
private SomeService cut;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
cut.someDao = mockDao;
cut.log = mockLogger;
}
@Test
public void testExecute_willPassWhenNotInBeta() {
when(mockDao.countSomeStuff()).thenReturn(23);
assertTrue(cut.hasEnoughStuff());
verify(mockLogger, times(1)).info("have 23");
}
}

25. Testability (see wikipedia)
● controllability ++
● observability ++
● isolateability ++
● separation of concerns ++
● understandability +
● automatability +
● heterogeneity o

26. Dependency Injection (DI)
Makes code ...
● more concise
● more modular
● easier to test

27. References:
● DI: http://martinfowler.com/articles/injection.html
● Guice: http://code.google.com/p/google-guice/
● RoboGuice: https://github.com/roboguice/roboguice
● Testability:
http://en.wikipedia.org/wiki/Software_testability
● Mockito: http://code.google.com/p/mockito/
● Rebolectric: http://pivotal.github.io/robolectric/
Contact:
● tom.braun@apps4use.com
● @tom___b
● http://play.google.com → GrooveGrid