diff --git a/sdk/src/androidTest/java/com/mapbox/maps/RenderCacheTest.kt b/sdk/src/androidTest/java/com/mapbox/maps/RenderCacheTest.kt index 0261be73ea..ec59dc99b0 100644 --- a/sdk/src/androidTest/java/com/mapbox/maps/RenderCacheTest.kt +++ b/sdk/src/androidTest/java/com/mapbox/maps/RenderCacheTest.kt @@ -7,6 +7,7 @@ import java.util.concurrent.CountDownLatch import java.util.concurrent.TimeUnit import java.util.concurrent.TimeoutException +@MapboxExperimental class RenderCacheTest { @get:Rule @@ -36,10 +37,10 @@ class RenderCacheTest { fun setDisabledRenderCache() { rule.scenario.onActivity { it.runOnUiThread { - mapView.setRenderCache(RenderCache.Disabled) + mapView.getMapboxMap().setRenderCacheOptions(RenderCacheOptions.Builder().setDisabled().build()) Assert.assertEquals( - RenderCache.CACHE_DISABLED, - Settings.get(RenderCache.RENDER_CACHE_SETTING).contents as Long + RENDER_CACHE_DISABLED, + mapView.getMapboxMap().getRenderCacheOptions().size ) } } @@ -49,10 +50,10 @@ class RenderCacheTest { fun setSmallRenderCache() { rule.scenario.onActivity { it.runOnUiThread { - mapView.setRenderCache(RenderCache.Small) + mapView.getMapboxMap().setRenderCacheOptions(RenderCacheOptions.Builder().setSmallSize().build()) Assert.assertEquals( - RenderCache.CACHE_SIZE_SMALL_MB, - Settings.get(RenderCache.RENDER_CACHE_SETTING).contents as Long + RENDER_CACHE_SIZE_SMALL_MB, + mapView.getMapboxMap().getRenderCacheOptions().size ) } } @@ -62,10 +63,10 @@ class RenderCacheTest { fun setLargeRenderCache() { rule.scenario.onActivity { it.runOnUiThread { - mapView.setRenderCache(RenderCache.Large) + mapView.getMapboxMap().setRenderCacheOptions(RenderCacheOptions.Builder().setLargeSize().build()) Assert.assertEquals( - RenderCache.CACHE_SIZE_LARGE_MB, - Settings.get(RenderCache.RENDER_CACHE_SETTING).contents as Long + RENDER_CACHE_SIZE_LARGE_MB, + mapView.getMapboxMap().getRenderCacheOptions().size ) } } @@ -75,24 +76,26 @@ class RenderCacheTest { fun setCustomRenderCache() { rule.scenario.onActivity { it.runOnUiThread { - val customSize = 256L - mapView.setRenderCache(RenderCache.Custom(customSize)) + val customSize = 256 + mapView.getMapboxMap().setRenderCacheOptions(RenderCacheOptions.Builder().size(customSize).build()) Assert.assertEquals( - customSize, Settings.get(RenderCache.RENDER_CACHE_SETTING).contents as Long + customSize, + mapView.getMapboxMap().getRenderCacheOptions().size ) } } } @Test + @Ignore("TODO Uncomment after https://github.com/mapbox/mapbox-maps-android/issues/402") fun setInvalidRenderCache() { rule.scenario.onActivity { it.runOnUiThread { - val customSize = -1L - mapView.setRenderCache(RenderCache.Custom(customSize)) - // render cache disabled by default now so checking for 0 here + val customSize = -1 + mapView.getMapboxMap().setRenderCacheOptions(RenderCacheOptions.Builder().size(customSize).build()) Assert.assertEquals( - 0L, Settings.get(RenderCache.RENDER_CACHE_SETTING).contents as Long + 0, + mapView.getMapboxMap().getRenderCacheOptions().size ) } } diff --git a/sdk/src/main/java/com/mapbox/maps/MapControllable.kt b/sdk/src/main/java/com/mapbox/maps/MapControllable.kt index 95dd176c03..96051d6803 100644 --- a/sdk/src/main/java/com/mapbox/maps/MapControllable.kt +++ b/sdk/src/main/java/com/mapbox/maps/MapControllable.kt @@ -40,20 +40,6 @@ interface MapControllable { */ fun onSizeChanged(w: Int, h: Int) - /** - * Render cache is introduced to store intermediate rendering results of tiles into cache textures - * to be reused in future frames. - * It's considerably smaller effort from the GPU to render quads with single texture lookups - * rather than rendering geometries of individual layers and tiles separately. - * - * Using render cache may bring improvement to rendering performance - * and reduce communication between CPU and GPU. - * - * @param cache [RenderCache] to apply to given [MapView]. - */ - @MapboxExperimental - fun setRenderCache(cache: RenderCache) - /** * Queue a runnable to be executed on the map renderer thread. * diff --git a/sdk/src/main/java/com/mapbox/maps/MapController.kt b/sdk/src/main/java/com/mapbox/maps/MapController.kt index 66f9c97c6f..2e5ff33a62 100644 --- a/sdk/src/main/java/com/mapbox/maps/MapController.kt +++ b/sdk/src/main/java/com/mapbox/maps/MapController.kt @@ -6,11 +6,9 @@ import android.os.Looper import android.util.AttributeSet import android.view.MotionEvent import com.mapbox.annotation.module.MapboxModuleType -import com.mapbox.bindgen.Value import com.mapbox.common.Logger import com.mapbox.common.module.provider.MapboxModuleProvider import com.mapbox.common.module.provider.ModuleProviderArgument -import com.mapbox.maps.RenderCache.Companion.RENDER_CACHE_SETTING import com.mapbox.maps.assets.AssetManagerProvider import com.mapbox.maps.loader.MapboxMapStaticInitializer import com.mapbox.maps.module.MapTelemetry @@ -145,15 +143,6 @@ internal class MapController : MapPluginProviderDelegate, MapControllable { pluginRegistry.onSizeChanged(w, h) } - @MapboxExperimental - override fun setRenderCache(cache: RenderCache) { - if (cache.cacheSizeMb >= 0) { - Settings.set(RENDER_CACHE_SETTING, Value(cache.cacheSizeMb)) - } else { - Logger.e(TAG, "Render cache size must be >= 0!") - } - } - override fun queueEvent(event: Runnable, needRender: Boolean) { if (needRender) { renderer.queueRenderEvent(event) diff --git a/sdk/src/main/java/com/mapbox/maps/MapSurface.kt b/sdk/src/main/java/com/mapbox/maps/MapSurface.kt index 47b566bea2..d2a60912ba 100644 --- a/sdk/src/main/java/com/mapbox/maps/MapSurface.kt +++ b/sdk/src/main/java/com/mapbox/maps/MapSurface.kt @@ -102,22 +102,6 @@ class MapSurface( mapController.onSizeChanged(w, h) } - /** - * Render cache is introduced to store intermediate rendering results of tiles into cache textures - * to be reused in future frames. - * It's considerably smaller effort from the GPU to render quads with single texture lookups - * rather than rendering geometries of individual layers and tiles separately. - * - * Using render cache may bring improvement to rendering performance - * and reduce communication between CPU and GPU. - * - * @param cache [RenderCache] to apply to given [MapView]. - */ - @MapboxExperimental - override fun setRenderCache(cache: RenderCache) { - mapController.setRenderCache(cache) - } - /** * Queue a runnable to be executed on the map renderer thread. * diff --git a/sdk/src/main/java/com/mapbox/maps/MapView.kt b/sdk/src/main/java/com/mapbox/maps/MapView.kt index 3e764cec49..f321068d4e 100644 --- a/sdk/src/main/java/com/mapbox/maps/MapView.kt +++ b/sdk/src/main/java/com/mapbox/maps/MapView.kt @@ -97,8 +97,6 @@ open class MapView : FrameLayout, MapPluginProviderDelegate, MapControllable { }, resolvedMapInitOptions ) - // render cache disabled explicitly by default - mapController.setRenderCache(RenderCache.Disabled) addView(view, 0) mapController.initializePlugins(resolvedMapInitOptions, this) } @@ -166,22 +164,6 @@ open class MapView : FrameLayout, MapPluginProviderDelegate, MapControllable { mapController.onSizeChanged(w, h) } - /** - * Render cache is introduced to store intermediate rendering results of tiles into cache textures - * to be reused in future frames. - * It's considerably smaller effort from the GPU to render quads with single texture lookups - * rather than rendering geometries of individual layers and tiles separately. - * - * Using render cache may bring improvement to rendering performance - * and reduce communication between CPU and GPU. - * - * @param cache [RenderCache] to apply to given [MapView]. - */ - @MapboxExperimental - override fun setRenderCache(cache: RenderCache) { - mapController.setRenderCache(cache) - } - /** * You must call this method from the parent's Activity#onStart() or Fragment#onStart() * @see android.app.Activity.onStart diff --git a/sdk/src/main/java/com/mapbox/maps/RenderCache.kt b/sdk/src/main/java/com/mapbox/maps/RenderCache.kt deleted file mode 100644 index 7a469e9f2d..0000000000 --- a/sdk/src/main/java/com/mapbox/maps/RenderCache.kt +++ /dev/null @@ -1,45 +0,0 @@ -package com.mapbox.maps - -/** - * Describes render cache mode where [cacheSizeMb] is actual GPU render cache size in megabytes. - */ -sealed class RenderCache( - /** - * Render cache size in megabytes. - * That value should be greater than zero and less than GPU memory. - * It is highly advised to use [RenderCache.Small] or [RenderCache.Large] in most cases. - */ - val cacheSizeMb: Long -) { - /** - * Render cache is disabled. - */ - object Disabled : RenderCache(CACHE_DISABLED) - - /** - * Render cache is set to be small. - * Works best with devices with not so powerful GPUs. - */ - object Small : RenderCache(CACHE_SIZE_SMALL_MB) - - /** - * Render cache is set to be large. - * Works best with devices powerful GPUs. - */ - object Large : RenderCache(CACHE_SIZE_LARGE_MB) - - /** - * Custom render cache with given [cacheSizeMb]. - */ - class Custom(cacheSizeMb: Long) : RenderCache(cacheSizeMb) - - /** - * Static variables. - */ - companion object { - internal const val RENDER_CACHE_SETTING = "mapbox_render_cache_size_mb" - internal const val CACHE_DISABLED = 0L - internal const val CACHE_SIZE_SMALL_MB = 64L - internal const val CACHE_SIZE_LARGE_MB = 128L - } -} \ No newline at end of file diff --git a/sdk/src/main/java/com/mapbox/maps/RenderCacheOptionsExt.kt b/sdk/src/main/java/com/mapbox/maps/RenderCacheOptionsExt.kt new file mode 100644 index 0000000000..c1c9a9feac --- /dev/null +++ b/sdk/src/main/java/com/mapbox/maps/RenderCacheOptionsExt.kt @@ -0,0 +1,33 @@ +package com.mapbox.maps + +/** + * Set render cache size to 0MB in order to disable it. + */ +fun RenderCacheOptions.Builder.setDisabled(): RenderCacheOptions.Builder = also { + size(RENDER_CACHE_DISABLED) +} + +/** + * Set render cache size to small(64MB). + * + * Works best with devices with not so powerful GPUs, or devices with pixel ratio of 1.0. + */ +fun RenderCacheOptions.Builder.setSmallSize(): RenderCacheOptions.Builder = also { + size(RENDER_CACHE_SIZE_SMALL_MB) +} + +/** + * Set render cache size to large(128MB). + * + * Works best with devices powerful GPUs, or devices with pixel ratio > 1.0. + */ +fun RenderCacheOptions.Builder.setLargeSize(): RenderCacheOptions.Builder = also { + size(RENDER_CACHE_SIZE_LARGE_MB) +} + +/** + * Static variables. + */ +internal const val RENDER_CACHE_DISABLED = 0 +internal const val RENDER_CACHE_SIZE_SMALL_MB = 64 +internal const val RENDER_CACHE_SIZE_LARGE_MB = 128 \ No newline at end of file