import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
/**
 * Parse location to fetch matching events
 * @param key the geoindex key
 * @param location the corresponding location
 */
@Override
public void onKeyEntered(String key, GeoLocation location) {
    String[] parts = key.split("@");
    String userId = parts[0];
    String eventId = parts[1];
    if(users.contains(userId)) {
        FirebaseDatabase.getInstance().getReference("events/"+userId+"/"+eventId).addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                HabitEventDataModel model = dataSnapshot.getValue(HabitEventDataModel.class);

                if (model != null) {
                    HabitEvent habitEvent = model.getHabitEvent();
                    nearbyEvents.add(habitEvent);
                    datasetChanged();
                }
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {

            }
        });
    }
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
/**
 * Filter by habit events within 5km
 */
private void filterByNearby(final ArrayList<String> followingIds) {
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
            ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION},
                MY_PERMISSIONS_REQUEST_LOCATION);
        return;
    }

    mFusedLocationClient.getLastLocation()
            .addOnSuccessListener(this, new OnSuccessListener<Location>() {
                @Override
                public void onSuccess(Location location) {
                    // Got last known location. In some rare situations this can be null.

                    if (location != null) {
                        // Logic to handle location object
                        HabitHistoryActivity.this.location = location;
                        LatLng loc = new LatLng(location.getLatitude(), location.getLongitude());

                        eventDataSource = new NearbyHabitEventDataSource(new GeoLocation(loc.latitude, loc.longitude), followingIds);
                        eventDataSource.addObserver(HabitHistoryActivity.this);
                        eventDataSource.open();
                        habitEvents = eventDataSource.getSource();
                        habitHistoryAdapter = new HabitHistoryAdapter(HabitHistoryActivity.this, habitEvents);
                        habitsListView.setAdapter(habitHistoryAdapter);

                        // TODO: update the data source here with the list of friends
                    } else {
                        Toast.makeText(HabitHistoryActivity.this, "Error getting location",
                                Toast.LENGTH_LONG).show();
                    }
                }
            });
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
/**
 * Add a habit event to the database
 * It's location is geocoded into the events_geofire index
 * @param habitEvent the event to add
 */
