Get map moved event

[Psijic]

I need to save map position after it was moved by user or other ways (current location button click). How to get such event? I see only 2 available:

public interface MapListener {
    /*
     * Called when a map is scrolled.
     */
    public boolean onScroll(ScrollEvent event);

    /*
     * Called when a map is zoomed.
     */
    public boolean onZoom(ZoomEvent event);
}

In Google Maps I used:

LaunchedEffect(cameraPositionState.isMoving) {
    if (!cameraPositionState.isMoving) 
   viewModel.setCameraPosition(target.latitude, target.longitude, zoom)
}

[LostRat]

Call something like this from onCreate in map activity.

  void createMoveListener() {
    map.addMapListener(new DelayedMapListener(new MapListener() {

      public boolean onZoom(final ZoomEvent e) {
        //do something
        return true;
      }

      public boolean onScroll(final ScrollEvent e) {
        //do something
        onCameraIdle_DROID(); // this is where I do stuff
        return true;
      }

    }, 300));
  }

  public void onCameraIdle_DROID() {
    if (DEBUG) Log.d(TAG, "onCameraIdle");
  }

[Psijic]

It needs to set the scroll/zoom flag first and then make the action after it stopped. Bad part for developer.
Also what these booleans do? public boolean onScroll

[Psijic]

Something like this is needed. Currently action executes a lot of times in a row, need to optimize:

private fun mapMovingCheck(mapView: MapView, action: () -> Unit) {
    Timber.v("mapMovingCheck")
    // Initialize a flag to track whether the map is currently moving
    var isMoving: Boolean? = null

    // Create a Handler to delay the execution of the action
    val handler = Handler(Looper.getMainLooper())

    // Runnable to execute the action after map movement stops
    val runnable = Runnable {
        if (isMoving == false) {
            isMoving = null
            action()
        }
    }

    // Create a MapListener to listen for map events
    val mapListener = object : MapListener {
        override fun onScroll(event: ScrollEvent?): Boolean {
            // Set the flag to indicate that the map is currently moving
            isMoving = true
            // Remove any pending action execution
            handler.removeCallbacks(runnable)
            return true
        }

        override fun onZoom(event: ZoomEvent?): Boolean {
            // Set the flag to indicate that the map is currently moving
            isMoving = true
            // Remove any pending action execution
            handler.removeCallbacks(runnable)
            return true
        }
    }

    // Add the MapListener to the MapView
    mapView.addMapListener(mapListener)

    // Use the MapListener to execute the action after map movement stops
    mapView.addMapListener(object : MapListener {
        override fun onScroll(event: ScrollEvent?): Boolean {
            // Check if the map was previously moving
            if (isMoving == true) {
                isMoving = false
                // Post a delayed action to execute after map movement stops
                handler.postDelayed(runnable, 300) // Adjust the delay as needed
            }
            return true
        }

        override fun onZoom(event: ZoomEvent?): Boolean {
            // Check if the map was previously moving
            if (isMoving == true) {
                isMoving = false
                // Post a delayed action to execute after map movement stops
                handler.postDelayed(runnable, 300) // Adjust the delay as needed
            }
            return true
        }
    })
}

[Psijic]

Somehow it works fine enough with this code:

@Composable
fun MapViewWithSideEffect(mapView: MapView, action: () -> Unit) {
    Timber.v("MapViewWithSideEffect")
    var isMoving by remember { mutableStateOf(false) }

    mapView.addMapListener(DelayedMapListener(object : MapListener {
        override fun onScroll(event: ScrollEvent?): Boolean {
            // Set the flag to indicate that the map is currently moving
            isMoving = true
            return true
        }

        override fun onZoom(event: ZoomEvent?): Boolean {
            // Set the flag to indicate that the map is currently moving
            isMoving = true
            return true
        }
    }, 0))

    // Execute the action when the map movement stops
    LaunchedEffect(isMoving) {
//        delay(300) // Adjust the delay as needed
        if (!isMoving) {
            Timber.d("LaunchedEffect action")
            action()
        }
        isMoving = false
    }
}

The next question is: how many same listeners will be added (in memory at least) if MapViewWithSideEffect() executes often? It's better to make all listeners as Set and data class (analog in Java) to remove duplicates out of the box