Enable auto manage for google api client

pull/281/head
Alex Baker 11 years ago
parent ce1a84cc98
commit 747236e21e

@ -1,12 +1,16 @@
package org.tasks.dialogs;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import org.tasks.location.LocationApi;
import org.tasks.location.OnLocationPickedHandler;
public class LocationPickerDialog {
public static void pickLocation(LocationApi locationApi, Fragment fragment, OnLocationPickedHandler onLocationPickedHandler) {
public LocationPickerDialog(OnLocationPickedHandler onLocationPickedHandler) {
}
public void show(FragmentManager childFragmentManager, String fragTagLocationPicker) {
}
}

@ -2,8 +2,6 @@ package org.tasks.dialogs;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.DialogFragment;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.view.KeyEvent;
import android.view.LayoutInflater;
@ -24,29 +22,33 @@ import com.google.android.gms.maps.model.LatLng;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.tasks.R;
import org.tasks.injection.InjectingDialogFragment;
import org.tasks.location.Geofence;
import org.tasks.location.LocationApi;
import org.tasks.location.ManagedGoogleApi;
import org.tasks.location.OnLocationPickedHandler;
import org.tasks.location.PlaceAutocompleteAdapter;
public class LocationPickerDialog extends DialogFragment {
import javax.inject.Inject;
public class LocationPickerDialog extends InjectingDialogFragment {
private static final Logger log = LoggerFactory.getLogger(LocationPickerDialog.class);
private static final String FRAG_TAG_LOCATION_PICKER = "frag_tag_location_picker";
private LocationApi locationApi;
private FragmentActivity fragmentActivity;
private OnLocationPickedHandler onLocationPickedHandler;
private PlaceAutocompleteAdapter mAdapter;
public static void pickLocation(LocationApi locationApi, Fragment fragment, OnLocationPickedHandler onLocationPickedHandler) {
LocationPickerDialog locationPickerDialog = new LocationPickerDialog();
locationPickerDialog.initialize(locationApi, fragment.getActivity(), onLocationPickedHandler);
locationPickerDialog.show(fragment.getChildFragmentManager(), FRAG_TAG_LOCATION_PICKER);
@Inject ManagedGoogleApi managedGoogleApi;
@Inject FragmentActivity fragmentActivity;
private OnLocationPickedHandler onLocationPickedHandler;
public LocationPickerDialog(OnLocationPickedHandler onLocationPickedHandler) {
this.onLocationPickedHandler = onLocationPickedHandler;
}
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
managedGoogleApi.requestGeoData();
managedGoogleApi.connect();
View layout = inflater.inflate(R.layout.location_picker_dialog, null);
EditText addressEntry = (EditText) layout.findViewById(R.id.address_entry);
@ -62,7 +64,7 @@ public class LocationPickerDialog extends DialogFragment {
}
});
mAdapter = new PlaceAutocompleteAdapter(locationApi, fragmentActivity, android.R.layout.simple_list_item_1);
mAdapter = new PlaceAutocompleteAdapter(managedGoogleApi, fragmentActivity, android.R.layout.simple_list_item_1);
ListView list = (ListView) layout.findViewById(R.id.list);
list.setAdapter(mAdapter);
list.setOnItemClickListener(mAutocompleteClickListener);
@ -70,12 +72,6 @@ public class LocationPickerDialog extends DialogFragment {
return layout;
}
public void initialize(LocationApi locationApi, FragmentActivity fragmentActivity, OnLocationPickedHandler onLocationPickedHandler) {
this.locationApi = locationApi;
this.fragmentActivity = fragmentActivity;
this.onLocationPickedHandler = onLocationPickedHandler;
}
private void error(String text) {
log.error(text);
Toast.makeText(fragmentActivity, text, Toast.LENGTH_LONG).show();
@ -88,7 +84,7 @@ public class LocationPickerDialog extends DialogFragment {
final PlaceAutocompleteAdapter.PlaceAutocomplete item = mAdapter.getItem(position);
final String placeId = String.valueOf(item.placeId);
log.info("Autocomplete item selected: " + item.description);
locationApi.getPlaceDetails(placeId, mUpdatePlaceDetailsCallback);
managedGoogleApi.getPlaceDetails(placeId, mUpdatePlaceDetailsCallback);
}
};

@ -4,7 +4,6 @@ import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.PendingResult;
import com.google.android.gms.common.api.ResultCallback;
@ -25,19 +24,17 @@ import javax.inject.Inject;
import static com.google.android.gms.location.Geofence.NEVER_EXPIRE;
import static com.google.common.collect.Iterables.transform;
import static com.google.common.collect.Lists.newArrayList;
import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
public class GeofenceApi {
private static final Logger log = LoggerFactory.getLogger(GeofenceApi.class);
private Context context;
private GoogleApiClientProvider googleApiClientProvider;
@Inject
public GeofenceApi(@ForApplication Context context, GoogleApiClientProvider googleApiClientProvider) {
public GeofenceApi(@ForApplication Context context) {
this.context = context;
this.googleApiClientProvider = googleApiClientProvider;
}
public void register(final List<Geofence> geofences) {
@ -45,11 +42,11 @@ public class GeofenceApi {
return;
}
googleApiClientProvider.getApi(new GoogleApiClientProvider.withApi() {
newClient(new GoogleApi.GoogleApiClientConnectionHandler() {
@Override
public void doWork(GoogleApiClient googleApiClient) {
public void onConnect(final GoogleApiClient client) {
PendingResult<Status> result = LocationServices.GeofencingApi.addGeofences(
googleApiClient,
client,
getRequests(geofences),
PendingIntent.getService(context, 0, new Intent(context, GeofenceTransitionsIntentService.class), PendingIntent.FLAG_UPDATE_CURRENT));
result.setResultCallback(new ResultCallback<Status>() {
@ -60,24 +57,21 @@ public class GeofenceApi {
} else {
log.error("Failed to register {}", geofences);
}
client.disconnect();
}
});
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
log.info("failed to register geofences");
}
});
}
public void cancel(final Geofence geofence) {
googleApiClientProvider.getApi(new GoogleApiClientProvider.withApi() {
newClient(new GoogleApi.GoogleApiClientConnectionHandler() {
@Override
public void doWork(GoogleApiClient googleApiClient) {
public void onConnect(final GoogleApiClient client) {
LocationServices.GeofencingApi.removeGeofences(
googleApiClient,
asList(Long.toString(geofence.getMetadataId())))
client,
singletonList(Long.toString(geofence.getMetadataId())))
.setResultCallback(new ResultCallback<Status>() {
@Override
public void onResult(Status status) {
@ -86,17 +80,20 @@ public class GeofenceApi {
} else {
log.error("Failed to remove {}", geofence);
}
client.disconnect();
}
});
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
log.info("failed to cancel geofence");
}
});
}
private void newClient(final GoogleApi.GoogleApiClientConnectionHandler handler) {
new GoogleApi(context)
.requestLocationServices()
.connect(handler);
}
private List<com.google.android.gms.location.Geofence> getRequests(List<Geofence> geofences) {
return newArrayList(transform(geofences, new Function<Geofence, com.google.android.gms.location.Geofence>() {
@Override

@ -35,15 +35,23 @@ public class GeofenceTransitionsIntentService extends InjectingIntentService {
int transitionType = geofencingEvent.getGeofenceTransition();
List<com.google.android.gms.location.Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();
log.info("Received geofence transition: {}, {}", transitionType, triggeringGeofences);
if (transitionType == com.google.android.gms.location.Geofence.GEOFENCE_TRANSITION_ENTER) {
List<com.google.android.gms.location.Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();
log.info("Received geofence transition: {}, {}", transitionType, triggeringGeofences);
for (com.google.android.gms.location.Geofence triggerGeofence : triggeringGeofences) {
Geofence geofence = geofenceService.getGeofenceById(Long.parseLong(triggerGeofence.getRequestId()));
broadcaster.requestNotification(geofence.getMetadataId(), geofence.getTaskId());
triggerNotification(triggerGeofence);
}
} else {
log.warn("invalid geofence transition type: {}", transitionType);
}
}
private void triggerNotification(com.google.android.gms.location.Geofence triggeringGeofence) {
try {
Geofence geofence = geofenceService.getGeofenceById(Long.parseLong(triggeringGeofence.getRequestId()));
broadcaster.requestNotification(geofence.getMetadataId(), geofence.getTaskId());
} catch(Exception e) {
log.error(e.getMessage(), e);
}
}
}

@ -0,0 +1,76 @@
package org.tasks.location;
import android.content.Context;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.location.places.Places;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.tasks.injection.ForApplication;
import javax.inject.Inject;
public class GoogleApi implements GoogleApiClient.OnConnectionFailedListener, GoogleApiClient.ConnectionCallbacks {
private static final Logger log = LoggerFactory.getLogger(GoogleApi.class);
private GoogleApiClient.Builder builder;
private GoogleApiClient googleApiClient;
private GoogleApiClientConnectionHandler googleApiClientConnectionHandler;
private boolean enableAutoManage;
public interface GoogleApiClientConnectionHandler {
void onConnect(GoogleApiClient client);
}
@Inject
public GoogleApi(@ForApplication Context context) {
builder = new GoogleApiClient.Builder(context, this, this)
.addConnectionCallbacks(this);
}
public GoogleApi requestLocationServices() {
builder.addApi(LocationServices.API);
return this;
}
public GoogleApi requestGeoData() {
builder.addApi(Places.GEO_DATA_API);
return this;
}
public void connect(final GoogleApiClientConnectionHandler googleApiClientConnectionHandler) {
this.googleApiClientConnectionHandler = googleApiClientConnectionHandler;
googleApiClient = builder.build();
if (!enableAutoManage) {
googleApiClient.connect();
}
}
protected GoogleApi enableAutoManage(FragmentActivity fragmentActivity, GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
enableAutoManage = true;
builder.enableAutoManage(fragmentActivity, 0, onConnectionFailedListener);
return this;
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
log.error("onConnectionFailed({})", connectionResult);
}
@Override
public void onConnected(Bundle bundle) {
log.info("onConnected(Bundle)");
googleApiClientConnectionHandler.onConnect(googleApiClient);
}
@Override
public void onConnectionSuspended(int i) {
log.info("onConnectionSuspended({})", i);
}
}

@ -1,51 +0,0 @@
package org.tasks.location;
import android.content.Context;
import android.os.Bundle;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.location.places.Places;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.tasks.injection.ForApplication;
import javax.inject.Inject;
public class GoogleApiClientProvider {
private static final Logger log = LoggerFactory.getLogger(GoogleApiClientProvider.class);
private Context context;
public interface withApi extends GoogleApiClient.OnConnectionFailedListener {
void doWork(GoogleApiClient googleApiClient);
}
@Inject
public GoogleApiClientProvider(@ForApplication Context context) {
this.context = context;
}
public void getApi(final withApi callback) {
final GoogleApiClient googleApiClient = new GoogleApiClient.Builder(context)
.addOnConnectionFailedListener(callback)
.addApi(Places.GEO_DATA_API)
.addApi(LocationServices.API)
.build();
googleApiClient.registerConnectionCallbacks(new GoogleApiClient.ConnectionCallbacks() {
@Override
public void onConnected(Bundle bundle) {
log.info("onConnected({})", bundle);
callback.doWork(googleApiClient);
}
@Override
public void onConnectionSuspended(int i) {
log.info("onConnectionSuspended({})", i);
}
});
googleApiClient.connect();
}
}

@ -1,84 +0,0 @@
package org.tasks.location;
import android.location.Location;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.location.places.AutocompletePredictionBuffer;
import com.google.android.gms.location.places.PlaceBuffer;
import com.google.android.gms.location.places.Places;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.LatLngBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
public class LocationApi {
private static final Logger log = LoggerFactory.getLogger(LocationApi.class);
private GoogleApiClientProvider googleApiClientProvider;
@Inject
public LocationApi(GoogleApiClientProvider googleApiClientProvider) {
this.googleApiClientProvider = googleApiClientProvider;
}
public void getPlaceDetails(final String placeId, final ResultCallback<PlaceBuffer> callback) {
googleApiClientProvider.getApi(new GoogleApiClientProvider.withApi() {
@Override
public void doWork(final GoogleApiClient googleApiClient) {
Places.GeoDataApi.getPlaceById(googleApiClient, placeId)
.setResultCallback(new ResultCallback<PlaceBuffer>() {
@Override
public void onResult(PlaceBuffer places) {
callback.onResult(places);
googleApiClient.disconnect();
}
}, 15, TimeUnit.SECONDS);
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
log.error("onConnectionFailed({})", connectionResult);
}
});
}
public void getAutocompletePredictions(final String constraint, final ResultCallback<AutocompletePredictionBuffer> callback) {
googleApiClientProvider.getApi(new GoogleApiClientProvider.withApi() {
@Override
public void doWork(final GoogleApiClient googleApiClient) {
final LatLngBounds bounds = LatLngBounds.builder().include(getLastKnownLocation(googleApiClient)).build();
Places.GeoDataApi.getAutocompletePredictions(googleApiClient, constraint, bounds, null)
.setResultCallback(new ResultCallback<AutocompletePredictionBuffer>() {
@Override
public void onResult(AutocompletePredictionBuffer autocompletePredictions) {
callback.onResult(autocompletePredictions);
googleApiClient.disconnect();
}
}, 15, TimeUnit.SECONDS);
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
log.error("onConnectionFailed({})", connectionResult);
}
});
}
private LatLng getLastKnownLocation(GoogleApiClient googleApiClient) {
try {
Location lastLocation = LocationServices.FusedLocationApi.getLastLocation(googleApiClient);
return new LatLng(lastLocation.getLatitude(), lastLocation.getLongitude());
} catch (Exception e) {
return new LatLng(0, 0);
}
}
}

@ -0,0 +1,97 @@
package org.tasks.location;
import android.content.IntentSender;
import android.location.Location;
import android.support.v4.app.FragmentActivity;
import android.widget.Toast;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.location.places.AutocompletePredictionBuffer;
import com.google.android.gms.location.places.PlaceBuffer;
import com.google.android.gms.location.places.Places;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.LatLngBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.tasks.R;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
public class ManagedGoogleApi extends GoogleApi implements GoogleApi.GoogleApiClientConnectionHandler {
private static final int RC_RESOLVE_GPS_ISSUE = 10009;
private static final Logger log = LoggerFactory.getLogger(ManagedGoogleApi.class);
private FragmentActivity fragmentActivity;
private GoogleApiClient googleApiClient;
@Inject
public ManagedGoogleApi(FragmentActivity fragmentActivity) {
super(fragmentActivity);
this.fragmentActivity = fragmentActivity;
enableAutoManage(fragmentActivity, this);
}
public void connect() {
if (googleApiClient == null) {
super.connect(this);
}
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
if (connectionResult.hasResolution()) {
try {
connectionResult.startResolutionForResult(fragmentActivity, RC_RESOLVE_GPS_ISSUE);
} catch (IntentSender.SendIntentException e) {
log.error(e.getMessage(), e);
}
} else {
Toast.makeText(fragmentActivity, String.format("%s: %s\n%s",
fragmentActivity.getString(R.string.app_name),
fragmentActivity.getString(R.string.common_google_play_services_notification_ticker),
connectionResult.getErrorCode()), Toast.LENGTH_LONG).show();
}
}
@Override
public void onConnect(GoogleApiClient googleApiClient) {
this.googleApiClient = googleApiClient;
}
public void getPlaceDetails(final String placeId, final ResultCallback<PlaceBuffer> callback) {
Places.GeoDataApi.getPlaceById(googleApiClient, placeId)
.setResultCallback(new ResultCallback<PlaceBuffer>() {
@Override
public void onResult(PlaceBuffer places) {
callback.onResult(places);
}
}, 15, TimeUnit.SECONDS);
}
public void getAutocompletePredictions(final String constraint, final ResultCallback<AutocompletePredictionBuffer> callback) {
final LatLngBounds bounds = LatLngBounds.builder().include(getLastKnownLocation(googleApiClient)).build();
Places.GeoDataApi.getAutocompletePredictions(googleApiClient, constraint, bounds, null)
.setResultCallback(new ResultCallback<AutocompletePredictionBuffer>() {
@Override
public void onResult(AutocompletePredictionBuffer autocompletePredictions) {
callback.onResult(autocompletePredictions);
}
}, 15, TimeUnit.SECONDS);
}
private LatLng getLastKnownLocation(GoogleApiClient googleApiClient) {
try {
Location lastLocation = LocationServices.FusedLocationApi.getLastLocation(googleApiClient);
return new LatLng(lastLocation.getLatitude(), lastLocation.getLongitude());
} catch (Exception e) {
return new LatLng(0, 0);
}
}
}

@ -20,13 +20,13 @@ public class PlaceAutocompleteAdapter
extends ArrayAdapter<PlaceAutocompleteAdapter.PlaceAutocomplete> {
private static final Logger log = LoggerFactory.getLogger(PlaceAutocompleteAdapter.class);
private final ManagedGoogleApi managedGoogleApi;
private List<PlaceAutocomplete> mResultList = new ArrayList<>();
private LocationApi locationApi;
public PlaceAutocompleteAdapter(LocationApi locationApi, Context context, int resource) {
public PlaceAutocompleteAdapter(ManagedGoogleApi managedGoogleApi, Context context, int resource) {
super(context, resource);
this.locationApi = locationApi;
this.managedGoogleApi = managedGoogleApi;
}
@Override
@ -40,7 +40,7 @@ public class PlaceAutocompleteAdapter
}
public void getAutocomplete(CharSequence constraint) {
locationApi.getAutocompletePredictions(constraint.toString(), onResults);
managedGoogleApi.getAutocompletePredictions(constraint.toString(), onResults);
}
private ResultCallback<AutocompletePredictionBuffer> onResults = new ResultCallback<AutocompletePredictionBuffer>() {

@ -80,7 +80,6 @@ import org.slf4j.LoggerFactory;
import org.tasks.R;
import org.tasks.injection.InjectingFragment;
import org.tasks.location.GeofenceService;
import org.tasks.location.LocationApi;
import org.tasks.notifications.NotificationManager;
import org.tasks.preferences.ActivityPreferences;
import org.tasks.preferences.ResourceResolver;
@ -174,7 +173,6 @@ ViewPager.OnPageChangeListener, EditNoteActivity.UpdatesChangedListener {
@Inject TagDataDao tagDataDao;
@Inject ActFmCameraModule actFmCameraModule;
@Inject GeofenceService geofenceService;
@Inject LocationApi locationApi;
@Inject ResourceResolver resourceResolver;
// --- UI components
@ -383,7 +381,7 @@ ViewPager.OnPageChangeListener, EditNoteActivity.UpdatesChangedListener {
controlSetMap.put(getString(R.string.TEA_ctrl_notes_pref),
notesControlSet);
ReminderControlSet reminderControlSet = new ReminderControlSet(locationApi, alarmService, geofenceService, this);
ReminderControlSet reminderControlSet = new ReminderControlSet(alarmService, geofenceService, this);
controls.add(reminderControlSet);
controlSetMap.put(getString(R.string.TEA_ctrl_reminders_pref), reminderControlSet);

@ -32,7 +32,6 @@ import org.tasks.dialogs.DateAndTimePickerDialog;
import org.tasks.dialogs.LocationPickerDialog;
import org.tasks.location.Geofence;
import org.tasks.location.GeofenceService;
import org.tasks.location.LocationApi;
import org.tasks.location.OnLocationPickedHandler;
import java.util.ArrayList;
@ -52,6 +51,7 @@ import static org.tasks.date.DateTimeUtils.newDateTime;
public class ReminderControlSet extends TaskEditControlSetBase implements AdapterView.OnItemSelectedListener {
private static final Logger log = LoggerFactory.getLogger(ReminderControlSet.class);
private static final String FRAG_TAG_LOCATION_PICKER = "frag_tag_location_picker";
private Spinner mode;
private Spinner addSpinner;
@ -61,7 +61,6 @@ public class ReminderControlSet extends TaskEditControlSetBase implements Adapte
private LinearLayout alertContainer;
private boolean whenDue;
private boolean whenOverdue;
private LocationApi locationApi;
private AlarmService alarmService;
private GeofenceService geofenceService;
private TaskEditFragment taskEditFragment;
@ -69,9 +68,8 @@ public class ReminderControlSet extends TaskEditControlSetBase implements Adapte
private ArrayAdapter<String> remindAdapter;
public ReminderControlSet(LocationApi locationApi, AlarmService alarmService, GeofenceService geofenceService, TaskEditFragment taskEditFragment) {
public ReminderControlSet(AlarmService alarmService, GeofenceService geofenceService, TaskEditFragment taskEditFragment) {
super(taskEditFragment.getActivity(), R.layout.control_set_reminders);
this.locationApi = locationApi;
this.alarmService = alarmService;
this.geofenceService = geofenceService;
this.taskEditFragment = taskEditFragment;
@ -381,12 +379,12 @@ public class ReminderControlSet extends TaskEditControlSetBase implements Adapte
} else if (selected.equals(taskEditFragment.getString(R.string.pick_a_date_and_time))) {
addNewAlarm();
} else if (selected.equals(taskEditFragment.getString(R.string.pick_a_location))) {
LocationPickerDialog.pickLocation(locationApi, taskEditFragment, new OnLocationPickedHandler() {
new LocationPickerDialog(new OnLocationPickedHandler() {
@Override
public void onLocationPicked(Geofence geofence) {
addGeolocationReminder(geofence);
}
});
}).show(taskEditFragment.getChildFragmentManager(), FRAG_TAG_LOCATION_PICKER);
}
if (position != 0) {
updateSpinner();

@ -0,0 +1,27 @@
package org.tasks.injection;
import android.support.v4.app.DialogFragment;
import android.support.v4.app.FragmentActivity;
import org.tasks.dialogs.LocationPickerDialog;
import dagger.Module;
import dagger.Provides;
@Module(addsTo = TasksModule.class,
injects = {
LocationPickerDialog.class
},
library = true)
public class DialogFragmentModule {
private DialogFragment dialogFragment;
public DialogFragmentModule(DialogFragment dialogFragment) {
this.dialogFragment = dialogFragment;
}
@Provides
public FragmentActivity getFragmentActivity() {
return dialogFragment.getActivity();
}
}

@ -3,7 +3,6 @@ package org.tasks.injection;
import android.app.Activity;
import android.content.Context;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import com.todoroo.astrid.actfm.TagViewFragment;
import com.todoroo.astrid.activity.TaskEditFragment;

@ -0,0 +1,18 @@
package org.tasks.injection;
import android.app.Activity;
import android.support.v4.app.DialogFragment;
public class InjectingDialogFragment extends DialogFragment {
private boolean injected;
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
if (!injected) {
((Injector) activity).getObjectGraph().plus(new DialogFragmentModule(this)).inject(this);
injected = true;
}
}
}
Loading…
Cancel
Save