From 707415a788d15a90c230becb711d35c348fb0b38 Mon Sep 17 00:00:00 2001 From: Andrei Shkrob Date: Sat, 20 Sep 2025 17:28:21 +0200 Subject: [PATCH] [android-auto] Fix activity recreation when [dis]connecting to car Signed-off-by: Andrei Shkrob --- .../java/app/organicmaps/MwmActivity.java | 8 +- .../app/organicmaps/car/CarAppSession.java | 5 +- .../organicmaps/car/renderer/Renderer.java | 16 ++-- .../car/renderer/RendererFactory.java | 20 ++++ .../car/renderer/SurfaceCallback.java | 86 +++++++++++++++++ .../car/renderer/SurfaceCallbackBase.java | 94 +++++++++++++++++++ .../car/renderer/SurfaceCallbackLegacy.java | 75 +-------------- .../car/renderer/SurfaceRenderer.java | 64 +++++++++++++ .../car/renderer/SurfaceRendererLegacy.java | 12 +-- .../main/java/app/organicmaps/sdk/Map.java | 7 +- .../app/organicmaps/sdk/MapController.java | 9 +- .../java/app/organicmaps/sdk/MapView.java | 15 ++- 12 files changed, 314 insertions(+), 97 deletions(-) create mode 100644 android/app/src/main/java/app/organicmaps/car/renderer/RendererFactory.java create mode 100644 android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallback.java create mode 100644 android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackBase.java create mode 100644 android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRenderer.java diff --git a/android/app/src/main/java/app/organicmaps/MwmActivity.java b/android/app/src/main/java/app/organicmaps/MwmActivity.java index bed77cabd..6e8f47118 100644 --- a/android/app/src/main/java/app/organicmaps/MwmActivity.java +++ b/android/app/src/main/java/app/organicmaps/MwmActivity.java @@ -246,7 +246,7 @@ public class MwmActivity extends BaseMwmFragmentActivity ManageRouteBottomSheet mManageRouteBottomSheet; private boolean mRemoveDisplayListener = true; - private int mLastUiMode = Configuration.UI_MODE_TYPE_UNDEFINED; + private static int mLastUiMode = Configuration.UI_MODE_TYPE_UNDEFINED; public interface LeftAnimationTrackListener { @@ -471,12 +471,10 @@ public class MwmActivity extends BaseMwmFragmentActivity super.onConfigurationChanged(newConfig); final int newUiMode = newConfig.uiMode & Configuration.UI_MODE_TYPE_MASK; - final boolean newUiModeIsCarConnected = newUiMode == Configuration.UI_MODE_TYPE_CAR; - final boolean newUiModeIsCarDisconnected = - mLastUiMode == Configuration.UI_MODE_TYPE_CAR && newUiMode == Configuration.UI_MODE_TYPE_NORMAL; + final boolean carModeChanged = (newUiMode | mLastUiMode & Configuration.UI_MODE_TYPE_CAR) != 0; mLastUiMode = newUiMode; - if (newUiModeIsCarConnected || newUiModeIsCarDisconnected) + if (carModeChanged) return; makeNavigationBarTransparentInLightMode(); diff --git a/android/app/src/main/java/app/organicmaps/car/CarAppSession.java b/android/app/src/main/java/app/organicmaps/car/CarAppSession.java index b86e2796f..2f692567f 100644 --- a/android/app/src/main/java/app/organicmaps/car/CarAppSession.java +++ b/android/app/src/main/java/app/organicmaps/car/CarAppSession.java @@ -13,7 +13,7 @@ import androidx.lifecycle.LifecycleOwner; import app.organicmaps.MwmApplication; import app.organicmaps.R; import app.organicmaps.car.renderer.Renderer; -import app.organicmaps.car.renderer.SurfaceRendererLegacy; +import app.organicmaps.car.renderer.RendererFactory; import app.organicmaps.car.screens.ErrorScreen; import app.organicmaps.car.screens.MapPlaceholderScreen; import app.organicmaps.car.screens.MapScreen; @@ -113,10 +113,11 @@ public final class CarAppSession extends Session implements DefaultLifecycleObse public void onCreate(@NonNull LifecycleOwner owner) { Logger.d(TAG); - mSurfaceRenderer = new SurfaceRendererLegacy(getCarContext(), getLifecycle()); mSensorsManager = new CarSensorsManager(getCarContext()); mDisplayManager = MwmApplication.from(getCarContext()).getDisplayManager(); mDisplayManager.addListener(DisplayType.Car, this); + mSurfaceRenderer = RendererFactory.create(getCarContext(), mDisplayManager, + MwmApplication.from(getCarContext()).getLocationHelper(), this); init(); } diff --git a/android/app/src/main/java/app/organicmaps/car/renderer/Renderer.java b/android/app/src/main/java/app/organicmaps/car/renderer/Renderer.java index 992d47498..35cd7d2ce 100644 --- a/android/app/src/main/java/app/organicmaps/car/renderer/Renderer.java +++ b/android/app/src/main/java/app/organicmaps/car/renderer/Renderer.java @@ -19,6 +19,10 @@ public abstract class Renderer implements DefaultLifecycleObserver { private static final String TAG = Renderer.class.getSimpleName(); + private SurfaceCallback mSurfaceCallback; + + private boolean mIsRunning; + @NonNull protected final CarContext mCarContext; @@ -28,9 +32,8 @@ public abstract class Renderer implements DefaultLifecycleObserver @NonNull protected final LocationHelper mLocationHelper; - private boolean mIsRunning; - - private SurfaceCallback mSurfaceCallback; + @NonNull + protected final LifecycleOwner mLifecycleOwner; @NonNull private final MapRenderingListener mMapRenderingListener = new MapRenderingListener() { @@ -42,14 +45,15 @@ public abstract class Renderer implements DefaultLifecycleObserver }; public Renderer(@NonNull CarContext carContext, @NonNull DisplayManager displayManager, - @NonNull LocationHelper locationHelper, @NonNull Lifecycle lifecycle) + @NonNull LocationHelper locationHelper, @NonNull LifecycleOwner lifecycleOwner) { Logger.d(TAG, "SurfaceRenderer()"); + mIsRunning = true; mCarContext = carContext; mDisplayManager = displayManager; mLocationHelper = locationHelper; - mIsRunning = true; - lifecycle.addObserver(this); + mLifecycleOwner = lifecycleOwner; + mLifecycleOwner.getLifecycle().addObserver(this); } protected void setSurfaceCallback(@NonNull SurfaceCallback surfaceCallback) diff --git a/android/app/src/main/java/app/organicmaps/car/renderer/RendererFactory.java b/android/app/src/main/java/app/organicmaps/car/renderer/RendererFactory.java new file mode 100644 index 000000000..3dcc94170 --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/car/renderer/RendererFactory.java @@ -0,0 +1,20 @@ +package app.organicmaps.car.renderer; + +import androidx.annotation.NonNull; +import androidx.car.app.CarContext; +import androidx.lifecycle.LifecycleOwner; +import app.organicmaps.sdk.display.DisplayManager; +import app.organicmaps.sdk.location.LocationHelper; + +public final class RendererFactory +{ + @NonNull + public static Renderer create(@NonNull CarContext carContext, @NonNull DisplayManager displayManager, + @NonNull LocationHelper locationHelper, @NonNull LifecycleOwner lifecycleOwner) + { + if (android.os.Build.VERSION.SDK_INT >= 23) + return new SurfaceRenderer(carContext, displayManager, locationHelper, lifecycleOwner); + else + return new SurfaceRendererLegacy(carContext, displayManager, locationHelper, lifecycleOwner); + } +} diff --git a/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallback.java b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallback.java new file mode 100644 index 000000000..61e5f213e --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallback.java @@ -0,0 +1,86 @@ +package app.organicmaps.car.renderer; + +import android.app.Presentation; +import android.hardware.display.DisplayManager; +import android.hardware.display.VirtualDisplay; +import android.view.View; +import android.view.ViewGroup; +import android.view.ViewParent; +import android.widget.FrameLayout; +import androidx.annotation.NonNull; +import androidx.annotation.RequiresApi; +import androidx.car.app.CarContext; +import androidx.car.app.SurfaceContainer; +import app.organicmaps.sdk.MapController; +import app.organicmaps.sdk.util.log.Logger; + +@RequiresApi(23) +class SurfaceCallback extends SurfaceCallbackBase +{ + private static final String TAG = SurfaceCallback.class.getSimpleName(); + + private static final String VIRTUAL_DISPLAY_NAME = "OM_Android_Auto_Display"; + private static final int VIRTUAL_DISPLAY_FLAGS = + DisplayManager.VIRTUAL_DISPLAY_FLAG_PRESENTATION | DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY; + + @NonNull + private final MapController mMapController; + + private VirtualDisplay mVirtualDisplay; + private Presentation mPresentation; + + public SurfaceCallback(@NonNull CarContext carContext, @NonNull MapController mapController) + { + super(carContext); + mMapController = mapController; + } + + @Override + public void onSurfaceAvailable(@NonNull SurfaceContainer surfaceContainer) + { + Logger.d(TAG, "Surface available " + surfaceContainer); + + mVirtualDisplay = + mCarContext.getSystemService(DisplayManager.class) + .createVirtualDisplay(VIRTUAL_DISPLAY_NAME, surfaceContainer.getWidth(), surfaceContainer.getHeight(), + surfaceContainer.getDpi(), surfaceContainer.getSurface(), VIRTUAL_DISPLAY_FLAGS); + mPresentation = new Presentation(mCarContext, mVirtualDisplay.getDisplay()); + + mPresentation.setContentView(prepareViewForPresentation(mMapController.getView())); + mPresentation.show(); + } + + @Override + public void onSurfaceDestroyed(@NonNull SurfaceContainer surfaceContainer) + { + Logger.d(TAG, "Surface destroyed"); + mPresentation.dismiss(); + mVirtualDisplay.release(); + } + + void stopPresenting() + { + if (mPresentation != null) + mPresentation.dismiss(); + } + + void startPresenting() + { + if (mPresentation != null) + mPresentation.show(); + } + + @NonNull + private View prepareViewForPresentation(@NonNull View view) + { + final ViewParent parent = view.getParent(); + if (parent instanceof ViewGroup) + ((ViewGroup) parent).removeView(view); + + final FrameLayout container = new FrameLayout(mCarContext); + container.addView( + view, new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)); + + return container; + } +} diff --git a/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackBase.java b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackBase.java new file mode 100644 index 000000000..4708cf49a --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackBase.java @@ -0,0 +1,94 @@ +package app.organicmaps.car.renderer; + +import android.graphics.Rect; +import androidx.annotation.NonNull; +import androidx.car.app.CarContext; +import androidx.car.app.SurfaceCallback; +import app.organicmaps.sdk.Framework; +import app.organicmaps.sdk.Map; +import app.organicmaps.sdk.util.concurrency.UiThread; +import app.organicmaps.sdk.util.log.Logger; + +abstract class SurfaceCallbackBase implements SurfaceCallback +{ + private static final String TAG = SurfaceCallbackBase.class.getSimpleName(); + + @NonNull + protected final CarContext mCarContext; + + @NonNull + protected Rect mVisibleArea = new Rect(); + + public SurfaceCallbackBase(@NonNull CarContext carContext) + { + mCarContext = carContext; + } + + @Override + public void onVisibleAreaChanged(@NonNull Rect visibleArea) + { + Logger.d(TAG, "Visible area changed. visibleArea: " + visibleArea); + mVisibleArea = visibleArea; + + if (!mVisibleArea.isEmpty()) + UiThread.runLater(() + -> Framework.nativeSetVisibleRect(mVisibleArea.left, mVisibleArea.top, mVisibleArea.right, + mVisibleArea.bottom)); + } + + @Override + public void onStableAreaChanged(@NonNull Rect stableArea) + { + Logger.d(TAG, "Stable area changed. stableArea: " + stableArea); + + if (!mVisibleArea.isEmpty()) + UiThread.runLater(() + -> Framework.nativeSetVisibleRect(mVisibleArea.left, mVisibleArea.top, mVisibleArea.right, + mVisibleArea.bottom)); + else if (!stableArea.isEmpty()) + UiThread.runLater( + () -> Framework.nativeSetVisibleRect(stableArea.left, stableArea.top, stableArea.right, stableArea.bottom)); + } + + @Override + public void onScroll(float distanceX, float distanceY) + { + Logger.d(TAG, "distanceX: " + distanceX + ", distanceY: " + distanceY); + Map.onScroll(distanceX, distanceY); + } + + @Override + public void onFling(float velocityX, float velocityY) + { + Logger.d(TAG, "velocityX: " + velocityX + ", velocityY: " + velocityY); + // TODO: Implement fling in the native code. + } + + @Override + public void onScale(float focusX, float focusY, float scaleFactor) + { + Logger.d(TAG, "focusX: " + focusX + ", focusY: " + focusY + ", scaleFactor: " + scaleFactor); + float x = focusX; + float y = focusY; + + if (!mVisibleArea.isEmpty()) + { + // If a focal point value is negative, use the center point of the visible area. + if (x < 0) + x = mVisibleArea.centerX(); + if (y < 0) + y = mVisibleArea.centerY(); + } + + final boolean animated = Float.compare(scaleFactor, 2f) == 0; + + Map.onScale(scaleFactor, x, y, animated); + } + + @Override + public void onClick(float x, float y) + { + Logger.d(TAG, "x: " + x + ", y: " + y); + Map.onClick(x, y); + } +} diff --git a/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackLegacy.java b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackLegacy.java index 3e15d5ea0..9135ee5ba 100644 --- a/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackLegacy.java +++ b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceCallbackLegacy.java @@ -5,20 +5,15 @@ import android.view.Surface; import androidx.annotation.NonNull; import androidx.annotation.Nullable; import androidx.car.app.CarContext; -import androidx.car.app.SurfaceCallback; import androidx.car.app.SurfaceContainer; -import app.organicmaps.sdk.Framework; import app.organicmaps.sdk.Map; import app.organicmaps.sdk.location.LocationHelper; import app.organicmaps.sdk.util.log.Logger; -public class SurfaceCallbackLegacy implements SurfaceCallback +class SurfaceCallbackLegacy extends SurfaceCallbackBase { private static final String TAG = SurfaceCallbackLegacy.class.getSimpleName(); - @NonNull - protected final CarContext mCarContext; - @NonNull private final Map mMap; @@ -28,12 +23,9 @@ public class SurfaceCallbackLegacy implements SurfaceCallback @Nullable private Surface mSurface = null; - @NonNull - private Rect mVisibleArea = new Rect(); - public SurfaceCallbackLegacy(@NonNull CarContext carContext, @NonNull Map map, @NonNull LocationHelper locationHelper) { - mCarContext = carContext; + super(carContext); mMap = map; mLocationHelper = locationHelper; } @@ -65,67 +57,4 @@ public class SurfaceCallbackLegacy implements SurfaceCallback } mMap.onSurfaceDestroyed(false); } - - @Override - public void onVisibleAreaChanged(@NonNull Rect visibleArea) - { - Logger.d(TAG, "Visible area changed. visibleArea: " + visibleArea); - mVisibleArea = visibleArea; - - if (!mVisibleArea.isEmpty()) - Framework.nativeSetVisibleRect(mVisibleArea.left, mVisibleArea.top, mVisibleArea.right, mVisibleArea.bottom); - } - - @Override - public void onStableAreaChanged(@NonNull Rect stableArea) - { - Logger.d(TAG, "Stable area changed. stableArea: " + stableArea); - - if (!stableArea.isEmpty()) - Framework.nativeSetVisibleRect(stableArea.left, stableArea.top, stableArea.right, stableArea.bottom); - else if (!mVisibleArea.isEmpty()) - Framework.nativeSetVisibleRect(mVisibleArea.left, mVisibleArea.top, mVisibleArea.right, mVisibleArea.bottom); - } - - @Override - public void onScroll(float distanceX, float distanceY) - { - Logger.d(TAG, "distanceX: " + distanceX + ", distanceY: " + distanceY); - mMap.onScroll(distanceX, distanceY); - } - - @Override - public void onFling(float velocityX, float velocityY) - { - Logger.d(TAG, "velocityX: " + velocityX + ", velocityY: " + velocityY); - // TODO: Implement fling in the native code. - } - - @Override - public void onScale(float focusX, float focusY, float scaleFactor) - { - Logger.d(TAG, "focusX: " + focusX + ", focusY: " + focusY + ", scaleFactor: " + scaleFactor); - float x = focusX; - float y = focusY; - - if (!mVisibleArea.isEmpty()) - { - // If a focal point value is negative, use the center point of the visible area. - if (x < 0) - x = mVisibleArea.centerX(); - if (y < 0) - y = mVisibleArea.centerY(); - } - - final boolean animated = Float.compare(scaleFactor, 2f) == 0; - - Map.onScale(scaleFactor, x, y, animated); - } - - @Override - public void onClick(float x, float y) - { - Logger.d(TAG, "x: " + x + ", y: " + y); - Map.onClick(x, y); - } } diff --git a/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRenderer.java b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRenderer.java new file mode 100644 index 000000000..10cee4f68 --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRenderer.java @@ -0,0 +1,64 @@ +package app.organicmaps.car.renderer; + +import androidx.annotation.NonNull; +import androidx.annotation.RequiresApi; +import androidx.car.app.CarContext; +import androidx.lifecycle.LifecycleOwner; +import app.organicmaps.sdk.MapController; +import app.organicmaps.sdk.MapView; +import app.organicmaps.sdk.display.DisplayManager; +import app.organicmaps.sdk.display.DisplayType; +import app.organicmaps.sdk.location.LocationHelper; +import app.organicmaps.sdk.util.log.Logger; + +@RequiresApi(23) +class SurfaceRenderer extends Renderer +{ + private static final String TAG = SurfaceRenderer.class.getSimpleName(); + + @NonNull + private final MapController mMapController; + + @NonNull + private final SurfaceCallback mSurfaceCallback; + + public SurfaceRenderer(@NonNull CarContext carContext, @NonNull DisplayManager displayManager, + @NonNull LocationHelper locationHelper, @NonNull LifecycleOwner lifecycleOwner) + { + super(carContext, displayManager, locationHelper, lifecycleOwner); + + mMapController = new MapController(new MapView(carContext, DisplayType.Car), locationHelper, + getMapRenderingListener(), null, false); + mLifecycleOwner.getLifecycle().addObserver(mMapController); + mSurfaceCallback = new SurfaceCallback(mCarContext, mMapController); + setSurfaceCallback(mSurfaceCallback); + } + + @Override + public void onResume(@NonNull LifecycleOwner owner) + { + Logger.d(TAG); + if (mDisplayManager.isCarDisplayUsed()) + mMapController.updateMyPositionRoutingOffset(0); + } + + @Override + public void enable() + { + super.enable(); + + mMapController.onStart(mLifecycleOwner); + mMapController.updateMyPositionRoutingOffset(0); + mSurfaceCallback.startPresenting(); + } + + @Override + public void disable() + { + super.disable(); + + mMapController.onPause(mLifecycleOwner); + mSurfaceCallback.stopPresenting(); + mMapController.onStop(mLifecycleOwner); + } +} diff --git a/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRendererLegacy.java b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRendererLegacy.java index da8093104..0cabd95a7 100644 --- a/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRendererLegacy.java +++ b/android/app/src/main/java/app/organicmaps/car/renderer/SurfaceRendererLegacy.java @@ -4,23 +4,23 @@ import static app.organicmaps.sdk.display.DisplayType.Car; import androidx.annotation.NonNull; import androidx.car.app.CarContext; -import androidx.lifecycle.Lifecycle; import androidx.lifecycle.LifecycleOwner; -import app.organicmaps.MwmApplication; import app.organicmaps.sdk.Map; +import app.organicmaps.sdk.display.DisplayManager; +import app.organicmaps.sdk.location.LocationHelper; import app.organicmaps.sdk.util.log.Logger; -public class SurfaceRendererLegacy extends Renderer +class SurfaceRendererLegacy extends Renderer { private static final String TAG = SurfaceRendererLegacy.class.getSimpleName(); @NonNull private final Map mMap = new Map(Car); - public SurfaceRendererLegacy(@NonNull CarContext carContext, @NonNull Lifecycle lifecycle) + public SurfaceRendererLegacy(@NonNull CarContext carContext, @NonNull DisplayManager displayManager, + @NonNull LocationHelper locationHelper, @NonNull LifecycleOwner lifecycleOwner) { - super(carContext, MwmApplication.from(carContext).getDisplayManager(), - MwmApplication.from(carContext).getLocationHelper(), lifecycle); + super(carContext, displayManager, locationHelper, lifecycleOwner); setSurfaceCallback(new SurfaceCallbackLegacy(mCarContext, mMap, mLocationHelper)); mMap.setMapRenderingListener(getMapRenderingListener()); } diff --git a/android/sdk/src/main/java/app/organicmaps/sdk/Map.java b/android/sdk/src/main/java/app/organicmaps/sdk/Map.java index d9bf89f1d..3a689dbbf 100644 --- a/android/sdk/src/main/java/app/organicmaps/sdk/Map.java +++ b/android/sdk/src/main/java/app/organicmaps/sdk/Map.java @@ -280,7 +280,7 @@ public final class Map return mSurfaceCreated; } - public void onScroll(double distanceX, double distanceY) + public static void onScroll(double distanceX, double distanceY) { Map.nativeOnScroll(distanceX, distanceY); } @@ -329,6 +329,11 @@ public final class Map nativeExecuteMapApiRequest(); } + public DisplayType getDisplayType() + { + return mDisplayType; + } + private void setupWidgets(final Context context, int width, int height) { mHeight = height; diff --git a/android/sdk/src/main/java/app/organicmaps/sdk/MapController.java b/android/sdk/src/main/java/app/organicmaps/sdk/MapController.java index d38673314..6636621c2 100644 --- a/android/sdk/src/main/java/app/organicmaps/sdk/MapController.java +++ b/android/sdk/src/main/java/app/organicmaps/sdk/MapController.java @@ -9,9 +9,13 @@ import app.organicmaps.sdk.util.log.Logger; public class MapController implements DefaultLifecycleObserver { - private static final String TAG = MapController.class.getSimpleName(); + private static final String TAG_PEFRIX = MapController.class.getSimpleName(); + @NonNull + private final String TAG; + @NonNull private final MapView mMapView; + @NonNull private final Map mMap; @Nullable @@ -19,7 +23,7 @@ public class MapController implements DefaultLifecycleObserver public MapController(@NonNull MapView mapView, @NonNull LocationHelper locationHelper, @NonNull MapRenderingListener mapRenderingListener, - @NonNull Map.CallbackUnsupported callbackUnsupported, boolean launchByDeepLink) + @Nullable Map.CallbackUnsupported callbackUnsupported, boolean launchByDeepLink) { mMapView = mapView; mMap = mMapView.getMap(); @@ -27,6 +31,7 @@ public class MapController implements DefaultLifecycleObserver mMap.setLocationHelper(locationHelper); mMap.setMapRenderingListener(mapRenderingListener); mMap.setCallbackUnsupported(callbackUnsupported); + TAG = TAG_PEFRIX + "[" + mMap.getDisplayType() + "]"; } public MapView getView() diff --git a/android/sdk/src/main/java/app/organicmaps/sdk/MapView.java b/android/sdk/src/main/java/app/organicmaps/sdk/MapView.java index f756c50d7..7944ad027 100644 --- a/android/sdk/src/main/java/app/organicmaps/sdk/MapView.java +++ b/android/sdk/src/main/java/app/organicmaps/sdk/MapView.java @@ -51,7 +51,12 @@ public class MapView extends SurfaceView public MapView(Context context) { - this(context, null); + this(context, null, 0); + } + + public MapView(Context context, DisplayType displayType) + { + this(context, null, 0, 0, displayType); } public MapView(Context context, AttributeSet attrs) @@ -65,9 +70,15 @@ public class MapView extends SurfaceView } public MapView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) + { + this(context, attrs, defStyleAttr, defStyleRes, DisplayType.Device); + } + + private MapView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes, + @NonNull DisplayType displayType) { super(context, attrs, defStyleAttr, defStyleRes); - mMap = new Map(DisplayType.Device); + mMap = new Map(displayType); getHolder().addCallback(new SurfaceHolderCallback()); }