com.google.android.gms.location.Geofence Java Examples

private String getGeofenceTransitionDetails(
        Context context,
        int geofenceTransition,
        List<Geofence> triggeringGeofences) {

    String geofenceTransitionString = getTransitionString(geofenceTransition);

    // Get the Ids of each geofence that was triggered.
    ArrayList triggeringGeofencesIdsList = new ArrayList();
    for (Geofence geofence : triggeringGeofences) {
        triggeringGeofencesIdsList.add(geofence.getRequestId());
    }
    String triggeringGeofencesIdsString = TextUtils.join(", ", triggeringGeofencesIdsList);

    return geofenceTransitionString + ": " + triggeringGeofencesIdsString;
}
 

private Geofence geofenceFromMap(Map<String, Object> regionData, String regionName) {
  Number latitude = (Number) regionData.get("lat");
  Number longitude = (Number) regionData.get("lon");
  Number radius = (Number) regionData.get("radius");
  Number version = (Number) regionData.get("version");
  if (latitude == null) {
    return null;
  }
  Builder geofenceBuilder = new Builder();
  geofenceBuilder.setCircularRegion(latitude.floatValue(),
      longitude.floatValue(), radius.floatValue());
  geofenceBuilder.setRequestId(geofenceID(regionName, version.intValue()));
  geofenceBuilder.setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER |
      Geofence.GEOFENCE_TRANSITION_EXIT);
  geofenceBuilder.setExpirationDuration(Geofence.NEVER_EXPIRE);
  return geofenceBuilder.build();
}
 

/**
 * In this sample, the geofences are predetermined and are hard-coded here. A real app might
 * dynamically create geofences based on the user's location.
 */
public void createGeofences() {
    // Create internal "flattened" objects containing the geofence data.
    mAndroidBuildingGeofence = new SimpleGeofence(
            ANDROID_BUILDING_ID,                // geofenceId.
            ANDROID_BUILDING_LATITUDE,
            ANDROID_BUILDING_LONGITUDE,
            ANDROID_BUILDING_RADIUS_METERS,
            GEOFENCE_EXPIRATION_TIME,
            Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT
    );
    mYerbaBuenaGeofence = new SimpleGeofence(
            YERBA_BUENA_ID,                // geofenceId.
            YERBA_BUENA_LATITUDE,
            YERBA_BUENA_LONGITUDE,
            YERBA_BUENA_RADIUS_METERS,
            GEOFENCE_EXPIRATION_TIME,
            Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT
    );

    // Store these flat versions in SharedPreferences and add them to the geofence list.
    mGeofenceStorage.setGeofence(ANDROID_BUILDING_ID, mAndroidBuildingGeofence);
    mGeofenceStorage.setGeofence(YERBA_BUENA_ID, mYerbaBuenaGeofence);
    mGeofenceList.add(mAndroidBuildingGeofence.toGeofence());
    mGeofenceList.add(mYerbaBuenaGeofence.toGeofence());
}
 

/**
 * Gets transition details and returns them as a formatted string.
 *
 * @param geofenceTransition    The ID of the geofence transition.
 * @param triggeringGeofences   The geofence(s) triggered.
 * @return                      The transition details formatted as String.
 */
private String getGeofenceTransitionDetails(
        int geofenceTransition,
        List<Geofence> triggeringGeofences) {

    String geofenceTransitionString = getTransitionString(geofenceTransition);

    // Get the Ids of each geofence that was triggered.
    ArrayList<String> triggeringGeofencesIdsList = new ArrayList<>();
    for (Geofence geofence : triggeringGeofences) {
        triggeringGeofencesIdsList.add(geofence.getRequestId());
    }
    String triggeringGeofencesIdsString = TextUtils.join(", ",  triggeringGeofencesIdsList);

    return geofenceTransitionString + ": " + triggeringGeofencesIdsString;
}
 

@Override
public void onReceive(Context context, Intent intent) {
  GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);

  if (geofencingEvent.hasError()) {
    int errorCode = geofencingEvent.getErrorCode();
    String errorMessage = GeofenceStatusCodes.getStatusCodeString(errorCode);
    Log.e(TAG, errorMessage);
  } else {
    // Get the transition type.
    int geofenceTransition = geofencingEvent.getGeofenceTransition();

    // A single event can trigger multiple geofences.
    // Get the geofences that were triggered.
    List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();

    // TODO React to the Geofence(s) transition(s).
  }
}
 

