Pawandeep Singh's questions

我在 Jetpack Compose 中有一个嵌套的组件结构，其中深层嵌套的组件需要与 ViewModel 交互。我正在尝试确定处理此交互的最佳方法。

这是我的组件结构：

class MainViewModel : ViewModel() {
    fun handleButtonClick() {
        // Do something
    }
}

// Approach 1: Passing ViewModel down
@Composable
fun ComposableA(viewModel: MainViewModel) {
    ComposableB()
    ComposableC(viewModel = viewModel)
}

@Composable
fun ComposableC(viewModel: MainViewModel) {
    ComposableD(viewModel = viewModel)
}

@Composable
fun ComposableD(viewModel: MainViewModel) {
    Button(onClick = { viewModel.handleButtonClick() }) {
        Text("Click Me")
    }
}

// Approach 2: Using Callbacks
@Composable
fun ComposableA(viewModel: MainViewModel) {
    val onButtonClick = { viewModel.handleButtonClick() }
    
    ComposableB()
    ComposableC(onButtonClick = onButtonClick)
}

@Composable
fun ComposableC(onButtonClick: () -> Unit) {
    ComposableD(onButtonClick = onButtonClick)
}

@Composable
fun ComposableD(onButtonClick: () -> Unit) {
    Button(onClick = onButtonClick) {
        Text("Click Me")
    }
}

Which approach is considered better practice?

我如何在 Jetpack Compose 中做到这一点，当用户单击列表中的项目时，屏幕从右侧滑入，显示数据并在从左到右滑动时关闭？

这是通过导航到新屏幕或对可组合项进行动画处理来实现的吗？

我需要逻辑或者简单的代码来解释其工作原理。

在我的 Android 应用中，我从房间数据库获取数据并将其显示在 UI 上。我正在缓存映射数据。这是在视图模型中缓存数据的正确方法吗？我是 Android 新手，如果我错了，请纠正我。我正在使用 withContext 切换调度程序，我们需要切换吗？

    @HiltViewModel
