Menampilkan lokasi pengguna dengan mapbox

DeviceLocationActivity.kt

package id.yukngoding.explore_mapbox.type.deviceLoc

import android.annotation.SuppressLint
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.mapbox.android.core.location.LocationEngine
import com.mapbox.android.core.location.LocationEngineProvider
import com.mapbox.android.core.location.LocationEngineRequest
import com.mapbox.android.core.permissions.PermissionsListener
import com.mapbox.android.core.permissions.PermissionsManager
import com.mapbox.mapboxsdk.location.LocationComponentActivationOptions
import com.mapbox.mapboxsdk.location.modes.CameraMode
import com.mapbox.mapboxsdk.location.modes.RenderMode
import com.mapbox.mapboxsdk.maps.MapboxMap
import com.mapbox.mapboxsdk.maps.OnMapReadyCallback
import com.mapbox.mapboxsdk.maps.Style
import id.yukngoding.explore_mapbox.R
import id.yukngoding.explore_mapbox.type.LocationChangeCallback
import kotlinx.android.synthetic.main.activity_device_location.*

class DeviceLocationActivity : AppCompatActivity(), OnMapReadyCallback, PermissionsListener {

    lateinit var mapboxMap: MapboxMap

    // Variables needed to handle location permissions
    private lateinit var permissionsManager: PermissionsManager

    // Variables needed to add the location engine
    private lateinit var locationEngine: LocationEngine
    private val DEFAULT_INTERVAL_IN_MILLISECONDS = 1000L
    private val DEFAULT_MAX_WAIT_TIME = DEFAULT_INTERVAL_IN_MILLISECONDS * 5

    private val callback: LocationChangeCallback =
        LocationChangeCallback(this)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_device_location)

        Mapbox.getInstance(this, getString(R.string.access_token))
        mapView.onCreate(savedInstanceState)
        mapView.getMapAsync(this)
    }

    override fun onMapReady(mapboxMap: MapboxMap) {
        Log.e("Ikhwan", "Trace onMapReady")
        this.mapboxMap = mapboxMap
        this.mapboxMap.setStyle(Style.TRAFFIC_DAY, Style.OnStyleLoaded {
            Log.e("Ikhwan", "Trace onMapReady, Style.OnStyleLoaded")
            enableLocationComponent(it)
        })
    }

    @SuppressLint("MissingPermission")
    private fun enableLocationComponent(loadedMapStyle: Style) {
        Log.e("Ikhwan", "Trace enableLocationComponent")
        // Check if permissions are enabled and if not request
        if (PermissionsManager.areLocationPermissionsGranted(this)) {
            Log.e("Ikhwan", "Trace enableLocationComponent location granted")

            // Get an instance of the component
            val locationComponent = mapboxMap.locationComponent

            // Set the LocationComponent activation options
            val locationComponentActivationOptions =
                LocationComponentActivationOptions.builder(this, loadedMapStyle)
                    .useDefaultLocationEngine(false)
                    .build()

            // Activate with the LocationComponentActivationOptions object
            locationComponent.activateLocationComponent(locationComponentActivationOptions)

            // Enable to make component visible
            // To active it
            locationComponent.isLocationComponentEnabled = true

            // Move camera to device location
            locationComponent.cameraMode = CameraMode.TRACKING

            // which means an arrow will be shown outside the device location icon to
            // display the device's compass bearing.
            // RenderMode.NORMAL: Blue circle without arrow
            // RenderMode.COMPASS: Blue circle with arrow, compass bearing
            // RenderMode.GPS: White circle with blue arrow, Like navigation
            locationComponent.renderMode = RenderMode.COMPASS
            initLocationEngine()
        } else {
            Log.e("Ikhwan", "Trace enableLocationComponent location else")
            permissionsManager = PermissionsManager(this)
            permissionsManager.requestLocationPermissions(this)
        }
    }

    /**
     * LocationEngine
     * */
    @SuppressLint("MissingPermission")
    private fun initLocationEngine() {
        Log.e("Ikhwan", "Trace initLocationEngine")
        locationEngine = LocationEngineProvider.getBestLocationEngine(this)
        val request = LocationEngineRequest.Builder(DEFAULT_INTERVAL_IN_MILLISECONDS)
            .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
            .setMaxWaitTime(DEFAULT_MAX_WAIT_TIME).build()
        locationEngine.requestLocationUpdates(request, callback, mainLooper)
        locationEngine.getLastLocation(callback)
    }

    /**
     * Permission
     * */
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        Log.e("Ikhwan", "Trace onRequestPermissionsResult")
        permissionsManager.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    override fun onExplanationNeeded(permissionsToExplain: MutableList<String>?) {
        Log.e("Ikhwan", "Trace onExplanationNeeded")
        Toast.makeText(
            this, R.string.user_location_permission_explanation,
            Toast.LENGTH_LONG
        ).show();
    }

    override fun onPermissionResult(granted: Boolean) {
        Log.e("Ikhwan", "Trace onPermissionResult $granted")
        if (granted) {
            mapboxMap.getStyle {
                enableLocationComponent(it)
            }
        } else {
            Toast.makeText(this, R.string.user_location_permission_not_granted, Toast.LENGTH_LONG)
                .show()
            finish()
        }
    }

    /**
     * LIFECYCLE
     * */
    override fun onStart() {
        super.onStart()
        mapView.onStart()
    }

    override fun onResume() {
        super.onResume()
        mapView.onResume()
    }

    override fun onPause() {
        super.onPause()
        mapView.onPause()
    }

    override fun onStop() {
        super.onStop()
        mapView.onStop()
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        mapView.onSaveInstanceState(outState)
    }

    override fun onDestroy() {
        super.onDestroy()
        // Prevent leaks
        if (this::locationEngine.isInitialized) {
            locationEngine.removeLocationUpdates(callback)
        }
        mapView.onDestroy()
    }

    override fun onLowMemory() {
        super.onLowMemory()
        mapView.onLowMemory()
    }

}