mirror of
https://github.com/meshtastic/Meshtastic-Android.git
synced 2026-04-20 22:23:37 +00:00
643 lines
24 KiB
Kotlin
643 lines
24 KiB
Kotlin
package com.geeksville.mesh.ui
|
|
|
|
import android.app.AlertDialog
|
|
import android.content.Context
|
|
import android.content.SharedPreferences
|
|
import android.content.res.Resources
|
|
import android.graphics.Canvas
|
|
import android.graphics.Color
|
|
import android.graphics.Paint
|
|
import android.graphics.Rect
|
|
import android.os.Bundle
|
|
import android.util.Log
|
|
import android.view.*
|
|
import android.widget.*
|
|
import androidx.core.content.ContextCompat
|
|
import androidx.fragment.app.activityViewModels
|
|
import com.geeksville.mesh.BuildConfig
|
|
import com.geeksville.mesh.NodeInfo
|
|
import com.geeksville.mesh.R
|
|
import com.geeksville.mesh.android.Logging
|
|
import com.geeksville.mesh.database.entity.Packet
|
|
import com.geeksville.mesh.databinding.MapViewBinding
|
|
import com.geeksville.mesh.model.UIViewModel
|
|
import com.geeksville.mesh.model.map.CustomOverlayManager
|
|
import com.geeksville.mesh.model.map.CustomTileSource
|
|
import com.geeksville.mesh.model.map.NOAAWmsTileSource
|
|
import com.geeksville.mesh.util.formatAgo
|
|
import com.google.android.material.dialog.MaterialAlertDialogBuilder
|
|
import com.google.android.material.floatingactionbutton.FloatingActionButton
|
|
import dagger.hilt.android.AndroidEntryPoint
|
|
import org.osmdroid.api.IMapController
|
|
import org.osmdroid.config.Configuration
|
|
import org.osmdroid.events.MapListener
|
|
import org.osmdroid.events.ScrollEvent
|
|
import org.osmdroid.events.ZoomEvent
|
|
import org.osmdroid.tileprovider.MapTileProviderBasic
|
|
import org.osmdroid.tileprovider.cachemanager.CacheManager
|
|
import org.osmdroid.tileprovider.cachemanager.CacheManager.CacheManagerCallback
|
|
import org.osmdroid.tileprovider.modules.SqlTileWriter
|
|
import org.osmdroid.tileprovider.modules.SqliteArchiveTileWriter
|
|
import org.osmdroid.tileprovider.tilesource.ITileSource
|
|
import org.osmdroid.tileprovider.tilesource.OnlineTileSourceBase
|
|
import org.osmdroid.tileprovider.tilesource.TileSourcePolicyException
|
|
import org.osmdroid.util.BoundingBox
|
|
import org.osmdroid.util.GeoPoint
|
|
import org.osmdroid.views.CustomZoomButtonsController
|
|
import org.osmdroid.views.MapView
|
|
import org.osmdroid.views.overlay.*
|
|
import org.osmdroid.views.overlay.gridlines.LatLonGridlineOverlay2
|
|
import java.io.File
|
|
import kotlin.math.pow
|
|
import android.util.DisplayMetrics
|
|
|
|
|
|
@AndroidEntryPoint
|
|
class MapFragment : ScreenFragment("Map"), Logging, View.OnClickListener {
|
|
|
|
// UI Elements
|
|
private lateinit var binding: MapViewBinding
|
|
private lateinit var map: MapView
|
|
private lateinit var downloadBtn: FloatingActionButton
|
|
private lateinit var cacheEstimate: TextView
|
|
private lateinit var executeJob: Button
|
|
private var downloadPrompt: AlertDialog? = null
|
|
private var alertDialog: AlertDialog? = null
|
|
|
|
// constants
|
|
private val defaultMinZoom = 1.5
|
|
private val defaultMaxZoom = 18.0
|
|
private val nodeZoomLevel = 8.5
|
|
private val defaultZoomSpeed = 3000L
|
|
private val prefsName = "org.geeksville.osm.prefs"
|
|
private val mapStyleId = "map_style_id"
|
|
private var nodePositions = listOf<MarkerWithLabel>()
|
|
private var wayPoints = listOf<MarkerWithLabel>()
|
|
private val nodeLayer = 1
|
|
|
|
// Distance of bottom corner to top corner of bounding box
|
|
private val zoomLevelLowest = 13.0 // approx 5 miles long
|
|
private val zoomLevelMiddle = 12.25 // approx 10 miles long
|
|
private val zoomLevelHighest = 11.5 // approx 15 miles long
|
|
|
|
private var zoomLevelMin = 0.0
|
|
private var zoomLevelMax = 0.0
|
|
|
|
// Map Elements
|
|
private lateinit var mapController: IMapController
|
|
private lateinit var mPrefs: SharedPreferences
|
|
private lateinit var writer: SqliteArchiveTileWriter
|
|
private val model: UIViewModel by activityViewModels()
|
|
private lateinit var cacheManager: CacheManager
|
|
private lateinit var downloadRegionBoundingBox: BoundingBox
|
|
|
|
|
|
override fun onCreateView(
|
|
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
|
|
): View {
|
|
binding = MapViewBinding.inflate(inflater)
|
|
downloadBtn = binding.root.findViewById(R.id.downloadButton)
|
|
binding.cacheLayout.visibility = View.GONE
|
|
return binding.root
|
|
}
|
|
|
|
override fun onViewCreated(viewIn: View, savedInstanceState: Bundle?) {
|
|
super.onViewCreated(viewIn, savedInstanceState)
|
|
Configuration.getInstance().userAgentValue =
|
|
BuildConfig.APPLICATION_ID // Required to get online tiles
|
|
map = viewIn.findViewById(R.id.map)
|
|
mPrefs = context!!.getSharedPreferences(prefsName, Context.MODE_PRIVATE)
|
|
|
|
setupMapProperties()
|
|
map.setTileSource(loadOnlineTileSourceBase())
|
|
renderDownloadButton()
|
|
map.let {
|
|
if (view != null) {
|
|
mapController = map.controller
|
|
binding.mapStyleButton.setOnClickListener {
|
|
chooseMapStyle()
|
|
}
|
|
if (binding.cacheLayout.visibility == View.GONE) {
|
|
model.nodeDB.nodes.value?.let { nodes ->
|
|
onNodesChanged(nodes.values)
|
|
drawOverlays()
|
|
}
|
|
}
|
|
}
|
|
if (binding.cacheLayout.visibility == View.GONE) {
|
|
// Any times nodes change update our map
|
|
model.nodeDB.nodes.observe(viewLifecycleOwner) { nodes ->
|
|
onNodesChanged(nodes.values)
|
|
drawOverlays()
|
|
}
|
|
model.waypoints.observe(viewLifecycleOwner) {
|
|
debug("New waypoints received: ${it.size}")
|
|
onWaypointChanged(it.values)
|
|
drawOverlays()
|
|
}
|
|
}
|
|
zoomToNodes(mapController)
|
|
}
|
|
downloadBtn.setOnClickListener(this)
|
|
}
|
|
|
|
override fun onClick(v: View) {
|
|
when (v.id) {
|
|
R.id.executeJob -> updateEstimate()
|
|
R.id.downloadButton -> showCacheManagerDialog()
|
|
R.id.box5miles -> generateBoxOverlay(zoomLevelLowest)
|
|
R.id.box10miles -> generateBoxOverlay(zoomLevelMiddle)
|
|
R.id.box15miles -> generateBoxOverlay(zoomLevelHighest)
|
|
}
|
|
}
|
|
|
|
|
|
private fun showCacheManagerDialog() {
|
|
val alertDialogBuilder = AlertDialog.Builder(
|
|
activity
|
|
)
|
|
// set title
|
|
alertDialogBuilder.setTitle("Offline Manager")
|
|
// set dialog message
|
|
alertDialogBuilder.setItems(
|
|
arrayOf<CharSequence>(
|
|
"Current Cache size",
|
|
"Download Region",
|
|
"Clear Downloaded Tiles",
|
|
resources.getString(R.string.cancel)
|
|
)
|
|
) { dialog, which ->
|
|
when (which) {
|
|
0 -> showCurrentCacheInfo()
|
|
1 -> {
|
|
downloadJobAlert()
|
|
dialog.dismiss()
|
|
}
|
|
2 -> clearCache()
|
|
else -> dialog.dismiss()
|
|
}
|
|
}
|
|
// create alert dialog
|
|
alertDialog = alertDialogBuilder.create()
|
|
|
|
// show it
|
|
alertDialog!!.show()
|
|
|
|
}
|
|
|
|
/**
|
|
* Clears active tile source cache
|
|
*/
|
|
private fun clearCache() {
|
|
val b: Boolean = SqlTileWriter().purgeCache()
|
|
SqlTileWriter().onDetach()
|
|
val title = if (b) "SQL Cache purged" else "SQL Cache purge failed, see logcat for details"
|
|
val length = if (b) Toast.LENGTH_SHORT else Toast.LENGTH_LONG
|
|
Toast.makeText(activity, title, length).show()
|
|
alertDialog!!.dismiss()
|
|
}
|
|
|
|
|
|
private fun showCurrentCacheInfo() {
|
|
Toast.makeText(activity, "Calculating...", Toast.LENGTH_SHORT).show()
|
|
cacheManager = CacheManager(map) // Make sure CacheManager has latest from map
|
|
Thread {
|
|
val alertDialogBuilder = AlertDialog.Builder(
|
|
activity
|
|
)
|
|
// set title
|
|
alertDialogBuilder.setTitle("Cache Manager")
|
|
.setMessage(
|
|
"""
|
|
Cache Capacity (mb): ${cacheManager.cacheCapacity() * 2.0.pow(-20.0)}
|
|
Cache Usage (mb): ${cacheManager.currentCacheUsage() * 2.0.pow(-20.0)}
|
|
""".trimIndent()
|
|
)
|
|
// set dialog message
|
|
alertDialogBuilder.setItems(
|
|
arrayOf<CharSequence>(
|
|
resources.getString(R.string.cancel)
|
|
)
|
|
) { dialog, _ -> dialog.dismiss() }
|
|
activity!!.runOnUiThread { // show it
|
|
// create alert dialog
|
|
val alertDialog = alertDialogBuilder.create()
|
|
alertDialog.show()
|
|
}
|
|
}.start()
|
|
}
|
|
|
|
|
|
private fun downloadJobAlert() {
|
|
//prompt for input params .
|
|
binding.downloadButton.hide()
|
|
binding.mapStyleButton.visibility = View.GONE
|
|
binding.cacheLayout.visibility = View.VISIBLE
|
|
val builder = AlertDialog.Builder(activity)
|
|
binding.box5miles.setOnClickListener(this)
|
|
binding.box10miles.setOnClickListener(this)
|
|
binding.box15miles.setOnClickListener(this)
|
|
cacheEstimate = binding.cacheEstimate
|
|
generateBoxOverlay(zoomLevelLowest)
|
|
executeJob = binding.executeJob
|
|
executeJob.setOnClickListener(this)
|
|
binding.cancelDownload.setOnClickListener {
|
|
cacheEstimate.text = ""
|
|
defaultMapSettings()
|
|
|
|
}
|
|
builder.setCancelable(true)
|
|
}
|
|
|
|
/**
|
|
* Reset map to default settings & visible buttons
|
|
*/
|
|
private fun defaultMapSettings() {
|
|
binding.downloadButton.show()
|
|
binding.mapStyleButton.visibility = View.VISIBLE
|
|
binding.cacheLayout.visibility = View.GONE
|
|
setupMapProperties()
|
|
drawOverlays()
|
|
}
|
|
|
|
/**
|
|
* Creates Box overlay showing what area can be downloaded
|
|
*/
|
|
private fun generateBoxOverlay(zoomLevel: Double) {
|
|
drawOverlays()
|
|
map.setMultiTouchControls(false)
|
|
zoomLevelMax = zoomLevel // furthest back
|
|
zoomLevelMin =
|
|
map.tileProvider.tileSource.maximumZoomLevel.toDouble() // furthest in min should be > than max
|
|
mapController.setZoom(zoomLevel)
|
|
downloadRegionBoundingBox = map.boundingBox
|
|
val polygon = Polygon()
|
|
polygon.points = Polygon.pointsAsRect(downloadRegionBoundingBox) as MutableList<GeoPoint>
|
|
map.overlayManager.add(polygon)
|
|
mapController.setZoom(zoomLevel - 1.0)
|
|
cacheManager = CacheManager(map)
|
|
val tilecount: Int =
|
|
cacheManager.possibleTilesInArea(
|
|
downloadRegionBoundingBox,
|
|
zoomLevelMax.toInt(),
|
|
zoomLevelMin.toInt()
|
|
)
|
|
cacheEstimate.text = ("$tilecount tiles")
|
|
}
|
|
|
|
|
|
/**
|
|
* if true, start the job
|
|
* if false, just update the dialog box
|
|
*/
|
|
private fun updateEstimate() {
|
|
try {
|
|
if (this::downloadRegionBoundingBox.isInitialized) {
|
|
val outputName =
|
|
Configuration.getInstance().osmdroidBasePath.absolutePath + File.separator + "mainFile.sqlite" // TODO: Accept filename input param from user
|
|
writer = SqliteArchiveTileWriter(outputName)
|
|
//nesw
|
|
if (downloadPrompt != null) {
|
|
downloadPrompt!!.dismiss()
|
|
downloadPrompt = null
|
|
}
|
|
try {
|
|
cacheManager =
|
|
CacheManager(map, writer) // Make sure cacheManager has latest from map
|
|
} catch (ex: TileSourcePolicyException) {
|
|
Log.d("MapFragment", "Tilesource does not allow archiving: ${ex.message}")
|
|
return
|
|
}
|
|
//this triggers the download
|
|
downloadRegion(
|
|
downloadRegionBoundingBox,
|
|
zoomLevelMax.toInt(),
|
|
zoomLevelMin.toInt(),
|
|
)
|
|
}
|
|
} catch (ex: Exception) {
|
|
ex.printStackTrace()
|
|
}
|
|
}
|
|
|
|
private fun downloadRegion(bb: BoundingBox, zoommin: Int, zoommax: Int) {
|
|
cacheManager.downloadAreaAsync(
|
|
activity,
|
|
bb,
|
|
zoommin,
|
|
zoommax,
|
|
object : CacheManagerCallback {
|
|
override fun onTaskComplete() {
|
|
Toast.makeText(activity, "Download complete!", Toast.LENGTH_LONG)
|
|
.show()
|
|
writer.onDetach()
|
|
defaultMapSettings()
|
|
}
|
|
|
|
override fun onTaskFailed(errors: Int) {
|
|
Toast.makeText(
|
|
activity,
|
|
"Download complete with $errors errors",
|
|
Toast.LENGTH_LONG
|
|
).show()
|
|
writer.onDetach()
|
|
defaultMapSettings()
|
|
}
|
|
|
|
override fun updateProgress(
|
|
progress: Int,
|
|
currentZoomLevel: Int,
|
|
zoomMin: Int,
|
|
zoomMax: Int
|
|
) {
|
|
//NOOP since we are using the build in UI
|
|
}
|
|
|
|
override fun downloadStarted() {
|
|
//NOOP since we are using the build in UI
|
|
}
|
|
|
|
override fun setPossibleTilesInArea(total: Int) {
|
|
//NOOP since we are using the build in UI
|
|
}
|
|
})
|
|
}
|
|
|
|
private fun chooseMapStyle() {
|
|
/// Prepare dialog and its items
|
|
val builder = MaterialAlertDialogBuilder(context!!)
|
|
builder.setTitle(getString(R.string.preferences_map_style))
|
|
val mapStyles by lazy { resources.getStringArray(R.array.map_styles) }
|
|
|
|
/// Load preferences and its value
|
|
val editor: SharedPreferences.Editor = mPrefs.edit()
|
|
val mapStyleInt = mPrefs.getInt(mapStyleId, 1)
|
|
debug("mapStyleId from prefs: $mapStyleInt")
|
|
|
|
builder.setSingleChoiceItems(mapStyles, mapStyleInt) { dialog, which ->
|
|
debug("Set mapStyleId pref to $which")
|
|
editor.putInt(mapStyleId, which)
|
|
editor.apply()
|
|
dialog.dismiss()
|
|
map.setTileSource(loadOnlineTileSourceBase())
|
|
renderDownloadButton()
|
|
drawOverlays()
|
|
}
|
|
val dialog = builder.create()
|
|
dialog.show()
|
|
}
|
|
|
|
private fun renderDownloadButton() {
|
|
if (!(map.tileProvider.tileSource as OnlineTileSourceBase).tileSourcePolicy.acceptsBulkDownload()) {
|
|
downloadBtn.hide()
|
|
} else {
|
|
downloadBtn.show()
|
|
}
|
|
}
|
|
|
|
private fun onWaypointChanged(wayPt: Collection<Packet>) {
|
|
|
|
/**
|
|
* Using the latest waypoint, generate GeoPoint
|
|
*/
|
|
// Find all waypoints
|
|
fun getCurrentWayPoints(): List<MarkerWithLabel> {
|
|
val wayPoint = wayPt.map { pt ->
|
|
debug("Showing on map: $pt")
|
|
lateinit var marker: MarkerWithLabel
|
|
pt.data.waypoint?.let {
|
|
val label = it.name + " " + formatAgo(it.expire)
|
|
marker = MarkerWithLabel(map, label)
|
|
marker.title = it.name
|
|
marker.snippet = it.description
|
|
marker.setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_BOTTOM)
|
|
marker.position = GeoPoint(it.latitudeI.toDouble(), it.longitudeI.toDouble())
|
|
}
|
|
marker
|
|
}
|
|
return wayPoint
|
|
}
|
|
wayPoints = getCurrentWayPoints()
|
|
}
|
|
|
|
private fun onNodesChanged(nodes: Collection<NodeInfo>) {
|
|
val nodesWithPosition = nodes.filter { it.validPosition != null }
|
|
|
|
/**
|
|
* Using the latest nodedb, generate GeoPoint
|
|
*/
|
|
// Find all nodes with valid locations
|
|
fun getCurrentNodes(): List<MarkerWithLabel> {
|
|
val mrkr = nodesWithPosition.map { node ->
|
|
val p = node.position!!
|
|
debug("Showing on map: $node")
|
|
lateinit var marker: MarkerWithLabel
|
|
node.user?.let {
|
|
val label = it.longName + " " + formatAgo(p.time)
|
|
marker = MarkerWithLabel(map, label)
|
|
marker.title = "${it.longName} ${node.batteryStr}"
|
|
marker.snippet = model.gpsString(p)
|
|
model.nodeDB.ourNodeInfo?.let { our ->
|
|
our.distanceStr(node)?.let { dist ->
|
|
marker.subDescription = "bearing: ${our.bearing(node)}° distance: $dist"
|
|
}
|
|
}
|
|
marker.setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_BOTTOM)
|
|
marker.position = GeoPoint(p.latitude, p.longitude)
|
|
marker.icon = ContextCompat.getDrawable(
|
|
requireActivity(), R.drawable.ic_baseline_location_on_24
|
|
)
|
|
}
|
|
marker
|
|
}
|
|
return mrkr
|
|
}
|
|
nodePositions = getCurrentNodes()
|
|
}
|
|
|
|
|
|
/**
|
|
* Create LatLong Grid line overlay
|
|
* @param enabled: turn on/off gridlines
|
|
*/
|
|
private fun createLatLongGrid(enabled: Boolean) {
|
|
val latLongGridOverlay = LatLonGridlineOverlay2()
|
|
latLongGridOverlay.isEnabled = enabled
|
|
if (latLongGridOverlay.isEnabled) {
|
|
val textPaint = Paint()
|
|
textPaint.textSize = 40f
|
|
textPaint.color = Color.GRAY
|
|
textPaint.isAntiAlias = true
|
|
textPaint.isFakeBoldText = true
|
|
textPaint.textAlign = Paint.Align.CENTER
|
|
latLongGridOverlay.textPaint = textPaint
|
|
latLongGridOverlay.setBackgroundColor(Color.TRANSPARENT)
|
|
latLongGridOverlay.setLineWidth(3.0f)
|
|
latLongGridOverlay.setLineColor(Color.GRAY)
|
|
map.overlayManager.add(latLongGridOverlay)
|
|
}
|
|
}
|
|
|
|
private fun drawOverlays() {
|
|
map.overlayManager.overlays().clear()
|
|
addCopyright() // Copyright is required for certain map sources
|
|
createLatLongGrid(false)
|
|
map.overlayManager.addAll(nodeLayer, nodePositions)
|
|
map.overlayManager.addAll(nodeLayer, wayPoints)
|
|
if (map.tileProvider.tileSource.name()
|
|
.equals(CustomTileSource.getTileSource("ESRI World TOPO").name())
|
|
) {
|
|
val layer = TilesOverlay(
|
|
MapTileProviderBasic(
|
|
activity,
|
|
CustomTileSource.OPENWEATHER_RADAR
|
|
), context
|
|
)
|
|
layer.loadingBackgroundColor = Color.TRANSPARENT
|
|
layer.loadingLineColor = Color.TRANSPARENT
|
|
map.overlayManager.add(layer)
|
|
} else {
|
|
map.overlays.clear()
|
|
}
|
|
map.invalidate()
|
|
}
|
|
|
|
/**
|
|
* Adds copyright to map depending on what source is showing
|
|
*/
|
|
private fun addCopyright() {
|
|
if (map.tileProvider.tileSource.copyrightNotice != null) {
|
|
val copyrightNotice: String = map.tileProvider.tileSource.copyrightNotice
|
|
val copyrightOverlay = CopyrightOverlay(context)
|
|
copyrightOverlay.setCopyrightNotice(copyrightNotice)
|
|
map.overlays.add(copyrightOverlay)
|
|
}
|
|
}
|
|
|
|
private fun setupMapProperties() {
|
|
if (this::map.isInitialized) {
|
|
map.setDestroyMode(false) // keeps map instance alive when in the background.
|
|
map.isVerticalMapRepetitionEnabled = false // disables map repetition
|
|
map.overlayManager = CustomOverlayManager.create(map, context)
|
|
map.setScrollableAreaLimitLatitude(
|
|
map.overlayManager.tilesOverlay.bounds.actualNorth,
|
|
map.overlayManager.tilesOverlay.bounds.actualSouth,
|
|
0
|
|
) // bounds scrollable map
|
|
map.isTilesScaledToDpi =
|
|
true // scales the map tiles to the display density of the screen
|
|
map.minZoomLevel =
|
|
defaultMinZoom // sets the minimum zoom level (the furthest out you can zoom)
|
|
map.maxZoomLevel = defaultMaxZoom
|
|
map.setMultiTouchControls(true) // Sets gesture controls to true.
|
|
map.zoomController.setVisibility(CustomZoomButtonsController.Visibility.NEVER) // Disables default +/- button for zooming
|
|
map.addMapListener(object : MapListener {
|
|
override fun onScroll(event: ScrollEvent): Boolean {
|
|
if (binding.cacheLayout.visibility == View.VISIBLE) {
|
|
generateBoxOverlay(zoomLevelMax)
|
|
}
|
|
return true
|
|
}
|
|
|
|
override fun onZoom(event: ZoomEvent): Boolean {
|
|
return false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
private fun zoomToNodes(controller: IMapController) {
|
|
val points: MutableList<GeoPoint> = mutableListOf()
|
|
val nodesWithPosition =
|
|
model.nodeDB.nodes.value?.values?.filter { it.validPosition != null }
|
|
if ((nodesWithPosition != null) && nodesWithPosition.isNotEmpty()) {
|
|
if (nodesWithPosition.size >= 2) {
|
|
// Multiple nodes, make them all fit on the map view
|
|
nodesWithPosition.forEach {
|
|
points.add(
|
|
GeoPoint(
|
|
it.position!!.latitude, it.position!!.longitude
|
|
)
|
|
)
|
|
}
|
|
val box = BoundingBox.fromGeoPoints(points)
|
|
val point = GeoPoint(box.centerLatitude, box.centerLongitude)
|
|
controller.animateTo(point, nodeZoomLevel, defaultZoomSpeed)
|
|
} else {
|
|
// Only one node, just zoom in on it
|
|
val it = nodesWithPosition[0].position!!
|
|
points.add(GeoPoint(it.latitude, it.longitude))
|
|
controller.animateTo(points[0], nodeZoomLevel, defaultZoomSpeed)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun loadOnlineTileSourceBase(): ITileSource {
|
|
val id = mPrefs.getInt(mapStyleId, 1)
|
|
debug("mapStyleId from prefs: $id")
|
|
return CustomTileSource.mTileSources.getOrNull(id) ?: CustomTileSource.DEFAULT_TILE_SOURCE
|
|
}
|
|
|
|
override fun onPause() {
|
|
map.onPause()
|
|
if (alertDialog != null && alertDialog!!.isShowing) {
|
|
alertDialog!!.dismiss()
|
|
}
|
|
if (downloadPrompt != null && downloadPrompt!!.isShowing) {
|
|
downloadPrompt!!.dismiss()
|
|
}
|
|
super.onPause()
|
|
}
|
|
|
|
override fun onResume() {
|
|
super.onResume()
|
|
map.onResume()
|
|
}
|
|
|
|
override fun onDestroy() {
|
|
super.onDestroyView()
|
|
map.onDetach()
|
|
}
|
|
|
|
private inner class MarkerWithLabel(mapView: MapView?, label: String) : Marker(mapView) {
|
|
val mLabel = label
|
|
|
|
private fun getTextBackgroundSize(text: String, x: Float, y: Float, paint: Paint): Rect {
|
|
val fontMetrics: Paint.FontMetrics = paint.fontMetrics
|
|
val halfTextLength: Float = paint.measureText(text) / 2 + 3
|
|
return Rect(
|
|
(x - halfTextLength).toInt(),
|
|
(y + fontMetrics.top).toInt(),
|
|
(x + halfTextLength).toInt(),
|
|
(y + fontMetrics.bottom).toInt()
|
|
)
|
|
}
|
|
|
|
override fun draw(c: Canvas, osmv: MapView?, shadow: Boolean) {
|
|
draw(c, osmv)
|
|
}
|
|
|
|
fun draw(c: Canvas, osmv: MapView?) {
|
|
super.draw(c, osmv, false)
|
|
|
|
val p = mPositionPixels
|
|
|
|
val textPaint = Paint()
|
|
textPaint.textSize = 40f
|
|
textPaint.color = Color.DKGRAY
|
|
textPaint.isAntiAlias = true
|
|
textPaint.isFakeBoldText = true
|
|
textPaint.textAlign = Paint.Align.CENTER
|
|
|
|
val bgRect = getTextBackgroundSize(mLabel, (p.x - 0f), (p.y - 110f), textPaint)
|
|
val bgPaint = Paint()
|
|
bgPaint.color = Color.WHITE
|
|
|
|
c.drawRect(bgRect, bgPaint)
|
|
c.drawText(mLabel, (p.x - 0f), (p.y - 110f), textPaint)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|