diff options
author | Tobrun <tobrun.van.nuland@gmail.com> | 2018-10-08 15:16:27 +0200 |
---|---|---|
committer | Tobrun <tobrun@mapbox.com> | 2018-10-11 14:12:35 +0200 |
commit | 9e7694cb38982cf0434be64b8894c1628236d0d9 (patch) | |
tree | ae7ac8fe4da4b5a59b8468c66bba599006dd01ec /platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox | |
parent | 52bc08456e81ce531448f2c28dec5084fcc69155 (diff) | |
download | qtlocation-mapboxgl-9e7694cb38982cf0434be64b8894c1628236d0d9.tar.gz |
[android] - replace OnMapChange with specific callbacks
Diffstat (limited to 'platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox')
3 files changed, 755 insertions, 6 deletions
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapChangeReceiver.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapChangeReceiver.java new file mode 100644 index 0000000000..f8ea597554 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapChangeReceiver.java @@ -0,0 +1,239 @@ +package com.mapbox.mapboxsdk.maps; + +import java.util.ArrayList; +import java.util.List; + +class MapChangeReceiver implements NativeMapView.StateCallback { + + private final List<MapView.OnCameraWillChangeListener> onCameraWillChangeListenerList = new ArrayList<>(); + private final List<MapView.OnCameraIsChangingListener> onCameraIsChangingListenerList = new ArrayList<>(); + private final List<MapView.OnCameraDidChangeListener> onCameraDidChangeListenerList = new ArrayList<>(); + private final List<MapView.OnWillStartLoadingMapListener> onWillStartLoadingMapListenerList = new ArrayList<>(); + private final List<MapView.OnDidFinishLoadingMapListener> onDidFinishLoadingMapListenerList = new ArrayList<>(); + private final List<MapView.OnDidFailLoadingMapListener> onDidFailLoadingMapListenerList = new ArrayList<>(); + private final List<MapView.OnWillStartRenderingFrameListener> onWillStartRenderingFrameList = new ArrayList<>(); + private final List<MapView.OnDidFinishRenderingFrameListener> onDidFinishRenderingFrameList = new ArrayList<>(); + private final List<MapView.OnWillStartRenderingMapListener> onWillStartRenderingMapListenerList = new ArrayList<>(); + private final List<MapView.OnDidFinishRenderingMapListener> onDidFinishRenderingMapListenerList = new ArrayList<>(); + private final List<MapView.OnDidFinishLoadingStyleListener> onDidFinishLoadingStyleListenerList = new ArrayList<>(); + private final List<MapView.OnSourceChangedListener> onSourceChangedListenerList = new ArrayList<>(); + + @Override + public void onCameraWillChange(boolean animated) { + if (!onCameraWillChangeListenerList.isEmpty()) { + for (MapView.OnCameraWillChangeListener onCameraWillChangeListener : onCameraWillChangeListenerList) { + onCameraWillChangeListener.onCameraWillChange(animated); + } + } + } + + @Override + public void onCameraIsChanging() { + if (!onCameraIsChangingListenerList.isEmpty()) { + for (MapView.OnCameraIsChangingListener onCameraIsChangingListener : onCameraIsChangingListenerList) { + onCameraIsChangingListener.onCameraIsChanging(); + } + } + } + + @Override + public void onCameraDidChange(boolean animated) { + if (!onCameraDidChangeListenerList.isEmpty()) { + for (MapView.OnCameraDidChangeListener onCameraDidChangeListener : onCameraDidChangeListenerList) { + onCameraDidChangeListener.onCameraDidChange(animated); + } + } + } + + @Override + public void onWillStartLoadingMap() { + if (!onWillStartLoadingMapListenerList.isEmpty()) { + for (MapView.OnWillStartLoadingMapListener onWillStartLoadingMapListener : onWillStartLoadingMapListenerList) { + onWillStartLoadingMapListener.onWillStartLoadingMap(); + } + } + } + + @Override + public void onDidFinishLoadingMap() { + if (!onDidFinishLoadingMapListenerList.isEmpty()) { + for (MapView.OnDidFinishLoadingMapListener onDidFinishLoadingMapListener : onDidFinishLoadingMapListenerList) { + onDidFinishLoadingMapListener.onDidFinishLoadingMap(); + } + } + } + + @Override + public void onDidFailLoadingMap(String error) { + if (!onDidFailLoadingMapListenerList.isEmpty()) { + for (MapView.OnDidFailLoadingMapListener onDidFailLoadingMapListener : onDidFailLoadingMapListenerList) { + onDidFailLoadingMapListener.onDidFailLoadingMap(error); + } + } + } + + @Override + public void onWillStartRenderingFrame() { + if (!onWillStartRenderingFrameList.isEmpty()) { + for (MapView.OnWillStartRenderingFrameListener listener : onWillStartRenderingFrameList) { + listener.onWillStartRenderingFrame(); + } + } + } + + @Override + public void onDidFinishRenderingFrame(boolean fully) { + if (!onDidFinishRenderingFrameList.isEmpty()) { + for (MapView.OnDidFinishRenderingFrameListener listener : onDidFinishRenderingFrameList) { + listener.onDidFinishRenderingFrame(fully); + } + } + } + + @Override + public void onWillStartRenderingMap() { + if (!onWillStartRenderingMapListenerList.isEmpty()) { + for (MapView.OnWillStartRenderingMapListener listener : onWillStartRenderingMapListenerList) { + listener.onWillStartRenderingMap(); + } + } + } + + @Override + public void onDidFinishRenderingMap(boolean fully) { + if (!onDidFinishRenderingMapListenerList.isEmpty()) { + for (MapView.OnDidFinishRenderingMapListener listener : onDidFinishRenderingMapListenerList) { + listener.onDidFinishRenderingMap(fully); + } + } + } + + @Override + public void onDidFinishLoadingStyle() { + if (!onDidFinishLoadingStyleListenerList.isEmpty()) { + for (MapView.OnDidFinishLoadingStyleListener listener : onDidFinishLoadingStyleListenerList) { + listener.onDidFinishLoadingStyle(); + } + } + } + + @Override + public void onSourceChanged(String sourceId) { + if (!onSourceChangedListenerList.isEmpty()) { + for (MapView.OnSourceChangedListener onSourceChangedListener : onSourceChangedListenerList) { + onSourceChangedListener.onSourceChangedListener(sourceId); + } + } + } + + void addOnCameraWillChangeListener(MapView.OnCameraWillChangeListener listener) { + onCameraWillChangeListenerList.add(listener); + } + + void removeOnCameraWillChangeListener(MapView.OnCameraWillChangeListener listener) { + onCameraWillChangeListenerList.remove(listener); + } + + void addOnCameraIsChangingListener(MapView.OnCameraIsChangingListener listener) { + onCameraIsChangingListenerList.add(listener); + } + + void removeOnCameraIsChangingListener(MapView.OnCameraIsChangingListener listener) { + onCameraIsChangingListenerList.remove(listener); + } + + void addOnCameraDidChangeListener(MapView.OnCameraDidChangeListener listener) { + onCameraDidChangeListenerList.add(listener); + } + + void removeOnCameraDidChangeListener(MapView.OnCameraDidChangeListener listener) { + onCameraDidChangeListenerList.remove(listener); + } + + void addOnWillStartLoadingMapListener(MapView.OnWillStartLoadingMapListener listener) { + onWillStartLoadingMapListenerList.add(listener); + } + + void removeOnWillStartLoadingMapListener(MapView.OnWillStartLoadingMapListener listener) { + onWillStartLoadingMapListenerList.remove(listener); + } + + void addOnDidFinishLoadingMapListener(MapView.OnDidFinishLoadingMapListener listener) { + onDidFinishLoadingMapListenerList.add(listener); + } + + void removeOnDidFinishLoadingMapListener(MapView.OnDidFinishLoadingMapListener listener) { + onDidFinishLoadingMapListenerList.remove(listener); + } + + void addOnDidFailLoadingMapListener(MapView.OnDidFailLoadingMapListener listener) { + onDidFailLoadingMapListenerList.add(listener); + } + + void removeOnDidFailLoadingMapListener(MapView.OnDidFailLoadingMapListener listener) { + onDidFailLoadingMapListenerList.remove(listener); + } + + void addOnWillStartRenderingFrameListener(MapView.OnWillStartRenderingFrameListener listener) { + onWillStartRenderingFrameList.add(listener); + } + + void removeOnWillStartRenderingFrameListener(MapView.OnWillStartRenderingFrameListener listener) { + onWillStartRenderingFrameList.remove(listener); + } + + void addOnDidFinishRenderingFrameListener(MapView.OnDidFinishRenderingFrameListener listener) { + onDidFinishRenderingFrameList.add(listener); + } + + void removeOnDidFinishRenderingFrameListener(MapView.OnDidFinishRenderingFrameListener listener) { + onDidFinishRenderingFrameList.remove(listener); + } + + void addOnWillStartRenderingMapListener(MapView.OnWillStartRenderingMapListener listener) { + onWillStartRenderingMapListenerList.add(listener); + } + + void removeOnWillStartRenderingMapListener(MapView.OnWillStartRenderingMapListener listener) { + onWillStartRenderingMapListenerList.remove(listener); + } + + void addOnDidFinishRenderingMapListener(MapView.OnDidFinishRenderingMapListener listener) { + onDidFinishRenderingMapListenerList.add(listener); + } + + void removeOnDidFinishRenderingMapListener(MapView.OnDidFinishRenderingMapListener listener) { + onDidFinishRenderingMapListenerList.remove(listener); + } + + void addOnDidFinishLoadingStyleListener(MapView.OnDidFinishLoadingStyleListener listener) { + onDidFinishLoadingStyleListenerList.add(listener); + } + + void removeOnDidFinishLoadingStyleListener(MapView.OnDidFinishLoadingStyleListener listener) { + onDidFinishLoadingStyleListenerList.remove(listener); + } + + void addOnSourceChangedListener(MapView.OnSourceChangedListener listener) { + onSourceChangedListenerList.add(listener); + } + + void removeOnSourceChangedListener(MapView.OnSourceChangedListener listener) { + onSourceChangedListenerList.remove(listener); + } + + void clear() { + onCameraWillChangeListenerList.clear(); + onCameraIsChangingListenerList.clear(); + onCameraDidChangeListenerList.clear(); + onWillStartLoadingMapListenerList.clear(); + onDidFinishLoadingMapListenerList.clear(); + onDidFailLoadingMapListenerList.clear(); + onWillStartRenderingFrameList.clear(); + onDidFinishRenderingFrameList.clear(); + onWillStartRenderingMapListenerList.clear(); + onDidFinishRenderingMapListenerList.clear(); + onDidFinishLoadingStyleListenerList.clear(); + onSourceChangedListenerList.clear(); + } +}
\ No newline at end of file diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java index 44aa507365..1c92b3fe0b 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java @@ -78,6 +78,7 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { private final MapCallback mapCallback = new MapCallback(); private final CopyOnWriteArrayList<OnMapChangedListener> onMapChangedListeners = new CopyOnWriteArrayList<>(); + private final MapChangeReceiver mapChangeReceiver = new MapChangeReceiver(); private NativeMapView nativeMapView; private MapboxMap mapboxMap; @@ -321,7 +322,11 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { } boolean crossSourceCollisions = mapboxMapOptions.getCrossSourceCollisions(); - nativeMapView = new NativeMapView(getContext(), getPixelRatio(), crossSourceCollisions, this, mapRenderer); + nativeMapView = new NativeMapView( + getContext(), getPixelRatio(), crossSourceCollisions, this, mapChangeReceiver, mapRenderer + ); + + // deprecated API nativeMapView.addOnMapChangedListener(change -> { // dispatch events to external listeners if (!onMapChangedListeners.isEmpty()) { @@ -422,6 +427,7 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { @UiThread public void onDestroy() { destroyed = true; + mapChangeReceiver.clear(); onMapChangedListeners.clear(); mapCallback.clearOnMapReadyCallbacks(); @@ -682,6 +688,381 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { // /** + * Set a callback that's invoked when the camera region will change. + * + * @param listener The callback that's invoked when the camera region will change + */ + public void addOnCameraWillChangeListener(OnCameraWillChangeListener listener) { + mapChangeReceiver.addOnCameraWillChangeListener(listener); + } + + /** + * Remove a callback that's invoked when the camera region will change. + * + * @param listener The callback that's invoked when the camera region will change + */ + public void removeOnCameraWillChangeListener(OnCameraWillChangeListener listener) { + mapChangeReceiver.removeOnCameraWillChangeListener(listener); + } + + /** + * Set a callback that's invoked when the camera is changing. + * + * @param listener The callback that's invoked when the camera is changing + */ + public void addOnCameraIsChangingListener(OnCameraIsChangingListener listener) { + mapChangeReceiver.addOnCameraIsChangingListener(listener); + } + + /** + * Remove a callback that's invoked when the camera is changing. + * + * @param listener The callback that's invoked when the camera is changing + */ + public void removeOnCameraIsChangingListener(OnCameraIsChangingListener listener) { + mapChangeReceiver.removeOnCameraIsChangingListener(listener); + } + + /** + * Set a callback that's invoked when the camera region did change. + * + * @param listener The callback that's invoked when the camera region did change + */ + public void addOnCameraDidChangeListener(OnCameraDidChangeListener listener) { + mapChangeReceiver.addOnCameraDidChangeListener(listener); + } + + /** + * Set a callback that's invoked when the camera region did change. + * + * @param listener The callback that's invoked when the camera region did change + */ + public void removeOnCameraDidChangeListener(OnCameraDidChangeListener listener) { + mapChangeReceiver.removeOnCameraDidChangeListener(listener); + } + + /** + * Set a callback that's invoked when the map will start loading. + * + * @param listener The callback that's invoked when the map will start loading + */ + public void addOnWillStartLoadingMapListener(OnWillStartLoadingMapListener listener) { + mapChangeReceiver.addOnWillStartLoadingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map will start loading. + * + * @param listener The callback that's invoked when the map will start loading + */ + public void removeOnWillStartLoadingMapListener(OnWillStartLoadingMapListener listener) { + mapChangeReceiver.removeOnWillStartLoadingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map has finished loading. + * + * @param listener The callback that's invoked when the map has finished loading + */ + public void addOnDidFinishLoadingMapListener(OnDidFinishLoadingMapListener listener) { + mapChangeReceiver.addOnDidFinishLoadingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map has finished loading. + * + * @param listener The callback that's invoked when the map has finished loading + */ + public void removeOnDidFinishLoadingMapListener(OnDidFinishLoadingMapListener listener) { + mapChangeReceiver.removeOnDidFinishLoadingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map failed to load. + * + * @param listener The callback that's invoked when the map failed to load + */ + public void addOnDidFailLoadingMapListener(OnDidFailLoadingMapListener listener) { + mapChangeReceiver.addOnDidFailLoadingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map failed to load. + * + * @param listener The callback that's invoked when the map failed to load + */ + public void removeOnDidFailLoadingMapListener(OnDidFailLoadingMapListener listener) { + mapChangeReceiver.removeOnDidFailLoadingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map will start rendering a frame. + * + * @param listener The callback that's invoked when the camera will start rendering a frame + */ + public void addOnWillStartRenderingFrameListener(OnWillStartRenderingFrameListener listener) { + mapChangeReceiver.addOnWillStartRenderingFrameListener(listener); + } + + /** + * Set a callback that's invoked when the map will start rendering a frame. + * + * @param listener The callback that's invoked when the camera will start rendering a frame + */ + public void removeOnWillStartRenderingFrameListener(OnWillStartRenderingFrameListener listener) { + mapChangeReceiver.removeOnWillStartRenderingFrameListener(listener); + } + + /** + * Set a callback that's invoked when the map has finished rendering a frame. + * + * @param listener The callback that's invoked when the map has finished rendering a frame + */ + public void addOnDidFinishRenderingFrameListener(OnDidFinishRenderingFrameListener listener) { + mapChangeReceiver.addOnDidFinishRenderingFrameListener(listener); + } + + /** + * Set a callback that's invoked when the map has finished rendering a frame. + * + * @param listener The callback that's invoked when the map has finished rendering a frame + */ + public void removeOnDidFinishRenderingFrameListener(OnDidFinishRenderingFrameListener listener) { + mapChangeReceiver.removeOnDidFinishRenderingFrameListener(listener); + } + + /** + * Set a callback that's invoked when the map will start rendering. + * + * @param listener The callback that's invoked when the map will start rendering + */ + public void addOnWillStartRenderingMapListener(OnWillStartRenderingMapListener listener) { + mapChangeReceiver.addOnWillStartRenderingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map will start rendering. + * + * @param listener The callback that's invoked when the map will start rendering + */ + public void removeOnWillStartRenderingMapListener(OnWillStartRenderingMapListener listener) { + mapChangeReceiver.removeOnWillStartRenderingMapListener(listener); + } + + /** + * Set a callback that's invoked when the map has finished rendering. + * + * @param listener The callback that's invoked when the map has finished rendering + */ + public void addOnDidFinishRenderingMapListener(OnDidFinishRenderingMapListener listener) { + mapChangeReceiver.addOnDidFinishRenderingMapListener(listener); + } + + /** + * Remove a callback that's invoked when the map has finished rendering. + * + * @param listener The callback that's invoked when the map has finished rendering + */ + public void removeOnDidFinishRenderingMapListener(OnDidFinishRenderingMapListener listener) { + mapChangeReceiver.removeOnDidFinishRenderingMapListener(listener); + } + + /** + * Set a callback that's invoked when the style has finished loading. + * + * @param listener The callback that's invoked when the style has finished loading + */ + public void addOnDidFinishLoadingStyleListener(OnDidFinishLoadingStyleListener listener) { + mapChangeReceiver.addOnDidFinishLoadingStyleListener(listener); + } + + /** + * Set a callback that's invoked when the style has finished loading. + * + * @param listener The callback that's invoked when the style has finished loading + */ + public void removeOnDidFinishLoadingStyleListener(OnDidFinishLoadingStyleListener listener) { + mapChangeReceiver.removeOnDidFinishLoadingStyleListener(listener); + } + + /** + * Set a callback that's invoked when a map source has changed. + * + * @param listener The callback that's invoked when the source has changed + */ + public void addOnSourceChangedListener(OnSourceChangedListener listener) { + mapChangeReceiver.addOnSourceChangedListener(listener); + } + + /** + * Set a callback that's invoked when a map source has changed. + * + * @param listener The callback that's invoked when the source has changed + */ + public void removeOnSourceChangedListener(OnSourceChangedListener listener) { + mapChangeReceiver.removeOnSourceChangedListener(listener); + } + + public interface OnCameraWillChangeListener { + + /** + * Called when the camera region will change. + */ + void onCameraWillChange(boolean animated); + } + + /** + * Interface definition for a callback to be invoked when the camera is changing. + * <p> + * {@link MapView#addOnCameraIsChangingListener(OnCameraIsChangingListener)} + * </p> + */ + public interface OnCameraIsChangingListener { + /** + * Called when the camera is changing. + */ + void onCameraIsChanging(); + } + + /** + * Interface definition for a callback to be invoked when the map region did change. + * <p> + * {@link MapView#addOnCameraDidChangeListener(OnCameraDidChangeListener)} + * </p> + */ + public interface OnCameraDidChangeListener { + /** + * Called when the camera did change. + */ + void onCameraDidChange(boolean animated); + } + + /** + * Interface definition for a callback to be invoked when the map will start loading. + * <p> + * {@link MapView#addOnWillStartLoadingMapListener(OnWillStartLoadingMapListener)} + * </p> + */ + public interface OnWillStartLoadingMapListener { + /** + * Called when the map will start loading. + */ + void onWillStartLoadingMap(); + } + + /** + * Interface definition for a callback to be invoked when the map finished loading. + * <p> + * {@link MapView#addOnDidFinishLoadingMapListener(OnDidFinishLoadingMapListener)} + * </p> + */ + public interface OnDidFinishLoadingMapListener { + /** + * Called when the map has finished loading. + */ + void onDidFinishLoadingMap(); + } + + /** + * Interface definition for a callback to be invoked when the map is changing. + * <p> + * {@link MapView#addOnDidFailLoadingMapListener(OnDidFailLoadingMapListener)} + * </p> + */ + public interface OnDidFailLoadingMapListener { + /** + * Called when the map failed to load. + * + * @param errorMessage The reason why the map failed to load + */ + void onDidFailLoadingMap(String errorMessage); + } + + /** + * Interface definition for a callback to be invoked when the map will start rendering a frame. + * <p> + * {@link MapView#addOnWillStartRenderingFrameListener(OnWillStartRenderingFrameListener)} + * </p> + */ + public interface OnWillStartRenderingFrameListener { + /** + * Called when the map will start rendering a frame. + */ + void onWillStartRenderingFrame(); + } + + /** + * Interface definition for a callback to be invoked when the map finished rendering a frame. + * <p> + * {@link MapView#addOnDidFinishRenderingFrameListener(OnDidFinishRenderingFrameListener)} + * </p> + */ + public interface OnDidFinishRenderingFrameListener { + /** + * Called when the map has finished rendering a frame + * + * @param fully true if all frames have been rendered, false if partially rendered + */ + void onDidFinishRenderingFrame(boolean fully); + } + + /** + * Interface definition for a callback to be invoked when the map will start rendering the map. + * <p> + * {@link MapView#addOnDidFailLoadingMapListener(OnDidFailLoadingMapListener)} + * </p> + */ + public interface OnWillStartRenderingMapListener { + /** + * Called when the map will start rendering. + */ + void onWillStartRenderingMap(); + } + + /** + * Interface definition for a callback to be invoked when the map is changing. + * <p> + * {@link MapView#addOnDidFinishRenderingMapListener(OnDidFinishRenderingMapListener)} + * </p> + */ + public interface OnDidFinishRenderingMapListener { + /** + * Called when the map has finished rendering. + * + * @param fully true if map is fully rendered, false if fully rendered + */ + void onDidFinishRenderingMap(boolean fully); + } + + /** + * Interface definition for a callback to be invoked when the map has loaded the style. + * <p> + * {@link MapView#addOnDidFailLoadingMapListener(OnDidFailLoadingMapListener)} + * </p> + */ + public interface OnDidFinishLoadingStyleListener { + /** + * Called when a style has finished loading. + */ + void onDidFinishLoadingStyle(); + } + + /** + * Interface definition for a callback to be invoked when a map source has changed. + * <p> + * {@link MapView#addOnDidFailLoadingMapListener(OnDidFailLoadingMapListener)} + * </p> + */ + public interface OnSourceChangedListener { + /** + * Called when a map source has changed. + * + * @param id the id of the source that has changed + */ + void onSourceChangedListener(String id); + } + + /** * <p> * Add a callback that's invoked when the displayed map view changes. * </p> @@ -689,7 +1070,9 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { * * @param listener The callback that's invoked on every frame rendered to the map view. * @see MapView#removeOnMapChangedListener(OnMapChangedListener) + * @deprecated use specific map change callbacks instead */ + @Deprecated public void addOnMapChangedListener(@NonNull OnMapChangedListener listener) { onMapChangedListeners.add(listener); } @@ -699,7 +1082,9 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { * * @param listener The previously added callback to remove. * @see MapView#addOnMapChangedListener(OnMapChangedListener) + * @deprecated use specific map change callbacks instead */ + @Deprecated public void removeOnMapChangedListener(@NonNull OnMapChangedListener listener) { if (onMapChangedListeners.contains(listener)) { onMapChangedListeners.remove(listener); @@ -954,7 +1339,9 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { * * @see MapView#addOnMapChangedListener(OnMapChangedListener) * @see MapView.MapChange + * @deprecated use specific map change callbacks instead */ + @Deprecated public interface OnMapChangedListener { /** * Called when the displayed map view changes. @@ -1299,4 +1686,4 @@ public class MapView extends FrameLayout implements NativeMapView.ViewCallback { public static void setMapStrictModeEnabled(boolean strictModeEnabled) { MapStrictMode.setStrictModeEnabled(strictModeEnabled); } -} +}
\ No newline at end of file diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/NativeMapView.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/NativeMapView.java index bf8c675cfa..48c571ee98 100755 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/NativeMapView.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/NativeMapView.java @@ -58,9 +58,12 @@ final class NativeMapView { // Used to validate if methods are called from the correct thread private final Thread thread; - // Used for callbacks + // Used for view callbacks private ViewCallback viewCallback; + // Used for map change callbacks + private StateCallback stateCallback; + // Device density private final float pixelRatio; @@ -85,17 +88,20 @@ final class NativeMapView { // public NativeMapView(final Context context, final boolean crossSourceCollisions, final ViewCallback viewCallback, - final MapRenderer mapRenderer) { - this(context, context.getResources().getDisplayMetrics().density, crossSourceCollisions, viewCallback, mapRenderer); + final StateCallback stateCallback, final MapRenderer mapRenderer) { + this(context, context.getResources().getDisplayMetrics().density, crossSourceCollisions, viewCallback, + stateCallback, mapRenderer); } public NativeMapView(final Context context, final float pixelRatio, final boolean crossSourceCollisions, - final ViewCallback viewCallback, final MapRenderer mapRenderer) { + final ViewCallback viewCallback, final StateCallback stateCallback, + final MapRenderer mapRenderer) { this.mapRenderer = mapRenderer; this.viewCallback = viewCallback; this.fileSource = FileSource.getInstance(context); this.pixelRatio = pixelRatio; this.thread = Thread.currentThread(); + this.stateCallback = stateCallback; nativeInitialize(this, fileSource, mapRenderer, pixelRatio, crossSourceCollisions); } @@ -917,6 +923,90 @@ final class NativeMapView { } @Keep + private void onCameraWillChange(boolean animated) { + stateCallback.onCameraWillChange(animated); + // deprecated API + onMapChanged(animated ? MapView.REGION_WILL_CHANGE_ANIMATED : MapView.REGION_WILL_CHANGE); + } + + @Keep + private void onCameraIsChanging() { + stateCallback.onCameraIsChanging(); + // deprecated API + onMapChanged(MapView.REGION_IS_CHANGING); + } + + @Keep + private void onCameraDidChange(boolean animated) { + stateCallback.onCameraDidChange(animated); + // deprecated API + onMapChanged(animated ? MapView.REGION_DID_CHANGE_ANIMATED : MapView.REGION_DID_CHANGE); + } + + @Keep + private void onWillStartLoadingMap() { + stateCallback.onWillStartLoadingMap(); + // deprecated API + onMapChanged(MapView.WILL_START_LOADING_MAP); + } + + @Keep + private void onDidFinishLoadingMap() { + stateCallback.onDidFinishLoadingMap(); + // deprecated API + onMapChanged(MapView.DID_FINISH_LOADING_MAP); + } + + @Keep + private void onDidFailLoadingMap(String error) { + stateCallback.onDidFailLoadingMap(error); + // deprecated API + onMapChanged(MapView.DID_FAIL_LOADING_MAP); + } + + @Keep + private void onWillStartRenderingFrame() { + stateCallback.onWillStartRenderingFrame(); + // deprecated API + onMapChanged(MapView.WILL_START_RENDERING_FRAME); + } + + @Keep + private void onDidFinishRenderingFrame(boolean fully) { + stateCallback.onDidFinishRenderingFrame(fully); + // deprecated API + onMapChanged(fully ? MapView.DID_FINISH_RENDERING_FRAME_FULLY_RENDERED : MapView.DID_FINISH_RENDERING_FRAME); + } + + @Keep + private void onWillStartRenderingMap() { + stateCallback.onWillStartRenderingMap(); + // deprecated API + onMapChanged(MapView.WILL_START_RENDERING_MAP); + } + + @Keep + private void onDidFinishRenderingMap(boolean fully) { + stateCallback.onDidFinishRenderingMap(fully); + // deprecated API + onMapChanged(fully ? MapView.DID_FINISH_RENDERING_MAP_FULLY_RENDERED : MapView.DID_FINISH_RENDERING_MAP); + } + + @Keep + private void onDidFinishLoadingStyle() { + stateCallback.onDidFinishLoadingStyle(); + // deprecated API + onMapChanged(MapView.DID_FINISH_LOADING_STYLE); + } + + @Keep + private void onSourceChanged(String sourceId) { + stateCallback.onSourceChanged(sourceId); + // deprecated API + onMapChanged(MapView.SOURCE_DID_CHANGE); + } + + @Keep protected void onSnapshotReady(Bitmap mapContent) { if (checkState("OnSnapshotReady")) { return; @@ -1220,10 +1310,17 @@ final class NativeMapView { // MapChangeEvents // + /** + * @deprecated use {@link StateCallback} instead + */ + @Deprecated void addOnMapChangedListener(@NonNull MapView.OnMapChangedListener listener) { onMapChangedListeners.add(listener); } + /** + * @deprecated use {@link StateCallback} instead + */ void removeOnMapChangedListener(@NonNull MapView.OnMapChangedListener listener) { if (onMapChangedListeners.contains(listener)) { onMapChangedListeners.remove(listener); @@ -1324,4 +1421,30 @@ final class NativeMapView { Bitmap getViewContent(); } + + public interface StateCallback { + void onCameraWillChange(boolean animated); + + void onCameraIsChanging(); + + void onCameraDidChange(boolean animated); + + void onWillStartLoadingMap(); + + void onDidFinishLoadingMap(); + + void onDidFailLoadingMap(String error); + + void onWillStartRenderingFrame(); + + void onDidFinishRenderingFrame(boolean fully); + + void onWillStartRenderingMap(); + + void onDidFinishRenderingMap(boolean fully); + + void onDidFinishLoadingStyle(); + + void onSourceChanged(String sourceId); + } } |