@Override
public void add(HabitEvent habitEvent) {
    HabitEventDataModel eventModel = new HabitEventDataModel(habitEvent);

    DatabaseReference newEvent = mHabitEventsRef.push();
    eventModel.setKey(newEvent.getKey());

    // Reverse Chronological Order
    newEvent.setValue(eventModel, -1 * habitEvent.getEventDate().getMillis(), null);
    geoFire.setLocation(userId+'@'+newEvent.getKey(), new GeoLocation(habitEvent.getLatitude(), habitEvent.getLongitude()));
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
/**
 * Update data at existing index with data
 * @param key the event key
 * @param habitEvent the event object
 */
@Override
public void update(String key, HabitEvent habitEvent) {
    HabitEventDataModel eventModel = new HabitEventDataModel(habitEvent);
    mHabitEventsRef.child(key).getRef().setValue(eventModel, null);
    geoFire.setLocation(userId+'@'+habitEvent.getKey(), new GeoLocation(habitEvent.getLatitude(), habitEvent.getLongitude()));
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
public void animateFriendMarker(String uid, GeoLocation location){
    final double lat = location.latitude;
    final double lng = location.longitude;
    final Handler handler = new Handler();
    final long start = SystemClock.uptimeMillis();
    final long DURATION_MS = 3000;
    final Interpolator interpolator = new AccelerateDecelerateInterpolator();
    final Marker marker = markerUserIdHashMap.get(uid);
    final LatLng startPosition = marker.getPosition();
    handler.post(new Runnable() {
        @Override
        public void run() {
            float elapsed = SystemClock.uptimeMillis() - start;
            float t = elapsed/DURATION_MS;
            float v = interpolator.getInterpolation(t);

            double currentLat = (lat - startPosition.latitude) * v + startPosition.latitude;
            double currentLng = (lng - startPosition.longitude) * v + startPosition.longitude;
            marker.setPosition(new LatLng(currentLat, currentLng));

            // if animation is not finished yet, repeat
            if (t < 1) {
                handler.postDelayed(this, 16);
            }
        }
    });
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
public static void saveToFirebase(GeoFire geoFire,Firebase db, Tutor tutor, Location location){
    if(location != null) {
        Firebase tutorStore = db.child("tutors").child(tutor.getFullName());
        tutorStore.setValue(tutor);
        geoFire.setLocation(tutor.getFullName(), new GeoLocation(location.getLatitude(), location.getLongitude()));
    }
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
public IndegoStation(String kioskId, GeoLocation location,double distance, String name, Integer bikesAvailable, Integer docksAvialable){
    this.kioskId = kioskId;
    this.location = location;
    this.bikesAvailable = bikesAvailable;
    this.docksAvialable = docksAvialable;
    this.distance = distance;
    this.name = name;

}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
@Override
public void onCreate() {
    super.onCreate();
    Timber.tag(getClass().getSimpleName());
    Timber.d(getClass().getSimpleName() + " is creating");

    UserLocation currentLocation = CacheManager.pluck().getUserLocation();
    if (currentLocation == null) {
        currentLocation = new UserLocation();
        currentLocation.setLatitude(-7.76772);
        currentLocation.setLongitude(110.37863);
    }
    GeoLocation location = new GeoLocation(currentLocation.getLatitude(), currentLocation.getLongitude());

    GeoQuery query = FirebaseApi.pluck().userLocations().queryAtLocation(location, 20);

    CacheManager.pluck().listenUserLocation()
            .subscribe(userLocation -> {
                if (userLocation != null) {
                    GeoLocation newLocation = new GeoLocation(userLocation.getLatitude(),
                                                              userLocation.getLongitude());
                    query.setCenter(newLocation);
                }
            }, throwable -> {
                Timber.e(throwable.getMessage());
            });

    query.addGeoQueryEventListener(this);
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
@Override
public void onKeyEntered(String key, GeoLocation location) {
    UserLocation userLocation = new UserLocation();
    userLocation.setUserId(key);
    userLocation.setLatitude(location.latitude);
    userLocation.setLongitude(location.longitude);
    CacheManager.pluck().cacheNearbyUser(userLocation);
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
private void createCaseLocation(String caseId) {
    Location currentLocation = CacheManager.pluck().getUserLocation();
    FirebaseApi.pluck()
            .caseLocations()
            .setLocation(caseId,
                         new GeoLocation(currentLocation.getLatitude(),
                                         currentLocation.getLongitude()));
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
private void listenLocationUpdate() {
    locationProvider.getUpdatedLocation(request)
            .subscribe(location -> {
                if (StateManager.pluck().getState().equals(StateManager.State.LOGGED) ||
                        StateManager.pluck().getState().equals(StateManager.State.ADDING_TRUSTED_USER) ||
                        StateManager.pluck().getState().equals(StateManager.State.MENOLONG) ||
                        StateManager.pluck().getState().equals(StateManager.State.DITOLONG) ||
                        StateManager.pluck().getState().equals(StateManager.State.DIKAWAL) ||
                        StateManager.pluck().getState().equals(StateManager.State.MENGAWAL)) {
                    UserLocation userLocation = new UserLocation();
                    userLocation.setUserId(currentUser.getUserId());
                    userLocation.setLatitude(location.getLatitude());
                    userLocation.setLongitude(location.getLongitude());
                    CacheManager.pluck().cacheUserLocation(userLocation);
                    FirebaseApi.pluck()
                            .userLocations()
                            .setLocation(currentUser.getUserId(),
                                         new GeoLocation(userLocation.getLatitude(), userLocation.getLongitude()));
                    if (view != null) {
                        view.onLocationUpdated(userLocation);
                    }
                }
            }, throwable -> {
                Timber.e(throwable.getMessage());
                if (view != null) {
                    view.showError(throwable.getMessage());
                }
            });
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
@Override
public void onKeyMoved(String key, GeoLocation location) {
    // Move the marker
    Marker marker = this.markers.get(key);
    if (marker != null) {
        this.animateMarkerTo(marker, location.latitude, location.longitude);
    }
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
@Override
public void onCameraChange(CameraPosition cameraPosition) {
    // Update the search criteria for this geoQuery and the circle on the map
    LatLng center = cameraPosition.target;
    double radius = zoomLevelToRadius(cameraPosition.zoom);
    this.searchCircle.setCenter(center);
    this.searchCircle.setRadius(radius);
    this.geoQuery.setCenter(new GeoLocation(center.latitude, center.longitude));
    // radius in km
    this.geoQuery.setRadius(radius/1000);
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
public static int bitsForBoundingBox(GeoLocation location, double size) {
    double latitudeDegreesDelta = GeoUtils.distanceToLatitudeDegrees(size);
    double latitudeNorth = Math.min(90, location.latitude + latitudeDegreesDelta);
    double latitudeSouth = Math.max(-90, location.latitude - latitudeDegreesDelta);
    int bitsLatitude = (int)Math.floor(Utils.bitsLatitude(size)) *2;
    int bitsLongitudeNorth = (int)Math.floor(Utils.bitsLongitude(size, latitudeNorth)) *2 - 1;
    int bitsLongitudeSouth = (int)Math.floor(Utils.bitsLongitude(size, latitudeSouth)) *2 - 1;
    return Math.min(bitsLatitude, Math.min(bitsLongitudeNorth, bitsLongitudeSouth));
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
public GeoHash(double latitude, double longitude, int precision) {
    if (precision < 1) {
        throw new IllegalArgumentException("Precision of GeoHash must be larger than zero!");
    }
    if (precision > MAX_PRECISION) {
        throw new IllegalArgumentException("Precision of a GeoHash must be less than " + (MAX_PRECISION + 1) + "!");
    }
    if (!GeoLocation.coordinatesValid(latitude, longitude)) {
        throw new IllegalArgumentException(String.format(US, "Not valid location coordinates: [%f, %f]", latitude, longitude));
    }
    double[] longitudeRange = { -180, 180 };
    double[] latitudeRange = { -90, 90 };

    char[] buffer = new char[precision];

    for (int i = 0; i < precision; i++) {
        int hashValue = 0;
        for (int j = 0; j < Base32Utils.BITS_PER_BASE32_CHAR; j++) {
            boolean even = (((i*Base32Utils.BITS_PER_BASE32_CHAR) + j) % 2) == 0;
            double val = even ? longitude : latitude;
            double[] range = even ? longitudeRange : latitudeRange;
            double mid = (range[0] + range[1])/2;
            if (val > mid) {
                hashValue = (hashValue << 1) + 1;
                range[0] = mid;
            } else {
                hashValue = hashValue << 1;
                range[1] = mid;
            }
        }
        buffer[i] = Base32Utils.valueToBase32Char(hashValue);
    }
    this.geoHash = new String(buffer);
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
@Override
public void onLocationResult(String key, GeoLocation location) {
    if (future.isDone()) {
        throw new IllegalStateException("Already received callback");
    }

    if (location != null) {
        future.put(location(key, location.latitude, location.longitude));
    } else {
        future.put(noLocation(key));
    }
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
/**
 * Initialize datasource on a particular location
 * @param loc the reference location
 * @param users list of user ids (following) to query for events
 */
public NearbyHabitEventDataSource(GeoLocation loc, ArrayList<String> users) {
    this.loc = loc;
    this.users = users;
    nearbyEvents = new ArrayList<>();
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
@Override
public void onKeyMoved(String key, GeoLocation location) {
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
@Override
public void onKeyEntered(String key, GeoLocation location) {
    // Add a new marker to the map
    Marker marker = this.map.addMarker(new MarkerOptions().position(new LatLng(location.latitude, location.longitude)));
    this.markers.put(key, marker);
}
 

import com.firebase.geofire.GeoLocation; //导入依赖的package包/类
public static double distance(GeoLocation location1, GeoLocation location2) {
    return distance(location1.latitude, location1.longitude, location2.latitude, location2.longitude);
}