class TrainVM @Inject constructor(
    private val repo: Repository,  // Inject the repository
private val apiRepo: KtorRepo

) : ViewModel() {

   
    private var localSchCache = mutableMapOf<String, TrainSchStat>()
    private var trainSchCache = mutableMapOf<String, TrainWithNew>()

    private val _trainStatus =
        MutableStateFlow<ViewState<TrainWithNew>>(value = ViewState.Loading)
    val trainStatus = _trainStatus.asStateFlow()

    private val _isLoading = MutableStateFlow(true)
    val isLoading = _isLoading.asStateFlow()

    fun fetchTrain(train: String, isLive: Boolean, date: LocalDate?) {
        _isLoading.update { true }
        _trainStatus.update { ViewState.Loading }
        if (isLive) {
            loadTrainStatus(train, date = date) //loads live status using API data
        } else {
            loadSchedule(train = train) // loads data from room
        }
    }

    //////////////////////////////////////////

    private fun loadSchedule(
        train: String,
    ) {
        viewModelScope.launch {
            try {
                withContext(Dispatchers.IO) {
                    val localSch = localSchCache[train] ?: repo.getSch(train)
                        .also { localSchCache[train] = it }

                    val trainSch = trainSchCache[train]
                        ?: mappedTrainToStation(localSch).also {
                            trainSchCache[train] = it
                        }

                    _trainStatus.update { ViewState.Success(data = trainSch) }
                }
            } catch (exception: Exception) {
                _trainStatus.update {
                    ViewState.Error(
                        message = exception.message ?: "An unknown error occurred"
                    )
                }
            } finally {
                _isLoading.update { false }
            }
        }
    }
private fun loadTrainStatus(
    train: String,
    date: LocalDate? = null,
) {

   viewModelScope.launch {
        try {
            val localData = localSchCache[train] ?: repo.getSch(train)
                .also { localSchCache[train] = it }

            apiRepo.fetchTrainStatus(train).onSuccess { apiData ->
                val mappedData = mappedTrainToStation(localData, apiData)
        _trainStatus.update { ViewState.Success(data = mappedData) }
            }.onFailure { exception ->
                _trainStatus.update {
                    ViewState.Error(
                        message = exception.message ?: "An unknown error"
                    )
                }
            }
        } catch (exception: Exception) {
            _trainStatus.update {
                ViewState.Error(
                    message = exception.message ?: "An unknown error occurred"
                )
            }
        } finally {
            _isLoading.update { false }
        }
    }
}

代码按预期运行，我想确保我做的事情是正确的。

在我的 Android 应用中，我从 Room 获取数据并将其显示在地图上。我遇到了这两种获取数据的视图模型方法。

哪一个是更有效且更好的方法？

目前，我正在使用第二种方法获取数据。它工作正常。只是想知道这两者之间有什么区别。

第一种方法：

private val _visibleRegion = MutableStateFlow(defaultVisibleRegion)
private val _zoomLevel = MutableStateFlow(6f)
private val _isFavorite = MutableStateFlow(false)

val mapData: StateFlow<PagingData<MapData>> = combine(
    _visibleRegion,
    _zoomLevel,
    _isFavorite
) { region, zoom, isFav ->
    Triple(region, zoom, isFav)
}.flatMapLatest { (region, zoom, isFav) ->
    repo.getDataInBoundsPaged(
        region.southwest.latitude,
        region.northeast.latitude,
        region.southwest.longitude,
        region.northeast.longitude,
        zoom = zoom,
        isFav = isFav
    )
}.stateIn(
    scope = viewModelScope,
    started = SharingStarted.WhileSubscribed(5000),
    initialValue = PagingData.empty()
)

fun updateVisibleRegion(region: LatLngBounds) {
    _visibleRegion.value = region
}

fun updateZoomLevel(zoom: Float) {
    _zoomLevel.value = zoom
}

fun toggleFavorite(isFavorite: Boolean) {
    _isFavorite.value = isFavorite
}

vs 第二种方法：

private val _mapData = MutableStateFlow<PagingData<MapData>>(PagingData.empty())
val mapData: StateFlow<PagingData<MapData>> = _mapData.asStateFlow()

private val defaultVisibleRegion = LatLngBounds(
    LatLng(6.792525080049721, 70.06730787456036),
    LatLng(37.411989227903604, 86.94231156259775)
)

init {
    fetchMapData()
}

fun fetchMapData(
    visibleRegion: LatLngBounds = defaultVisibleRegion,
    zoomLevel: Float = 6f,
    isFavorite: Boolean = false
) {
    viewModelScope.launch {
      
        repo.getDataInBoundsPaged(
            visibleRegion.southwest.latitude,
            visibleRegion.northeast.latitude,
            visibleRegion.southwest.longitude,
            visibleRegion.northeast.longitude,
            zoom = zoomLevel,
            isFav = isFavorite
        )
          
            .cachedIn(viewModelScope)
            .collect {
                _mapData.value = it
             
            }
    }
}

如何在撰写时创建带有此类自定义文本的自定义标记图标？

目前，我正在使用高级标记中的引脚配置创建此图标，但它会导致滞后，在高级标记中使用引脚配置不如普通标记那么流畅。

注：公交图标内置于地图中

带有 22222 文本的红色标记是使用

AdvancedMarker(
    state = markerState,
    pinConfig = marker.pinConfig,
    title = "hello",
    snippet = "World",
    alpha = alpha,
   
)

我想使用这个标记，我可以为这个标记函数提供上面的图标

Marker(
    state = markerState,
    icon = 
)

我无法在 Marker() 中使用 pin 配置。它需要 BitmapDescriptor

我在我的应用中使用了 Modal Bottom Sheet。如何防止它在向下滑动时关闭？我在表单上有一个延迟列。我希望它只在我单击关闭图标时关闭。

fun Preview(
    list: List<String>,
    onBottomSheetDismiss: (Boolean) -> Unit,
) {
    val scope = rememberCoroutineScope()
    val previewSheetState = rememberModalBottomSheetState(
        skipPartiallyExpanded = false,
    )
    ModalBottomSheet(
        onDismissRequest = { onBottomSheetDismiss(false) },
        sheetState = previewSheetState,
        modifier = Modifier.height(700.dp),
        dragHandle = {
            Column {
                Row(
                    Modifier
                        .fillMaxWidth()
                        .background(Color.White)
                        .padding(start = 15.dp, top = 10.dp, bottom = 5.dp, end = 10.dp),
                    Arrangement.SpaceBetween,
                    Alignment.CenterVertically
                ) {

               Text(text= "Preview")

                 CloseIcon(onClick = {
                        scope.launch {
                            previewSheetState.hide()
                            onBottomSheetDismiss(false)
                        }
                    })
                }
                HorizontalDivider(thickness = 1.dp)
            }
        }
    ) {
       LazyColumn(){
           items(list){
            Text(text= "it")
           }
        }

我正在从房间数据库中提取数据，函数返回我需要的数据，它会在惰性列中显示几秒钟，然后变为空白。

class TrainViewModel(private val cRepository: CRepository) : ViewModel() {
private val _trainList = MutableStateFlow<List<TrnTable>>(emptyList())
val trainList: StateFlow<List<TrnTable>> get() = _trainList

fun loadTrains() {
    viewModelScope.launch {
        cRepository.getAllTrains().collect { trains ->
            _trainList.value = trains
        }
    }
}

}

在 LazyColumn 中显示它

    @Composable
fun TrainListScreen(viewModel: TrainViewModel) {
    val trainList by viewModel.trainList.collectAsState()

    Column {
        Button(onClick = { viewModel.loadTrains() }) {
            Text("Load Trains")
        }

        LazyColumn {
            items(trainList) { train ->
                Text(text = train.name)
            }
        }
    }
}

但是当我使用这种方法时，可以正确检索数据。

val allTrains: Flow<List<TrnTable>> = cRepository.getAllTrains()

但我有大约 12k 列火车，哪种方法更有效？

存储库-

 fun getAllTrains(): Flow<List<TrnTable>> {
    return trainDao.getTrains()
}

DAO-

@Query("SELECT * FROM Trn")
abstract  fun getTrains(): Flow<List<TrnTable>>

实体-

 @Entity("Trn")
data class TrnTable(
    @PrimaryKey
    val number:String="",
    val name:String="",
    val fromStnCode:String="",
    val fromStnName:String="",
    val toStnCode:String="",
    val toStnName:String="",)

我正在构建一个 KTOR 后端服务器，它从 API 中提取数据并将其存储在 MongoDB Atlas 中。一些始终相同的数据我已将其存储在 MongoDB 中。我经常需要它来处理 API 数据。我有两个选择？要么我在每个 API 请求时调用从 mongo 中提取它，这将增加与数据库的连接，或者我所做的是将数据存储在代码资源文件夹中的 JSON 文件中，并从该文件中提取所需的数据。

就性能而言，第二种方法是否比第一种方法更好？

注意 - json 文档是 10000 个对象的数组，大小为 1.5MB。

这是我用来获取数据的代码

fun getStationsFromJson(statCode:String): Station? {
    val jsonText = File("fillepath").readText()
   val stations =Json.decodeFromString<List<Station>>(jsonText)
    val foundStationByCode = stations.find { it.stationCode == statCode }

    return foundStationByCode
}

这种方法好不好？或者还有什么我可以做的吗？