BobDoolittle's questions

Tenho um tempo representado em um Kotlin Instant. Quero obter a string de data e hora ISO 8601 para o fuso horário local no Android. Mas estou tendo conflitos com duas classes separadas chamadas TimeZone e não sei como traduzir entre elas (ou se estou no caminho certo).

A documentação do Kotlin diz para usar Instant.toLocalDateTime()e passar um TimeZone. Isso é androidx.datetime.TimeZone.

Os documentos do Android dizem para obter o fuso horário local usando TimeZone.getDefault(). Mas isso é android.icu.util.TimeZone.

Qual é a maneira correta de realizar essa tarefa simples?

Neste Google Codelab (Mars Photos), enquanto o Coil carrega imagens, o aplicativo exibe uma roda de progresso. O código usa este arquivo XML como um drawable:

e usa este código para exibi-lo:

@Composable
fun LoadingScreen(modifier: Modifier = Modifier) {
    Box(
        contentAlignment = Alignment.Center,
        modifier = modifier.fillMaxSize()
    ) {
        Image(
            modifier = Modifier.size(200.dp),
            painter = painterResource(R.drawable.loading_img),
            contentDescription = stringResource(R.string.loading)
        )
    }
}

No entanto, isso só exibe uma imagem estática. Quero que ela gire (o que eu certamente esperava como comportamento). Pensei em algumas abordagens, nenhuma das quais eu gosto muito:

• Defina 12 arquivos XML semelhantes, um para cada grau de rotação, e exiba cada um continuamente em sequência
• Gere dinamicamente o XML e de alguma forma o converta em um pintor na hora
• Use Coil para carregar um GIF

Existe uma maneira mais simples de realizar essa tarefa? Existe uma maneira de rotacionar a imagem em si programaticamente, como aplicar um modo de animação predefinido de algum tipo (talvez semelhante ao basicMarquee)?

Estou tentando criar uma UI que se parece muito com a que está no topo da página do Material3 Chip . Parece que a melhor maneira de fazer isso é construir um LazyVerticalStaggeredGrid, cujo conteúdo consiste em FilteredChipcomposables.

Um único FilteredChip em uma coluna é exibido perfeitamente. Mas quando eu o envolvo em um LazyVerticalStaggeredGrid, ele ignora as restrições de tamanho do texto e reduz a largura de cada chip, e fornece uma altura muito grande. De acordo com o Layout Inspector, o texto tem largura de 0 dp e altura de 140 dp. Além disso, ele ignora meu esquema de cores de tema.

Eu esperava que ele medisse o tamanho do texto dentro do Text composable e passasse isso para determinar a largura de cada chip e a altura de cada linha. Se não é assim que LazyGrids funcionam, como devo abordar isso?

Aqui está um exemplo muito simples que ilustra meu problema:

@Composable
fun VerticalGrid(
    contentList: List<String>,
    modifier: Modifier = Modifier,
) {
    LazyVerticalStaggeredGrid(
        horizontalArrangement = Arrangement.spacedBy(16.dp),
        columns = StaggeredGridCells.Adaptive(minSize = 4.dp),
        verticalItemSpacing = 8.dp,
        modifier = modifier.fillMaxSize()
    ) {
        var selected = false
        items(contentList) { text ->
            Chip(text, selected, { selected = !selected }, modifier)
        }
    }
}

@Composable
fun Chip(
    text: String,
    selected: Boolean,
    onClick: () -> (Unit),
    modifier: Modifier = Modifier,
) {
    FilterChip(
        onClick = onClick,
        label = { Text(text = text) },
        selected = selected,
        modifier = modifier
    )
}

object Content {
    val contentList = mutableListOf<String>()

    init {
        for (i in 10..50) {
            contentList.add("Label$i")
        }
    }
}

@Preview(showBackground = true)
@Composable
fun ChipPreview1() {
    StaggeredGridOfChipsTheme {
        Column(
            verticalArrangement = Arrangement.Top,
            modifier = Modifier.fillMaxSize()
        ) {
            Chip("Hello", true, {})
        }
    }
}

@Preview(showBackground = true)
@Composable
fun VerticalGridPreview1() {
    StaggeredGridOfChipsTheme {
        VerticalGrid(Content.contentList, Modifier.fillMaxSize())
    }
}

Isso resulta no seguinte comportamento:

Qualquer dica que pudesse me ajudar a solucionar esse problema também seria bem-vinda.

Tenho uma classe em Kotlin que nunca quero que seja instanciada por meio do construtor primário. Ambos os construtores secundários acabam inicializando uma propriedade com base em seus parâmetros, e quero ter certeza de que a propriedade seja inicializada (o que não será com o construtor primário).

Gostaria de declarar minha propriedade como lateinit e, então, testar para garantir que ela foi inicializada antes que quaisquer métodos de classe sejam executados (por exemplo, como uma etapa final da construção), para gerar algum tipo de erro significativo. Não quero ter que introduzir guardas em cada método de classe.

Aqui está um exemplo:

class ElementsContainer() {
    private lateinit var elements: Elements

    constructor(url: String): this() {
        val doc = Jsoup.connect(url).get()
        elements = doc.body().select("*")
    }

    constructor(newElements: Elements): this() {
        elements = newElements
    }
 ...
}

Existe uma maneira de minha classe validar o que elementsfoi inicializado como uma verificação final no final da construção (via this::elements.isInitialized) e falhar na construção caso contrário (por exemplo, lançar uma exceção)?

Estou seguindo este curso sobre o uso do Room no desenvolvimento Android: https://developer.android.com/codelabs/basic-android-kotlin-compose-update-data-room A classe DB é definida para criar um novo DB somente se ainda não existir um:

@Database(entities = [Item::class], version = 1, exportSchema = false)
abstract class InventoryDatabase : RoomDatabase() {
    abstract fun itemDao(): ItemDao

    companion object {
        @Volatile
        private var Instance: InventoryDatabase? = null

        fun getDatabase(context: Context): InventoryDatabase {
            return Instance ?: synchronized(this) {
                Room.databaseBuilder(context, InventoryDatabase::class.java, "item_database")
                    .fallbackToDestructiveMigration()
                    .build()
                    .also { Instance = it }
            }
        }
    }
}

A versão do DB nunca é alterada, nem minhas classes DB, DAO ou Entity (que alterariam o esquema). Presumo que é isso que desencadearia a migração destrutiva.

Consequentemente, eu esperaria que, uma vez que o BD fosse criado, seu conteúdo persistisse. No entanto, percebo que quando reconstruo meu aplicativo e o executo novamente, o conteúdo (às vezes?) desaparece. Por que isso aconteceria? Estou de alguma forma entulhando o sistema de arquivos com instâncias de BD (até onde eu sei, o local do sistema de arquivos que o Room usa por padrão requer acesso root, então não consigo dizer)?

Quero desserializar algum json complexo que tem muitas chaves opcionais, em Kotlin. Estou usando Retrofit2.

Eu só me importo com um pequeno subconjunto das chaves disponíveis, então, em vez de tentar definir rigorosamente classes de dados para trabalhar com todas as entradas json possíveis, eu gostaria de ignorar chaves desconhecidas e definir as partes que me importam. Estou construindo uma fábrica Retrofit para criar meu desserializador da seguinte forma:

private val retrofit = Retrofit.Builder()
        .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
        .baseUrl(baseUrl)
        .build()

como posso configurar esse conversor de forma que o Json faça a análise sintática usando ignoreUnknownKeys=trueo comportamento (ou vice-versa, se esse for o padrão)?