-  - The Android Arsenal – Dependency Injections -  - The Android Arsenal – Dependency Injections

This is a tiny lifecycle aware provider for . It17;s inspired in ViewModelProviders from Android Architecture Components and it relies on Service Tree to retain instances organized according to the structure and active components of your application.

Why should you use it?

  • No leaks: it will never hold on to any reference of your activities or fragments
  • Low memory footprint: it’s smart about instance creation
  • Plug and play: it initializes itself upon first use
  • Lifecycle aware: every resource is automatically created and disposed for you as your activities and fragments get created and destroyed
  • No imposition of inheritance: no need to extend from an application, activity, fragment, or resource class, just use it without restrictions
  • Team player: it plays well with Dagger. Plus, it doesn’t require any previous configuration
  • Light as air: only 26kb and 102 methods (Release 0.1.0)

Show me the code!

protected void onCreate(Bundle savedInstanceState) {

    // App singleton example. This instance will always be the same.
    SomeService service = LifecycleServices.of(getApplication())

     * Activity singleton example.
     * This instance will always be the same throughout this activity's lifecycle
    MainViewModel viewModel = LifecycleServices.of(this)
            .getOrCreate(() -> new MainViewModel("some custom string"));

Some things to note

  • If the screen rotates, all bound instances remain, but if the activity is destroyed, then all activity’s services are disposed
  • LifecycleServices is used to retrieve a ServiceProvider instance associated to your Application, Activity or Fragment
  • Given a class, ServiceProvider provides an instance of a LifecycleService, which is an abstraction that manages the lifespan of the required object. ServiceProviders are managed instances too, so don’t worry about keeping references to them, they don’t get recreated for the same Application, Activity or Fragment
  • Finally, a LifecycleService will be able to get a managed instance for you, or it will create one using a ServiceBuilder that receives as a parameter. If you have more complex dependencies, you should use a well known DI library and just request the injector to be managed (An example using Dagger is shown below)
  • Although LifecycleServices provides a method to manually dispose the instances, it’s highly recommended not to use it, as the library will do that for you

Please note that the intention is NOT to replace dependency injection.

Dagger example

@Inject MainViewModel viewModel;
@Inject SomeService service;

protected void onCreate(Bundle savedInstanceState) {

    // Manage the component and use it to inject your dependencies with your custom scopes
    // Use your instances...

In this example, the application class handles the app component (it could have also used Lifecycle Services). We request a managed instance of an activity component and we use that to inject the dependencies. Note that this can be abstracted in a method of a parent class or in an injector helper object.

Efforts are still being made to make this integration even easier.


Add jitpack as a repository in your -level build.gradle file

allprojects {
    repositories {
        maven { url "" }

Add the Android Lifecycle Services dependency to your module-level build.gradle file

dependencies {
    compile 'com.github.juanmc2005:android-lifecycle-services:x.y.z'


Copyright 2017 Juan Manuel Coria

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

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
See the License for the specific language governing permissions and
limitations under the License.

Source link


Please enter your comment!
Please enter your name here