Заводим Яндекс Карты в Compose Multipltform

enabled – статус view (используется, если скрывается диалогом)
zoom – зум карты (не используется пока)
location – местоположение пользователя (latitude и longitude)
startPosition – стартовое положение камеры карты (запоминается)
points – список точек СТО (координаты, название и тд)
onPointClick – callback для выбора точки СТО
customPosition – выбранная пользователем точка
canSelectPosition – может ли пользователь сам выбрать точку
anotherLocationSelected – статус (выбрана ли точка вручную)
bottomFocusAreaPadding – размер bottomsheet, перекрывающего карту
onPositionSelected – callback для выбора метку вручную
onDragged – callback если пользователь сдвинул карту (чтобы не следить за его местоположением)

import Foundation
import YandexMapsMobile
import ComposeApp
import UIKit


class MapViewController: UIViewController {
    private let locationMark: UIImage = UIImage(named: "location_mark")!
    private let myLocatioPoint: UIImage = UIImage(named: "my_location_point")!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        mapView = YMKMapView(frame: view.frame)
        YMKMapKit.sharedInstance().onStart()
        view.addSubview(mapView)
        
        map = mapView.mapWindow.map
        addMyLocationPlacemark()
        addCustomLocationPlacemark()
        
        map.addCameraListener(with: mapCameraListener)
        map.addInputListener(with: mapInputListener)
        pinsCollection = map.mapObjects.add()
    }

    private func move(to cameraPosition: YMKCameraPosition) {
        map.move(with: cameraPosition, animation: YMKAnimation(type: .smooth, duration: 0.2))
    }

    private func addMyLocationPlacemark() {
        myPointPlacemark = map.mapObjects.addPlacemark()
        myPointPlacemark.setIconWith(
            myLocatioPoint,
            style: {
                let iconStyle = YMKIconStyle()
                iconStyle.anchor = NSValue(cgPoint: CGPoint(x: 0.5, y: 0.5))
                iconStyle.scale = 0.14
                iconStyle.flat = true
                return iconStyle
            }()
        )
    }
    
    private func addCustomLocationPlacemark() {
        customPointPlacemark = map.mapObjects.addPlacemark()
        customPointPlacemark.setIconWith(
            locationMark,
            style: {
                let iconStyle = YMKIconStyle()
                iconStyle.anchor = NSValue(cgPoint: CGPoint(x: 0.5, y: 1))
                iconStyle.scale = 0.14
                iconStyle.flat = false
                return iconStyle
            }()
        )
    }

    private var mapView: YMKMapView!
    private var map: YMKMap!
    private var myPointPlacemark: YMKPlacemarkMapObject!
    private var customPointPlacemark: YMKPlacemarkMapObject!
    
    private var pinsCollection: YMKMapObjectCollection!

    private lazy var mapCameraListener: MapCameraListener = MapCameraListener()
    private lazy var mapInputListener: MapInputListener = MapInputListener()
    private lazy var mapPointListener: MapPointListener = MapPointListener(controller: self)
    
    func addCameraListener(onDragged: @escaping () -> Void) {
        mapCameraListener.onDragged = onDragged
    }
    
    func addInputListener(onPositionSelect: @escaping (_ latitude: Double, _ longitude: Double) -> Void = {_, _ in }) {
        mapInputListener.onPositionSelect = onPositionSelect
    }
    
    func addPointListener(onPointClick: @escaping (KotlinLong) -> Void) {
        mapPointListener.onPointClick = { id, latLng in
            self.mapMove(latLng: latLng)
            onPointClick(id)
        }
    }

    func startMap() {
        YMKMapKit.sharedInstance().onStart()
    }
    
    func stopMap() {
        YMKMapKit.sharedInstance().onStop()
    }
    
    func mapMove(latLng: LatLng) {
        move(to: YMKCameraPosition(target: YMKPoint(latitude: latLng.latitude, longitude: latLng.longitude), zoom: 16.0, azimuth: 0.0, tilt: 0.0))
    }
    
    func updateMyPoint(latLng: LatLng?, visible: Bool) {
        if myPointPlacemark != nil {
            if latLng != nil {
                myPointPlacemark.geometry = YMKPoint(latitude: latLng!.latitude, longitude: latLng!.longitude)
            }
            myPointPlacemark.isVisible = visible
        }
    }
    
    func updateCustomPoint(latLng: LatLng?, visible: Bool) {
        if customPointPlacemark != nil {
            if latLng != nil {
                customPointPlacemark.geometry = YMKPoint(latitude: latLng!.latitude, longitude: latLng!.longitude)
            }
            customPointPlacemark.isVisible = visible
        }
    }
    
    func updateFocusArea(bottomFocusAreaPadding: Int) {
        let yVal = Float(mapView.mapWindow.height() - (bottomFocusAreaPadding as Int))
        mapView.mapWindow.focusRect = YMKScreenRect(
            topLeft: YMKScreenPoint(x: 0, y: 0),
            bottomRight: YMKScreenPoint(
                x: Float(mapView.mapWindow.width()),
                y: yVal < 0 ? 0 : yVal
            )
        )
    }
    
    func updatePointsCollection(points: [PointMapModel]) {
        pinsCollection.clear()
        if pinsCollection != nil {
            points.forEach { point in
                let pin = pinsCollection.addPlacemark()
                pin.geometry = YMKPoint(latitude: point.latLng.latitude, longitude: point.latLng.longitude)
                pin.setIconWith(
                    locationMark,
                    style: {
                        let iconStyle = YMKIconStyle()
                        iconStyle.anchor = NSValue(cgPoint: CGPoint(x: 0.5, y: 1))
                        iconStyle.scale = 0.14
                        iconStyle.flat = false
                        return iconStyle
                    }()
                )
                pin.setTextWithText(
                    point.name,
                    style: {
                        let textStyle = YMKTextStyle()
                        textStyle.size = 10
                        textStyle.placement = YMKTextStylePlacement.right
                        textStyle.offset = 5
                        return textStyle
                    }()
                )
                pin.userData = PointUserData(id: point.id)
                pin.addTapListener(with: mapPointListener)
            }
        }
    }
    
    final private class MapInputListener: NSObject, YMKMapInputListener {
        var onPositionSelect: (_ latitude: Double, _ longitude: Double) -> Void
        
        init(onPositionSelect: @escaping (_ latitude: Double, _ longitude: Double) -> Void = {_, _ in }) {
            self.onPositionSelect = onPositionSelect
        }
        
        func onMapTap(with map: YMKMap, point: YMKPoint) {
            onPositionSelect(point.latitude, point.longitude)
        }
        
        func onMapLongTap(with map: YMKMap, point: YMKPoint) {}
    }
    
    final private class MapCameraListener: NSObject, YMKMapCameraListener {
        var onDragged: () -> Void
        
        init(onDragged: @escaping () -> Void = {}) {
            self.onDragged = onDragged
        }
        
        func onCameraPositionChanged(with map: YMKMap, cameraPosition: YMKCameraPosition, cameraUpdateReason: YMKCameraUpdateReason, finished: Bool) {
            if (cameraUpdateReason == YMKCameraUpdateReason.gestures) {
                onDragged()
            }
        }
    }
    
    final private class MapPointListener: NSObject, YMKMapObjectTapListener {
        var onPointClick: (KotlinLong, LatLng) -> Void
        
        init(controller: UIViewController, onPointClick: @escaping (KotlinLong, LatLng) -> Void = {_, _ in}) {
            self.controller = controller
            self.onPointClick = onPointClick
        }
        
        func onMapObjectTap(with mapObject: YMKMapObject, point: YMKPoint) -> Bool {
            let userData = mapObject.userData as! PointUserData
            onPointClick(KotlinLong(value: userData.id), LatLng(latitude: point.latitude, longitude: point.longitude))
            return true
        }
        
        private weak var controller: UIViewController?
    }
    
    private struct PointUserData {
        let id: Int64
    }
}