protected static List<GeofenceData> from(GeofencingEvent event) {
    String problem = check(event);
    if (problem != null) {
        throw new IllegalArgumentException(problem);
    }
    ArrayList<GeofenceData> result = new ArrayList<>();
    for (Geofence geofence : event.getTriggeringGeofences()) {
        try {
            result.add(new GeofenceData(geofence.getRequestId()));
        } catch (IllegalArgumentException ex) {
            Logger.log.logError(ex.getMessage());
        }
    }
    if (result.isEmpty()) {
        throw new IllegalArgumentException("GeofencingEvent has no triggering geofences");
    }
    return result;
}
 

private static String check(GeofencingEvent event) {
    if (event == null) {
        return "GeofencingEvent is null";
    }
    if (event.hasError()) {
        return "GeofencingEvent has error: "+event.getErrorCode();
    }
    if (event.getTriggeringGeofences() == null) {
        return "GeofencingEvent has no triggering geofences";
    }
    if (event.getTriggeringGeofences().isEmpty()) {
        return "GeofencingEvent has empty list of triggering geofences";
    }
    int transition = event.getGeofenceTransition();
    //Only GEOFENCE_TRANSITION_ENTER and GEOFENCE_TRANSITION_EXIT are supported for now.
    if (transition != Geofence.GEOFENCE_TRANSITION_ENTER && transition != Geofence.GEOFENCE_TRANSITION_EXIT) {
        return "GeofencingEvent has invalid transition: "+transition;
    }
    return null;
}
 

private HashMap<String, Geofence> getGeofencesFromCursor(Cursor cursor, int limit) {
    HashMap<String, Geofence> result = new HashMap<>(limit);
    Geofence geofence;
    int i = 0;
    while (cursor.moveToNext()) {
        i++;
        if (i <= HIGH) {
            String fence = cursor.getString(cursor.getColumnIndex(DBHelper.TG_FENCE));
            geofence = buildGeofence(fence);
            if (geofence != null) {
                result.put(fence, geofence);
            }
        } else {
            Logger.log.geofenceError("Over " + HIGH + " found in cursor", null);
            break;
        }
    }
    return result;
}
 

private Geofence buildGeofence(String fence) {
    try {
        GeofenceData temp = new GeofenceData(fence);
        return new Geofence.Builder()
                .setRequestId(temp.getFence())
                .setCircularRegion(
                        temp.getLatitude(),
                        temp.getLongitude(),
                        temp.getRadius())
                .setExpirationDuration(Long.MAX_VALUE)
                .setNotificationResponsiveness(settings.getGeofenceNotificationResponsiveness())
                //TODO this could be optimized to trigger only on entry / exit according to layout. Not worth it now.
                .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT)
                .build();
    } catch (IllegalArgumentException ex) {
        Logger.log.geofenceError("Invalid geofence: "+fence, ex);
        return null;
    }
}
 

@Override
protected void onHandleIntent( Intent intent ) {
	NotificationCompat.Builder builder = new NotificationCompat.Builder( this );
	builder.setSmallIcon( R.drawable.ic_launcher );
	builder.setDefaults( Notification.DEFAULT_ALL );
	builder.setOngoing( true );

	int transitionType = LocationClient.getGeofenceTransition( intent );
	if( transitionType == Geofence.GEOFENCE_TRANSITION_ENTER ) {
		builder.setContentTitle( "Geofence Transition" );
		builder.setContentText( "Entering Geofence" );
		mNotificationManager.notify( 1, builder.build() );
	}
	else if( transitionType == Geofence.GEOFENCE_TRANSITION_EXIT ) {
		builder.setContentTitle( "Geofence Transition" );
		builder.setContentText( "Exiting Geofence" );
		mNotificationManager.notify( 1, builder.build() );
	}
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Rather than displayng this activity, simply display a toast indicating that the geofence
    // service is being created. This should happen in less than a second.
    Toast.makeText(this, getString(R.string.start_geofence_service), Toast.LENGTH_SHORT).show();

    // Instantiate a new geofence storage area.
    mGeofenceStorage = new SimpleGeofenceStore(this);
    // Instantiate the current List of geofences.
    mGeofenceList = new ArrayList<Geofence>();
    // Start with the request flag set to false.
    mInProgress = false;

    createGeofences();
    addGeofences();

    finish();
}
 

@Override
protected void onHandleIntent(Intent intent) {
  try {
    GeofencingEvent event = GeofencingEvent.fromIntent(intent);
    if (event.hasError()) {
      int errorCode = event.getErrorCode();
      Log.d("Location Client Error with code: " + errorCode);
    } else {
      int transitionType = event.getGeofenceTransition();
      List<Geofence> triggeredGeofences = event.getTriggeringGeofences();
      if (transitionType == Geofence.GEOFENCE_TRANSITION_ENTER ||
          transitionType == Geofence.GEOFENCE_TRANSITION_EXIT) {
        LocationManagerImplementation locationManager = (LocationManagerImplementation)
            ActionManager.getLocationManager();
        if (locationManager != null) {
          locationManager.updateStatusForGeofences(triggeredGeofences, transitionType);
        }
      }
    }
  } catch (Throwable t) {
    Util.handleException(t);
  }
}
 

/**
 * In this sample, the geofences are predetermined and are hard-coded here. A real app might
 * dynamically create geofences based on the user's location.
 */
public void createGeofences() {
    // Create internal "flattened" objects containing the geofence data.
    mAndroidBuildingGeofence = new SimpleGeofence(
            ANDROID_BUILDING_ID,                // geofenceId.
            ANDROID_BUILDING_LATITUDE,
            ANDROID_BUILDING_LONGITUDE,
            ANDROID_BUILDING_RADIUS_METERS,
            GEOFENCE_EXPIRATION_TIME,
            Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT
    );
    mYerbaBuenaGeofence = new SimpleGeofence(
            YERBA_BUENA_ID,                // geofenceId.
            YERBA_BUENA_LATITUDE,
            YERBA_BUENA_LONGITUDE,
            YERBA_BUENA_RADIUS_METERS,
            GEOFENCE_EXPIRATION_TIME,
            Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT
    );

    // Store these flat versions in SharedPreferences and add them to the geofence list.
    mGeofenceStorage.setGeofence(ANDROID_BUILDING_ID, mAndroidBuildingGeofence);
    mGeofenceStorage.setGeofence(YERBA_BUENA_ID, mYerbaBuenaGeofence);
    mGeofenceList.add(mAndroidBuildingGeofence.toGeofence());
    mGeofenceList.add(mYerbaBuenaGeofence.toGeofence());
}
 

public Geofence toGeofence(Date expiryDate) {
    long expirationDurationMillis = 0L;
    if (expiryDate != null) {
        expirationDurationMillis = expiryDate.getTime() - Time.now();
    }
    if (expirationDurationMillis <= 0) {
        expirationDurationMillis = Geofence.NEVER_EXPIRE;
    }

    return new Geofence.Builder()
            .setCircularRegion(getLatitude(), getLongitude(), getRadius())
            .setRequestId(getId())
            .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER)
            .setExpirationDuration(expirationDurationMillis)
            .build();
}
 

private void addFence(double latitude, double longitude, float radius,
        String requestId, String broadcastUri) {
    if (!servicesConnected()) {
        return;
    }

    Geofence.Builder builder = new Geofence.Builder();
    builder.setRequestId(requestId);
    builder.setCircularRegion(latitude, longitude, radius);
    builder.setExpirationDuration(Geofence.NEVER_EXPIRE); // 無期限
    builder.setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER);

    // フェンスのListを作成する。
    List<Geofence> fenceList = new ArrayList<Geofence>();
    fenceList.add(builder.build());

    // フェンス内に入った時に、指定のURIを表示するインテントを投げるようにする。
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(broadcastUri));
    PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent,
            PendingIntent.FLAG_UPDATE_CURRENT);

    mLocationClient.addGeofences(fenceList, pendingIntent, this);
}
 

private boolean geofenceStateChanged(@eu.power_switch.google_play_services.geofence.Geofence.State String state, eu.power_switch.google_play_services.geofence.Geofence.EventType eventType) {
    switch (eventType) {
        case ENTER:
            if (!eu.power_switch.google_play_services.geofence.Geofence.STATE_INSIDE.equals(state)) {
                return true;
            } else {
                return false;
            }
        case EXIT:
            if (!eu.power_switch.google_play_services.geofence.Geofence.STATE_OUTSIDE.equals(state)) {
                return true;
            } else {
                return false;
            }
        default:
            return false;
    }
}
 

/**
 * Called when a geofence is triggered
 */
private void geofenceTriggered(Intent intent) {
    Log.v(TAG, ACTION_GEOFENCE_TRIGGERED);

    // Check if geofences are enabled
    boolean geofenceEnabled = Utils.getGeofenceEnabled(this);

    // Extract the geofences from the intent
    GeofencingEvent event = GeofencingEvent.fromIntent(intent);
    List<Geofence> geofences = event.getTriggeringGeofences();

    if (geofenceEnabled && geofences != null && geofences.size() > 0) {
        if (event.getGeofenceTransition() == Geofence.GEOFENCE_TRANSITION_ENTER) {
            // Trigger the notification based on the first geofence
            showNotification(geofences.get(0).getRequestId(), Constants.USE_MICRO_APP);
        } else if (event.getGeofenceTransition() == Geofence.GEOFENCE_TRANSITION_EXIT) {
            // Clear notifications
            clearNotificationInternal();
            clearRemoteNotifications();
        }
    }
    UtilityReceiver.completeWakefulIntent(intent);
}
 

/**
 * Called when a geofence is triggered
 */
private void geofenceTriggered(Intent intent) {
    Log.v(TAG, ACTION_GEOFENCE_TRIGGERED);

    // Check if geofences are enabled
    boolean geofenceEnabled = Utils.getGeofenceEnabled(this);

    // Extract the geofences from the intent
    GeofencingEvent event = GeofencingEvent.fromIntent(intent);
    List<Geofence> geofences = event.getTriggeringGeofences();

    if (geofenceEnabled && geofences != null && geofences.size() > 0) {
        if (event.getGeofenceTransition() == Geofence.GEOFENCE_TRANSITION_ENTER) {
            // Trigger the notification based on the first geofence
            showNotification(geofences.get(0).getRequestId(), Constants.USE_MICRO_APP);
        } else if (event.getGeofenceTransition() == Geofence.GEOFENCE_TRANSITION_EXIT) {
            // Clear notifications
            clearNotificationInternal();
            clearRemoteNotifications();
        }
    }
    UtilityReceiver.completeWakefulIntent(intent);
}
 

/**
 * Called when a geofence is triggered
 */
private void geofenceTriggered(Intent intent) {
    Log.v(TAG, ACTION_GEOFENCE_TRIGGERED);

    // Check if geofences are enabled
    boolean geofenceEnabled = Utils.getGeofenceEnabled(this);

    // Extract the geofences from the intent
    GeofencingEvent event = GeofencingEvent.fromIntent(intent);
    List<Geofence> geofences = event.getTriggeringGeofences();

    if (geofenceEnabled && geofences != null && geofences.size() > 0) {
        if (event.getGeofenceTransition() == Geofence.GEOFENCE_TRANSITION_ENTER) {
            // Trigger the notification based on the first geofence
            showNotification(geofences.get(0).getRequestId(), Constants.USE_MICRO_APP);
        } else if (event.getGeofenceTransition() == Geofence.GEOFENCE_TRANSITION_EXIT) {
            // Clear notifications
            clearNotificationInternal();
            clearRemoteNotifications();
        }
    }
    UtilityReceiver.completeWakefulIntent(intent);
}
 

@Test
public void shouldCalculateRefreshDateForGeoExpiredIfGeoIsMonitoredNow() throws Exception {
    // Given
    long millis15MinBeforeNow = now - 15 * 60 * 1000;
    long millis15MinAfterNow = now + 15 * 60 * 1000;
    String date15MinBeforeNow = DateTimeUtil.ISO8601DateToString(new Date(millis15MinBeforeNow));
    String date15MinAfterNow = DateTimeUtil.ISO8601DateToString(new Date(millis15MinAfterNow));

    saveGeoMessageToDb(date15MinBeforeNow, date15MinAfterNow);

    // When
    Pair<List<Geofence>, Pair<Date, Date>> geofencesAndNextRefreshDate = geofencingImpl.calculateGeofencesToMonitorDates(geoStore);

    // Then
    assertNotNull(geofencesAndNextRefreshDate);
    assertFalse(geofencesAndNextRefreshDate.first.isEmpty());
    assertNull(geofencesAndNextRefreshDate.second.first);
    assertEquals(millis15MinAfterNow, geofencesAndNextRefreshDate.second.second.getTime(), 3000);
}
 

@Test
public void shouldNotCalculateRefreshDateForGeoStartIfGeoIsMonitoredNow() throws Exception {
    // Given
    Long millis15MinBeforeNow = now - 15 * 60 * 1000;
    Long millis15MinAfterNow = now + 15 * 60 * 1000;
    String date15MinBeforeNow = DateTimeUtil.ISO8601DateToString(new Date(millis15MinBeforeNow));
    String date15MinAfterNow = DateTimeUtil.ISO8601DateToString(new Date(millis15MinAfterNow));

    saveGeoMessageToDb(date15MinBeforeNow, date15MinAfterNow);

    // When
    Pair<List<Geofence>, Pair<Date, Date>> geofencesAndNextRefreshDate = geofencingImpl.calculateGeofencesToMonitorDates(geoStore);

    // Then
    assertNotNull(geofencesAndNextRefreshDate);
    assertFalse(geofencesAndNextRefreshDate.first.isEmpty());
    assertNull(geofencesAndNextRefreshDate.second.first);
}
 

@Test
public void shouldCalculateRefreshDateForGeoExpiredIfGeoExpired() throws Exception {
    // Given
    Long millis30MinBeforeNow = now - 30 * 60 * 1000;
    Long millis15MinBeforeNow = now - 15 * 60 * 1000;
    String date30MinBeforeNow = DateTimeUtil.ISO8601DateToString(new Date(millis30MinBeforeNow));
    String date15MinBeforeNow = DateTimeUtil.ISO8601DateToString(new Date(millis15MinBeforeNow));

    saveGeoMessageToDb(date30MinBeforeNow, date15MinBeforeNow);

    // When
    Pair<List<Geofence>, Pair<Date, Date>> geofencesAndNextRefreshDate = geofencingImpl.calculateGeofencesToMonitorDates(geoStore);

    // Then
    assertNotNull(geofencesAndNextRefreshDate);
    assertTrue(geofencesAndNextRefreshDate.first.isEmpty());
    assertNull(geofencesAndNextRefreshDate.second.first);
    assertEquals(now, geofencesAndNextRefreshDate.second.second.getTime(), 3000);
}
 

@Test
public void shouldNotCalculateRefreshDateForGeoStartIfGeoExpired() throws Exception {
    // Given
    long millis30MinBeforeNow = now - 30 * 60 * 1000;
    long millis15MinBeforeNow = now - 15 * 60 * 1000;
    String date30MinBeforeNow = DateTimeUtil.ISO8601DateToString(new Date(millis30MinBeforeNow));
    String date15MinBeforeNow = DateTimeUtil.ISO8601DateToString(new Date(millis15MinBeforeNow));

    saveGeoMessageToDb(date30MinBeforeNow, date15MinBeforeNow);

    // When
    Pair<List<Geofence>, Pair<Date, Date>> geofencesAndNextRefreshDate = geofencingImpl.calculateGeofencesToMonitorDates(geoStore);

    // Then
    assertNotNull(geofencesAndNextRefreshDate);
    assertTrue(geofencesAndNextRefreshDate.first.isEmpty());
    assertNull(geofencesAndNextRefreshDate.second.first);
}
 

@Test
public void shouldCalculateRefreshDatesForGeoStartAndExpired() throws Exception {
    // Given
    long millis15MinAfterNow = now + 15 * 60 * 1000;
    long millis30MinAfterNow = now + 30 * 60 * 1000;
    String date15MinAfterNow = DateTimeUtil.ISO8601DateToString(new Date(millis15MinAfterNow));
    String date30MinAfterNow = DateTimeUtil.ISO8601DateToString(new Date(millis30MinAfterNow));

    saveGeoMessageToDb(date15MinAfterNow, date30MinAfterNow);

    // When
    Pair<List<Geofence>, Pair<Date, Date>> geofencesAndNextRefreshDate = geofencingImpl.calculateGeofencesToMonitorDates(geoStore);

    // Then
    assertNotNull(geofencesAndNextRefreshDate);
    assertTrue(geofencesAndNextRefreshDate.first.isEmpty());
    assertNotNull(geofencesAndNextRefreshDate.second);

    Date refreshStartDate = geofencesAndNextRefreshDate.second.first;
    Date refreshExpiryDate = geofencesAndNextRefreshDate.second.second;
    assertEquals(millis15MinAfterNow, refreshStartDate.getTime(), 3000);
    assertEquals(millis30MinAfterNow, refreshExpiryDate.getTime(), 3000);
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Rather than displayng this activity, simply display a toast indicating that the geofence
    // service is being created. This should happen in less than a second.
    if (!isGooglePlayServicesAvailable()) {
        Log.e(TAG, "Google Play services unavailable.");
        finish();
        return;
    }

    mApiClient = new GoogleApiClient.Builder(this)
            .addApi(LocationServices.API)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .build();

    mApiClient.connect();

    // Instantiate a new geofence storage area.
    mGeofenceStorage = new SimpleGeofenceStore(this);
    // Instantiate the current List of geofences.
    mGeofenceList = new ArrayList<Geofence>();
    createGeofences();
}
 

private String getTransitionString(int transitionType) {
    switch (transitionType) {
        case Geofence.GEOFENCE_TRANSITION_ENTER:
            return "Entered";
        case Geofence.GEOFENCE_TRANSITION_EXIT:
            return "Exited";
        default:
            return "Unknown Transition";
    }
}
 

@Override
protected void onHandleIntent(Intent intent) {
    GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
    if (geofencingEvent.hasError()) {
        String errorMessage = GeofenceErrorMessages.getErrorString(this,
                geofencingEvent.getErrorCode());
        Log.e(TAG, errorMessage);
        return;
    }

    // Get the transition type.
    int geofenceTransition = geofencingEvent.getGeofenceTransition();

    // Test that the reported transition was of interest.
    if (geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
            geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) {

        // Get the geofences that were triggered. A single event can trigger multiple geofences.
        List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();

        // Get the transition details as a String.
        String geofenceTransitionDetails = getGeofenceTransitionDetails(
                this,
                geofenceTransition,
                triggeringGeofences
        );

        // Send notification and log the transition details.
        sendNotification(geofenceTransitionDetails);
        Log.i(TAG, geofenceTransitionDetails);
    } else {
        // Log the error.
    }
}
 

/**
 * Handles incoming intents.
 *
 * @param intent sent by Location Services. This Intent is provided to Location
 *               Services (inside a PendingIntent) when addGeofences() is called.
 */
@Override
protected void onHandleIntent(Intent intent) {
    GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
    if (geofencingEvent.hasError()) {
        Log.e(this, "GeofencingError");
        return;
    }

    // Get the transition type.
    int geofenceTransition = geofencingEvent.getGeofenceTransition();

    // Test that the reported transition was of interest.
    if (geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
            geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) {

        // Get the geofences that were triggered. A single event can trigger
        // multiple geofences.
        List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();

        // Get the Ids of each geofence that was triggered.
        ArrayList<String> triggeringGeofencesIdsList = new ArrayList<>();
        for (Geofence geofence : triggeringGeofences) {
            triggeringGeofencesIdsList.add(geofence.getRequestId());
        }
        Log.d(this, getTransitionString(geofenceTransition) + ": " + TextUtils.join(", ", triggeringGeofencesIdsList));

        executeGeofences(triggeringGeofences, geofenceTransition);
    } else {
        // Log the error.
        Log.e(this, "Unknown Geofence transition: " + geofenceTransition);
    }
}
 

private void startGeofence() {
	Location location = mLocationClient.getLastLocation();

	Geofence.Builder builder = new Geofence.Builder();
	mGeofence = builder.setRequestId( FENCE_ID )
			.setCircularRegion( location.getLatitude(), location.getLongitude(), RADIUS )
			.setTransitionTypes( Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT )
			.setExpirationDuration( Geofence.NEVER_EXPIRE )
			.build();

	ArrayList<Geofence> geofences = new ArrayList<Geofence>();
	geofences.add( mGeofence );
	mLocationClient.addGeofences( geofences, mPendingIntent, this );
}
 

private void onGeofencesAdded(Location location, List<Geofence> geofences, int initialTrigger) {
    registered = true;
    updating = false;
    previous = location;
    storePrevious(previous);
    Logger.log.geofence("Successfully added " + geofences.size() +
            " geofences, initial trigger: " + initialTrigger);
    requestLocationUpdates();
}