How to inject a SyncAdapter

Question

I just started to learn how to use Dagger, and I have converted my Backend connection class to be injected automatically.

That class handles Retrofit and performs network requests. It used to have static methods but now it is an object, e.g.:

Backend.fetchPost(context, 42); // old way
mBackend.fetchPost(42); // mBackend is an injected field

The context is used to retrieve the AccountManager which provides the OAuth token with my backend server. This is now injected automatically.

That works well in activities and fragments but I can't figure out how to inject my SyncAdapter class.
Indeed, it is a framework object that I don't have control over, and AndroidInjections doesn't have a static method ready to inject that kind of class.

Here's the code that I would like to get to work:

/**
 * Handle the transfer of data between the backend and the app, using the Android sync adapter framework.
 */
public class SyncAdapter extends AbstractThreadedSyncAdapter {    
    @Inject
    public Backend mBackend; // can't use constructor injection,
                             // so might aswell use a public field

    public SyncAdapter(Context context, boolean autoInitialize) {
        super(context, autoInitialize);
    }

    public SyncAdapter(Context context, boolean autoInitialize, boolean allowParallelSyncs) {
        super(context, autoInitialize, allowParallelSyncs);
    }

    @Override
    public void onPerformSync(Account account, Bundle extras, String authority, ContentProviderClient provider, SyncResult syncResult) {
        List<Post> posts = mBackend.getPosts();
        // do stuf with the posts
    }
}

So I know I should call @#!.inject(this) somewhere in the constructor, but I don't know exactly how I'm supposed to do this:

• use a static field on the application class to retrieve the head of the dependency graph, and let it browse it until it can inject all the fields
• create a factory class and interfaces like the one used for activities and fragments
• something else?

More details about my dagger2 implementation:

• the Backend class has an @Inject constructor, so dagger should be able to construct it provided it can get instances of the API and the Gson parser:

  @Inject
  public Backend(BackendApi api, @UploadGson Gson uploadGson) {
      mApi = api;
      mUploadGson = uploadGson;
  }
  

• the BackendModule dagger module has @Provide methods for a @UploadGson Gson object, and the dependency list from a BackendApi (retrofit) to the application class (through various objects such as injectors or loggers)
• the BackendModule.class is referenced in the modules = {} declaration of the application @Component

So basically, given an application object, dagger should be able to instantiate an object of the class Backend, which I want to inject into my SyncAdapter class.
I just don't know how to actually trigger the injection.

PS: as stated, I learned Dagger yesterday, so please advise if you think that my implementation is broken.

Answer 1

I think I went too fast posting here. I thought the framework instantiated my SyncAdapter, however I'm doing it myself:

public class SyncService extends Service {
    private static final Object sSyncAdapterLock = new Object();

    private static SyncAdapter sSyncAdapter = null;

    /**
     * Instantiate the sync adapter object.
     */
    @Override
    public void onCreate() {
        synchronized (sSyncAdapterLock) {
            if (sSyncAdapter == null) {
                sSyncAdapter = new SyncAdapter(getApplicationContext(), true); // bingo!
            }
        }
    }

    /**
     * Return an object that allows the system to invoke the sync adapter.
     */
    @Override
    public IBinder onBind(Intent intent) {
        return sSyncAdapter.getSyncAdapterBinder();
    }
}

So I just need to inject the service and I'm done. Here's how to fix that:

public class SyncService extends Service {
    @Inject
    SyncAdapter sSyncAdapter;

    /**
     * Instantiate the sync adapter object.
     */
    @Override
    public void onCreate() {
        AndroidInjection.inject(this);
    }

    /**
     * Return an object that allows the system to invoke the sync adapter.
     */
    @Override
    public IBinder onBind(Intent intent) {
        return sSyncAdapter.getSyncAdapterBinder();
    }
}

Here's the sync adapter: the default constructor was hidden (made private) and the new constructor is crafted for Dagger: it expects directly SyncService as a context and injects the backend and other objects (in my case, a repository class).

public class SyncAdapter extends AbstractThreadedSyncAdapter {
    private static final String TAG = SyncAdapter.class.getSimpleName();

    private Backend mBackend;

    private PostRepository mRepository;

    @Inject
    SyncAdapter(SyncService service, Backend backend, PostRepository repo) {
        this(service, true);
        mBackend = backend;
        mRepository = repo;
    }

    private SyncAdapter(Context context, boolean autoInitialize) {
        super(context, autoInitialize);
    }

New subcomponent for Service injection:

@Subcomponent(modules = {})
public interface SyncServiceSubcomponent extends AndroidInjector<SyncService> {
    @Subcomponent.Builder
    abstract class Builder extends AndroidInjector.Builder<SyncService> {
    }
}

Here's the module that references that subcomponent. It provides the SyncService (and AuthenticatorService, which is implemented in the exact same behavior) expected by the SyncAdapter constructor (resp. Authenticator):

/**
 * Used to provide/bind services with a factory
 * Services can't be injected in the constructor so this is required
 */
@Module(subcomponents = {
        SyncServiceSubcomponent.class,
        AuthenticatorServiceSubcomponent.class,
})
public abstract class ServicesModule {
    @Binds
    @IntoMap
    @ServiceKey(SyncService.class)
    abstract AndroidInjector.Factory<? extends Service> bindSyncServiceInjectorFactory(SyncServiceSubcomponent.Builder builder);

    @Binds
    @IntoMap
    @ServiceKey(AuthenticatorService.class)
    abstract AndroidInjector.Factory<? extends Service> bindAuthenticatorServiceInjectorFactory(AuthenticatorServiceSubcomponent.Builder builder);
}

So the sync adapter has the following dependencies:

• sync service: provided by the ServicesModule
• backend, repository, etc: app logic
• service injection: subcomponent

Maybe this can help someone.