mirror of https://github.com/NekoX-Dev/NekoX.git
621 lines
20 KiB
Java
621 lines
20 KiB
Java
package org.telegram.messenger;
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.content.Context;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Point;
|
|
import android.location.Location;
|
|
import android.os.Bundle;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
|
|
import androidx.core.util.Consumer;
|
|
|
|
import com.google.android.gms.maps.CameraUpdate;
|
|
import com.google.android.gms.maps.CameraUpdateFactory;
|
|
import com.google.android.gms.maps.GoogleMap;
|
|
import com.google.android.gms.maps.MapView;
|
|
import com.google.android.gms.maps.MapsInitializer;
|
|
import com.google.android.gms.maps.Projection;
|
|
import com.google.android.gms.maps.UiSettings;
|
|
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
|
|
import com.google.android.gms.maps.model.Circle;
|
|
import com.google.android.gms.maps.model.CircleOptions;
|
|
import com.google.android.gms.maps.model.Dash;
|
|
import com.google.android.gms.maps.model.Gap;
|
|
import com.google.android.gms.maps.model.LatLngBounds;
|
|
import com.google.android.gms.maps.model.MapStyleOptions;
|
|
import com.google.android.gms.maps.model.Marker;
|
|
import com.google.android.gms.maps.model.MarkerOptions;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
public class GoogleMapsProvider implements IMapsProvider {
|
|
|
|
@Override
|
|
public void initializeMaps(Context context) {
|
|
MapsInitializer.initialize(context);
|
|
}
|
|
|
|
@Override
|
|
public IMapView onCreateMapView(Context context) {
|
|
return new GoogleMapView(context);
|
|
}
|
|
|
|
@Override
|
|
public ICameraUpdate newCameraUpdateLatLng(LatLng latLng) {
|
|
return new GoogleCameraUpdate(CameraUpdateFactory.newLatLng(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude)));
|
|
}
|
|
|
|
@Override
|
|
public ICameraUpdate newCameraUpdateLatLngZoom(LatLng latLng, float zoom) {
|
|
return new GoogleCameraUpdate(CameraUpdateFactory.newLatLngZoom(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude), zoom));
|
|
}
|
|
|
|
@Override
|
|
public ICameraUpdate newCameraUpdateLatLngBounds(ILatLngBounds bounds, int padding) {
|
|
return new GoogleCameraUpdate(CameraUpdateFactory.newLatLngBounds(((GoogleLatLngBounds) bounds).bounds, padding));
|
|
}
|
|
|
|
@Override
|
|
public ILatLngBoundsBuilder onCreateLatLngBoundsBuilder() {
|
|
return new GoogleLatLngBoundsBuilder();
|
|
}
|
|
|
|
@Override
|
|
public IMapStyleOptions loadRawResourceStyle(Context context, int resId) {
|
|
return new GoogleMapStyleOptions(MapStyleOptions.loadRawResourceStyle(context, resId));
|
|
}
|
|
|
|
@Override
|
|
public String getMapsAppPackageName() {
|
|
return "com.google.android.apps.maps";
|
|
}
|
|
|
|
@Override
|
|
public int getInstallMapsString() {
|
|
return R.string.InstallGoogleMaps;
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions onCreateMarkerOptions() {
|
|
return new GoogleMarkerOptions();
|
|
}
|
|
|
|
@Override
|
|
public ICircleOptions onCreateCircleOptions() {
|
|
return new GoogleCircleOptions();
|
|
}
|
|
|
|
public final static class GoogleMapImpl implements IMap {
|
|
private GoogleMap googleMap;
|
|
|
|
private Map<Marker, GoogleMarker> implToAbsMarkerMap = new HashMap<>();
|
|
private Map<Circle, GoogleCircle> implToAbsCircleMap = new HashMap<>();
|
|
|
|
private GoogleMapImpl(GoogleMap googleMap) {
|
|
this.googleMap = googleMap;
|
|
}
|
|
|
|
@Override
|
|
public void setMapType(int mapType) {
|
|
switch (mapType) {
|
|
case MAP_TYPE_NORMAL:
|
|
googleMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
|
|
break;
|
|
case MAP_TYPE_SATELLITE:
|
|
googleMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
|
|
break;
|
|
case MAP_TYPE_HYBRID:
|
|
googleMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public float getMaxZoomLevel() {
|
|
return googleMap.getMaxZoomLevel();
|
|
}
|
|
|
|
@SuppressLint("MissingPermission")
|
|
@Override
|
|
public void setMyLocationEnabled(boolean enabled) {
|
|
googleMap.setMyLocationEnabled(enabled);
|
|
}
|
|
|
|
@Override
|
|
public IUISettings getUiSettings() {
|
|
return new GoogleUISettings(googleMap.getUiSettings());
|
|
}
|
|
|
|
@Override
|
|
public void setOnCameraMoveStartedListener(OnCameraMoveStartedListener onCameraMoveStartedListener) {
|
|
googleMap.setOnCameraMoveStartedListener(reason -> {
|
|
int outReason;
|
|
switch (reason) {
|
|
default:
|
|
case GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE:
|
|
outReason = OnCameraMoveStartedListener.REASON_GESTURE;
|
|
break;
|
|
case GoogleMap.OnCameraMoveStartedListener.REASON_API_ANIMATION:
|
|
outReason = OnCameraMoveStartedListener.REASON_API_ANIMATION;
|
|
break;
|
|
case GoogleMap.OnCameraMoveStartedListener.REASON_DEVELOPER_ANIMATION:
|
|
outReason = OnCameraMoveStartedListener.REASON_DEVELOPER_ANIMATION;
|
|
break;
|
|
}
|
|
onCameraMoveStartedListener.onCameraMoveStarted(outReason);
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public CameraPosition getCameraPosition() {
|
|
com.google.android.gms.maps.model.CameraPosition pos = googleMap.getCameraPosition();
|
|
return new CameraPosition(new LatLng(pos.target.latitude, pos.target.longitude), pos.zoom);
|
|
}
|
|
|
|
@Override
|
|
public void setOnMapLoadedCallback(Runnable callback) {
|
|
googleMap.setOnMapLoadedCallback(callback::run);
|
|
}
|
|
|
|
@Override
|
|
public IProjection getProjection() {
|
|
return new GoogleProjection(googleMap.getProjection());
|
|
}
|
|
|
|
@Override
|
|
public void setPadding(int left, int top, int right, int bottom) {
|
|
googleMap.setPadding(left, top, right, bottom);
|
|
}
|
|
|
|
@Override
|
|
public void setMapStyle(IMapStyleOptions style) {
|
|
googleMap.setMapStyle(style == null ? null : ((GoogleMapStyleOptions) style).mapStyleOptions);
|
|
}
|
|
|
|
@Override
|
|
public IMarker addMarker(IMarkerOptions markerOptions) {
|
|
Marker impl = googleMap.addMarker(((GoogleMarkerOptions) markerOptions).markerOptions);
|
|
GoogleMarker abs = new GoogleMarker(impl);
|
|
implToAbsMarkerMap.put(impl, abs);
|
|
return abs;
|
|
}
|
|
|
|
@Override
|
|
public ICircle addCircle(ICircleOptions circleOptions) {
|
|
Circle impl = googleMap.addCircle(((GoogleCircleOptions) circleOptions).circleOptions);
|
|
GoogleCircle abs = new GoogleCircle(impl);
|
|
implToAbsCircleMap.put(impl, abs);
|
|
return abs;
|
|
}
|
|
|
|
@Override
|
|
public void setOnMyLocationChangeListener(Consumer<Location> callback) {
|
|
googleMap.setOnMyLocationChangeListener(callback::accept);
|
|
}
|
|
|
|
@Override
|
|
public void setOnMarkerClickListener(OnMarkerClickListener markerClickListener) {
|
|
googleMap.setOnMarkerClickListener(marker -> {
|
|
GoogleMarker abs = implToAbsMarkerMap.get(marker);
|
|
if (abs == null) {
|
|
abs = new GoogleMarker(marker);
|
|
implToAbsMarkerMap.put(marker, abs);
|
|
}
|
|
return markerClickListener.onClick(abs);
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void setOnCameraMoveListener(Runnable callback) {
|
|
googleMap.setOnCameraMoveListener(callback::run);
|
|
}
|
|
|
|
@Override
|
|
public void animateCamera(ICameraUpdate update) {
|
|
googleMap.animateCamera(((GoogleCameraUpdate) update).cameraUpdate);
|
|
}
|
|
|
|
@Override
|
|
public void animateCamera(ICameraUpdate update, ICancelableCallback callback) {
|
|
googleMap.animateCamera(((GoogleCameraUpdate) update).cameraUpdate, callback == null ? null : new GoogleMap.CancelableCallback() {
|
|
@Override
|
|
public void onFinish() {
|
|
callback.onFinish();
|
|
}
|
|
|
|
@Override
|
|
public void onCancel() {
|
|
callback.onCancel();
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void animateCamera(ICameraUpdate update, int duration, ICancelableCallback callback) {
|
|
googleMap.animateCamera(((GoogleCameraUpdate) update).cameraUpdate, duration, callback == null ? null : new GoogleMap.CancelableCallback() {
|
|
@Override
|
|
public void onFinish() {
|
|
callback.onFinish();
|
|
}
|
|
|
|
@Override
|
|
public void onCancel() {
|
|
callback.onCancel();
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void moveCamera(ICameraUpdate update) {
|
|
googleMap.moveCamera(((GoogleCameraUpdate) update).cameraUpdate);
|
|
}
|
|
|
|
public final class GoogleMarker implements IMarker {
|
|
private Marker marker;
|
|
|
|
private GoogleMarker(Marker marker) {
|
|
this.marker = marker;
|
|
}
|
|
|
|
@Override
|
|
public Object getTag() {
|
|
return marker.getTag();
|
|
}
|
|
|
|
@Override
|
|
public void setTag(Object tag) {
|
|
marker.setTag(tag);
|
|
}
|
|
|
|
@Override
|
|
public LatLng getPosition() {
|
|
com.google.android.gms.maps.model.LatLng latLng = marker.getPosition();
|
|
return new LatLng(latLng.latitude, latLng.longitude);
|
|
}
|
|
|
|
@Override
|
|
public void setPosition(LatLng latLng) {
|
|
marker.setPosition(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude));
|
|
}
|
|
|
|
@Override
|
|
public void setRotation(int rotation) {
|
|
marker.setRotation(rotation);
|
|
}
|
|
|
|
@Override
|
|
public void setIcon(Bitmap bitmap) {
|
|
marker.setIcon(BitmapDescriptorFactory.fromBitmap(bitmap));
|
|
}
|
|
|
|
@Override
|
|
public void setIcon(int resId) {
|
|
marker.setIcon(BitmapDescriptorFactory.fromResource(resId));
|
|
}
|
|
|
|
@Override
|
|
public void remove() {
|
|
marker.remove();
|
|
implToAbsMarkerMap.remove(marker);
|
|
}
|
|
}
|
|
|
|
public final class GoogleCircle implements ICircle {
|
|
private Circle circle;
|
|
|
|
private GoogleCircle(Circle circle) {
|
|
this.circle = circle;
|
|
}
|
|
|
|
@Override
|
|
public void setStrokeColor(int color) {
|
|
circle.setStrokeColor(color);
|
|
}
|
|
|
|
@Override
|
|
public void setFillColor(int color) {
|
|
circle.setFillColor(color);
|
|
}
|
|
|
|
@Override
|
|
public void setRadius(double radius) {
|
|
circle.setRadius(radius);
|
|
}
|
|
|
|
@Override
|
|
public double getRadius() {
|
|
return circle.getRadius();
|
|
}
|
|
|
|
@Override
|
|
public void setCenter(LatLng latLng) {
|
|
circle.setCenter(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude));
|
|
}
|
|
|
|
@Override
|
|
public void remove() {
|
|
circle.remove();
|
|
implToAbsCircleMap.remove(circle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final static class GoogleProjection implements IProjection {
|
|
private Projection projection;
|
|
|
|
private GoogleProjection(Projection projection) {
|
|
this.projection = projection;
|
|
}
|
|
|
|
@Override
|
|
public Point toScreenLocation(LatLng latLng) {
|
|
return projection.toScreenLocation(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude));
|
|
}
|
|
}
|
|
|
|
public final static class GoogleUISettings implements IUISettings {
|
|
private UiSettings uiSettings;
|
|
|
|
private GoogleUISettings(UiSettings settings) {
|
|
uiSettings = settings;
|
|
}
|
|
|
|
@Override
|
|
public void setMyLocationButtonEnabled(boolean enabled) {
|
|
uiSettings.setMyLocationButtonEnabled(enabled);
|
|
}
|
|
|
|
@Override
|
|
public void setZoomControlsEnabled(boolean enabled) {
|
|
uiSettings.setZoomControlsEnabled(enabled);
|
|
}
|
|
|
|
@Override
|
|
public void setCompassEnabled(boolean enabled) {
|
|
uiSettings.setCompassEnabled(enabled);
|
|
}
|
|
}
|
|
|
|
public final static class GoogleCircleOptions implements ICircleOptions {
|
|
private CircleOptions circleOptions;
|
|
|
|
private GoogleCircleOptions() {
|
|
circleOptions = new CircleOptions();
|
|
}
|
|
|
|
@Override
|
|
public ICircleOptions center(LatLng latLng) {
|
|
circleOptions.center(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude));
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public ICircleOptions radius(double radius) {
|
|
circleOptions.radius(radius);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public ICircleOptions strokeColor(int color) {
|
|
circleOptions.strokeColor(color);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public ICircleOptions fillColor(int color) {
|
|
circleOptions.fillColor(color);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public ICircleOptions strokePattern(List<PatternItem> patternItems) {
|
|
List<com.google.android.gms.maps.model.PatternItem> pattern = new ArrayList<>();
|
|
for (PatternItem item : patternItems) {
|
|
if (item instanceof PatternItem.Gap) {
|
|
pattern.add(new Gap(((PatternItem.Gap) item).length));
|
|
} else if (item instanceof PatternItem.Dash) {
|
|
pattern.add(new Dash(((PatternItem.Dash) item).length));
|
|
}
|
|
}
|
|
circleOptions.strokePattern(pattern);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public ICircleOptions strokeWidth(int width) {
|
|
circleOptions.strokeWidth(width);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public final static class GoogleMarkerOptions implements IMarkerOptions {
|
|
private MarkerOptions markerOptions;
|
|
|
|
private GoogleMarkerOptions() {
|
|
this.markerOptions = new MarkerOptions();
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions position(LatLng latLng) {
|
|
markerOptions.position(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude));
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions icon(Bitmap bitmap) {
|
|
markerOptions.icon(BitmapDescriptorFactory.fromBitmap(bitmap));
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions icon(int resId) {
|
|
markerOptions.icon(BitmapDescriptorFactory.fromResource(resId));
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions anchor(float lat, float lng) {
|
|
markerOptions.anchor(lat, lng);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions title(String title) {
|
|
markerOptions.title(title);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions snippet(String snippet) {
|
|
markerOptions.snippet(snippet);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public IMarkerOptions flat(boolean flat) {
|
|
markerOptions.flat(flat);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public final static class GoogleLatLngBoundsBuilder implements ILatLngBoundsBuilder {
|
|
private LatLngBounds.Builder builder;
|
|
|
|
private GoogleLatLngBoundsBuilder() {
|
|
builder = new LatLngBounds.Builder();
|
|
}
|
|
|
|
@Override
|
|
public ILatLngBoundsBuilder include(LatLng latLng) {
|
|
builder.include(new com.google.android.gms.maps.model.LatLng(latLng.latitude, latLng.longitude));
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public ILatLngBounds build() {
|
|
return new GoogleLatLngBounds(builder.build());
|
|
}
|
|
}
|
|
|
|
public final static class GoogleLatLngBounds implements ILatLngBounds {
|
|
private LatLngBounds bounds;
|
|
|
|
private GoogleLatLngBounds(LatLngBounds bounds) {
|
|
this.bounds = bounds;
|
|
}
|
|
|
|
@Override
|
|
public LatLng getCenter() {
|
|
com.google.android.gms.maps.model.LatLng latLng = bounds.getCenter();
|
|
return new LatLng(latLng.latitude, latLng.longitude);
|
|
}
|
|
}
|
|
|
|
public final static class GoogleMapView implements IMapView {
|
|
private MapView mapView;
|
|
|
|
private ITouchInterceptor dispatchInterceptor;
|
|
private ITouchInterceptor interceptInterceptor;
|
|
private Runnable onLayoutListener;
|
|
|
|
private GoogleMapView(Context context) {
|
|
mapView = new MapView(context) {
|
|
@Override
|
|
public boolean dispatchTouchEvent(MotionEvent ev) {
|
|
if (dispatchInterceptor != null) {
|
|
return dispatchInterceptor.onInterceptTouchEvent(ev, super::dispatchTouchEvent);
|
|
}
|
|
return super.dispatchTouchEvent(ev);
|
|
}
|
|
|
|
@Override
|
|
public boolean onInterceptTouchEvent(MotionEvent ev) {
|
|
if (interceptInterceptor != null) {
|
|
return interceptInterceptor.onInterceptTouchEvent(ev, super::onInterceptTouchEvent);
|
|
}
|
|
return super.onInterceptTouchEvent(ev);
|
|
}
|
|
|
|
@Override
|
|
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
|
|
super.onLayout(changed, left, top, right, bottom);
|
|
if (onLayoutListener != null) {
|
|
onLayoutListener.run();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public void setOnDispatchTouchEventInterceptor(ITouchInterceptor touchInterceptor) {
|
|
dispatchInterceptor = touchInterceptor;
|
|
}
|
|
|
|
@Override
|
|
public void setOnInterceptTouchEventInterceptor(ITouchInterceptor touchInterceptor) {
|
|
interceptInterceptor = touchInterceptor;
|
|
}
|
|
|
|
@Override
|
|
public void setOnLayoutListener(Runnable callback) {
|
|
onLayoutListener = callback;
|
|
}
|
|
|
|
@Override
|
|
public View getView() {
|
|
return mapView;
|
|
}
|
|
|
|
@Override
|
|
public void getMapAsync(Consumer<IMap> callback) {
|
|
mapView.getMapAsync(googleMap -> callback.accept(new GoogleMapImpl(googleMap)));
|
|
}
|
|
|
|
@Override
|
|
public void onPause() {
|
|
mapView.onPause();
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
mapView.onResume();
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstance) {
|
|
mapView.onCreate(savedInstance);
|
|
}
|
|
|
|
@Override
|
|
public void onDestroy() {
|
|
mapView.onDestroy();
|
|
}
|
|
|
|
@Override
|
|
public void onLowMemory() {
|
|
mapView.onLowMemory();
|
|
}
|
|
}
|
|
|
|
public final static class GoogleCameraUpdate implements ICameraUpdate {
|
|
private CameraUpdate cameraUpdate;
|
|
|
|
private GoogleCameraUpdate(CameraUpdate update) {
|
|
this.cameraUpdate = update;
|
|
}
|
|
}
|
|
|
|
public final static class GoogleMapStyleOptions implements IMapStyleOptions {
|
|
private MapStyleOptions mapStyleOptions;
|
|
|
|
private GoogleMapStyleOptions(MapStyleOptions mapStyleOptions) {
|
|
this.mapStyleOptions = mapStyleOptions;
|
|
}
|
|
}
|
|
}
|