import SwiftUI
import ComposeApp
import YandexMapsMobile

@main
 struct iOSApp: App {
    init() {
        YMKMapKit.setApiKey(Constants().MAPKIT_API_KEY)
        YMKMapKit.sharedInstance().onStart()
        KoinDI_iosKt.doInitKoinIos(mapProtocol: YandexMapProtocolImpl())
    }
    
	var body: some Scene {
		WindowGroup {
			ContentView()
		}
	}
}

@OptIn(ExperimentalForeignApi::class)
@Composable
actual fun YandexMap(
    modifier: Modifier,
    enabled: Boolean,
    zoom: Float,
    location: LatLng?,
    startPosition: LatLng?,
    points: List<PointMapModel>,
    onPointClick: (id: Long) -> Unit,
    customPosition: Boolean,
    canSelectPosition: State<Boolean>,
    anotherLocationSelected: Boolean,
    bottomFocusAreaPadding: Int,
    onPositionSelected: (lat: Double, lng: Double) -> Unit,
    onDragged: () -> Unit
) {
    val yandexMapProtocol = koinInject<YandexMapProtocol>().apply {
        addCameraListener(onDragged)
        addMapPointListener(onPointClick)
    }

    LaunchedEffect(canSelectPosition) {
        yandexMapProtocol.addMapListener { latitude, longitude ->
            if (canSelectPosition.value) {
                yandexMapProtocol.updateCustomPoint(
                    latLng = LatLng(latitude, longitude),
                    visible = true
                )
                onPositionSelected(latitude, longitude)
                yandexMapProtocol.onMapMove(LatLng(latitude, longitude))
            }
        }
    }

    LaunchedEffect(Unit) {
        yandexMapProtocol.onMapStart()
        location?.let { latLng ->
            Napier.d(tag = "YandexMap") { "Update map user location" }
            if (customPosition) {
                yandexMapProtocol.onMapMove(latLng)
            }
            yandexMapProtocol.updateMyPoint(latLng)
        }
        startPosition?.let { latLng ->
            yandexMapProtocol.onMapMove(latLng)
            if (anotherLocationSelected && canSelectPosition.value) {
                yandexMapProtocol.updateCustomPoint(
                    latLng = latLng
                )
            }
        }
        yandexMapProtocol.updateCustomPoint(
            visible = anotherLocationSelected
        )
    }
    
    LaunchedEffect(enabled) {
        if (enabled) {
            yandexMapProtocol.onMapStart()
        } else {
            yandexMapProtocol.onMapStop()
        }
    }

    LaunchedEffect(points) {
        yandexMapProtocol.updatePointsCollection(points)
    }

    DisposableEffect(Unit) {
        onDispose {
            yandexMapProtocol.onMapStop()
        }
    }

    UIKitView(
        factory = {
            yandexMapProtocol.viewController.view
        },
        modifier = modifier.fillMaxSize(),
        update = {
            location?.let { latLng ->
                if (customPosition) {
                    yandexMapProtocol.onMapMove(latLng)
                }
                yandexMapProtocol.updateMyPoint(latLng = latLng)
            }
            if (canSelectPosition.value) {
                yandexMapProtocol.updateCustomPoint(visible = anotherLocationSelected)
            } else {
                yandexMapProtocol.updateCustomPoint(visible = false)
            }
            yandexMapProtocol.setupFocusRect(bottomFocusAreaPadding)
        }
    )
}