Kotlin Academy · Aula

APIs da Plataforma

Acesse recursos nativos

APIs da Plataforma é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Acessando recursos nativos

O código compartilhado às vezes precisa dos recursos do dispositivo — armazenamento, configurações, relógio e mecanismo de rede. O KMM oferece várias maneiras de acessar APIs nativas de forma organizada.

expect/actual para valores primitivos

Para valores pequenos da plataforma, use expect/actual. O código comum permanece organizado, enquanto cada plataforma fornece os detalhes.

// commonMain
expect fun currentTimeMillis(): Long

// androidMain
actual fun currentTimeMillis(): Long = System.currentTimeMillis()

Injeção de dependências do código da plataforma

Uma abordagem mais flexível: defina uma interface no código comum e injete uma implementação da plataforma a partir de cada aplicativo.

// commonMain
interface Storage {
    fun save(key: String, value: String)
    fun load(key: String): String?
}

Implementação para Android

O Android implementa a interface com SharedPreferences e a fornece ao código compartilhado.

// androidMain
import android.content.SharedPreferences

class AndroidStorage(private val prefs: SharedPreferences) : Storage {
    override fun save(key: String, value: String) {
        prefs.edit().putString(key, value).apply()
    }
    override fun load(key: String): String? = prefs.getString(key, null)
}

Implementação para iOS

O iOS implementa a mesma interface com NSUserDefaults da estrutura Foundation.

// iosMain
import platform.Foundation.NSUserDefaults

class IosStorage : Storage {
    private val defaults = NSUserDefaults.standardUserDefaults
    override fun save(key: String, value: String) = defaults.setObject(value, key)
    override fun load(key: String): String? = defaults.stringForKey(key)
}

Chamando APIs nativas do iOS

Em iosMain, você pode chamar diretamente as estruturas da Apple, pois o Kotlin/Native gera vínculos de interoperabilidade para elas.

import platform.UIKit.UIDevice

fun deviceModel(): String = UIDevice.currentDevice.model

Chamando APIs do Android

androidMain tem todo o SDK do Android disponível, pois é compilado com base na plataforma Android.

import android.os.Build

fun deviceModel(): String = Build.MODEL

Bibliotecas multiplataforma prontas

Muitas vezes, você não precisa criar uma interoperabilidade personalizada. As bibliotecas já encapsulam recursos comuns:

multiplatform-settings — armazenamento de pares chave-valor
Ktor — comunicação em rede
SQLDelight — banco de dados local

Fornecendo implementações

Injete implementações da plataforma na inicialização do aplicativo, normalmente por meio de uma estrutura de DI como o Koin, para que o código compartilhado receba a implementação correta.

// Android: provide AndroidStorage(prefs)
// iOS: provide IosStorage()
// Shared Repository(storage) uses whichever was injected

Escolhendo uma abordagem

Diretrizes:

Valor pequeno → expect/actual
Comportamento com vários métodos → interface + injeção
Necessidade comum → use uma biblioteca multiplataforma existente

Demonstração executável de uma abstração

A ideia de interface usa Kotlin básico. Aqui, uma implementação em memória representa um armazenamento da plataforma.

interface Storage {
    fun save(key: String, value: String)
    fun load(key: String): String?
}

class MemoryStorage : Storage {
    private val map = mutableMapOf<String, String>()
    override fun save(key: String, value: String) { map[key] = value }
    override fun load(key: String): String? = map[key]
}

fun main() {
    val s: Storage = MemoryStorage()
    s.save("name", "Ada")
    println(s.load("name"))
}

Verificação rápida

Você precisa de um recurso de armazenamento com vários métodos, implementado de maneira diferente em cada plataforma e fácil de testar. Qual abordagem é recomendada?

Recapitulação

Você pode acessar recursos nativos de forma organizada:

expect/actual para valores primitivos
Interface comum + implementação da plataforma injetada para comportamentos
Interoperabilidade direta em androidMain/iosMain
Reutilize bibliotecas multiplataforma sempre que possível

Isso conclui o curso Fundamentos do KMM.

Perguntas Frequentes

A aula “APIs da Plataforma” é grátis?

Sim — o texto completo de “APIs da Plataforma” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “APIs da Plataforma”?

Acesse recursos nativos Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “APIs da Plataforma”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy