Via GPS kontrollieren ob man in einem bestimmten Koordinatenbereich ist

if ((latitude < latitudeMax && latitude > latitudeMin) &&
                        (longitude < longitudeMax && longitude > longitudeMin))

public class GeofenceBootReceiver extends BroadcastReceiver {

	public static final String TAG = GeofenceBootReceiver.class.getSimpleName();

	@Override
	public void onReceive(Context context, Intent intent) {
		Log.v(TAG, "onReceive()");
		GeofenceHelper helper = new GeofenceHelper(context);
		helper.initGeofencesFromDB();
	}

}

public class GeofenceHelper implements ConnectionCallbacks,
		OnConnectionFailedListener, OnAddGeofencesResultListener,
		OnRemoveGeofencesResultListener {

	private static final String TAG = GeofenceHelper.class.getSimpleName();

	private static final String ENTER_SUFFIX = "_enter";

	private static final String EXIT_SUFFIX = "_exit";

	private final Context context;
	private final LocationClient locationClient;
	private final List<Geofence> geofencesToAdd;
	private final List<String> geofencesToRemove;
	private Action action;

	private enum Action {
		ADD, REMOVE
	}

	public GeofenceHelper(Context context) {
		this.context = context;
		locationClient = new LocationClient(context, this, this);
		geofencesToAdd = new LinkedList<Geofence>();
		geofencesToRemove = new LinkedList<String>();
	}

	public void initGeofencesFromDB() {
		Log.v(TAG, "initGeofencesFromDb()");
		action = Action.ADD;
		Cursor cursor = context.getContentResolver().query(
				LocationContentProvider.CONTENT_URI, null, null, null, null);
		Geofence.Builder builder = new Geofence.Builder();
		String id;
		double latitude, longitude;
		float radius;
		while (cursor.moveToNext()) {
			// FIXME Util benutzen
			id = cursor.getString(cursor
					.getColumnIndex(LocationTable.ID))
					+ ENTER_SUFFIX;
			latitude = cursor.getDouble(cursor
					.getColumnIndex(LocationTable.LATITUDE));
			longitude = cursor.getDouble(cursor
					.getColumnIndex(LocationTable.LONGITUDE));
			radius = cursor.getFloat(cursor
					.getColumnIndex(LocationTable.RADIUS));
			builder.setRequestId(id)
					.setCircularRegion(latitude, longitude, radius)
					.setExpirationDuration(Geofence.NEVER_EXPIRE)
					.setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER);
			geofencesToAdd.add(builder.build());
			id = cursor.getString(cursor
					.getColumnIndex(LocationTable.ID))
					+ EXIT_SUFFIX;
			builder.setRequestId(id).setTransitionTypes(
					Geofence.GEOFENCE_TRANSITION_EXIT);
			geofencesToAdd.add(builder.build());
		}
		locationClient.connect();
	}

	public void addGeofences(SimpleGeofence geofence) {
		Geofence newGeofence = GeofenceUtil.convertToGeofenec(geofence);
		geofencesToAdd.add(newGeofence);
		locationClient.connect();
	}

	@Override
	public void onConnectionFailed(ConnectionResult result) {
		// TODO Auto-generated method stub
	}

	@Override
	public void onConnected(Bundle connectionHint) {
		switch (action) {
		case ADD:
			locationClient.addGeofences(geofencesToAdd, getPendingIntent(),
					this);
			geofencesToAdd.clear();
			break;
		case REMOVE:
			locationClient.removeGeofences(geofencesToRemove, this);
			geofencesToRemove.clear();
			break;
		}
	}

	private PendingIntent getPendingIntent() {
		Intent intent = new Intent(context,
				ReceiveTransitionsIntentService.class);
		return PendingIntent.getService(context, 0, intent,
				PendingIntent.FLAG_UPDATE_CURRENT);
	}

	@Override
	public void onDisconnected() {
		Log.v(TAG, "onDiscconected()");
	}

	@Override
	public void onAddGeofencesResult(int statuscode, String[] geofenceRequestIds) {
		locationClient.disconnect();
	}

	public void removeGeofencesFromDb() {
		action = Action.REMOVE;
		Cursor cursor = context.getContentResolver().query(
				LocationContentProvider.CONTENT_URI, null, null, null, null);
		while (cursor.moveToNext()) {
			String enterId = cursor.getString(cursor
					.getColumnIndex(LocationTable.ID))
					+ ENTER_SUFFIX;
			String exitId = cursor.getString(cursor
					.getColumnIndex(LocationTable.ID))
					+ EXIT_SUFFIX;
			geofencesToRemove.add(enterId);
			geofencesToRemove.add(exitId);
		}

		if (!geofencesToRemove.isEmpty()) {
			locationClient.connect();
		}
	}

	@Override
	public void onRemoveGeofencesByPendingIntentResult(int statusCode,
			PendingIntent pendingIntent) {
		locationClient.disconnect();
	}

	@Override
	public void onRemoveGeofencesByRequestIdsResult(int statusCode,
			String[] geofenceRequestIds) {
		locationClient.disconnect();
	}
}

public class ReceiveTransitionsIntentService extends IntentService {

	private static final String TAG = ReceiveTransitionsIntentService.class
			.getSimpleName();

	public ReceiveTransitionsIntentService() {
		super(ReceiveTransitionsIntentService.class.getSimpleName());
		Log.v(TAG, "ReceiverTransitionsIntetSerivce()");
	}

	@Override
	protected void onHandleIntent(Intent intent) {
		Log.v(TAG, "onHandleIntent()");
		if (LocationClient.hasError(intent)) {
			int errorCode = LocationClient.getErrorCode(intent);
			Log.e(TAG, "errorCode: " + errorCode);
			return;
		}

		int transitionType = LocationClient.getGeofenceTransition(intent);
		switch (transitionType) {
		case Geofence.GEOFENCE_TRANSITION_ENTER:
			showNotification(intent);
			break;
		case Geofence.GEOFENCE_TRANSITION_EXIT:
			hideNotification(intent);
		}
	}

	private void showNotification(final Intent intent) {
		Log.v(TAG, "showNotification()");
		NotificationManager nManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
		NotificationCompat.Builder nBuilder = new NotificationCompat.Builder(
				this);
		for (Geofence geofence : LocationClient.getTriggeringGeofences(intent)) {
			long id = Long.parseLong(geofence.getRequestId().split("_")[0]);
			Uri uri = ContentUris.withAppendedId(
					LocationContentProvider.CONTENT_URI, id);
			Cursor cursor = getContentResolver().query(uri, null, null, null,
					null);
			cursor.moveToFirst();
			SimpleGeofence location = SimpleGeofenceBuilder.fromCursor(cursor);
			cursor.close();

			Intent newIntent = new Intent(this, MainActivity.class);
			newIntent.putExtra(MainActivity.ARG_ID, id);
			PendingIntent pIntent = PendingIntent.getActivity(this, (int) id,
					newIntent, PendingIntent.FLAG_CANCEL_CURRENT
							| PendingIntent.FLAG_UPDATE_CURRENT);

			nBuilder.setContentTitle(location.getTitle())
					.setContentText(location.getDescription())
					.setTicker(location.getTitle()).setContentIntent(pIntent)
					.setSmallIcon(R.drawable.ic_launcher).setAutoCancel(true);
			nManager.notify((int) id, nBuilder.build());
		}
	}

	private void hideNotification(Intent intent) {
		Log.v(TAG, "hideNotification()");
		NotificationManager nManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
		for (Geofence geofence : LocationClient.getTriggeringGeofences(intent)) {
			long id = Long.parseLong(geofence.getRequestId().split("_")[0]);
			nManager.cancel((int) id);
		}
	}
}

 <!-- Boot receiver -->
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

<!-- Boot receiver -->
        <receiver android:name=".geofence.GeofenceBootReceiver" >
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
        <!-- Geofence Service -->
        <service
            android:name=".geofence.ReceiveTransitionsIntentService"
            android:exported="false"
            android:label="@string/app_name" />