<link rel="stylesheet" href="/fa/font-awesome.css">
App mobili24 min di letturaAggiornato il

Kotlin Multiplatform (KMP): architettura, funzionamento interno e codice condiviso tra Android e iOS

Kotlin Multiplatform (KMP) consente la condivisione del codice tra Android, iOS e altre piattaforme senza imporre un'unica architettura a tutte le applicazioni. Scopri la sua architettura, i set di sorgenti, il ruolo del compilatore Kotlin, come funzionano Kotlin/JVM e Kotlin/Native, l'interoperabilità con Swift e i meccanismi che permettono al codice condiviso di comunicare con le API native.

Kotlin Multiplatform (KMP): architettura, funzionamento interno e codice condiviso tra Android e iOS
Indice
  1. Kotlin Multiplatform (KMP): architettura, funzionamento interno e codice condiviso tra Android e iOS
  2. Introduzione
  3. 1. Cos'è Kotlin Multiplatform?
  4. Esempio semplice
  5. 2. KMP è un framework di interfaccia grafica?
  6. Con KMP senza interfaccia condivisa
  7. Con KMP e Compose Multiplatform
  8. 3. L'architettura fondamentale di Kotlin Multiplatform
  9. 3.1. Obiettivi di compilazione: obiettivi
  10. 3.2. Set sorgente: organizzazione del codice in base alle piattaforme
  11. 3.3. Insiemi sorgenti intermedi
  12. 3.4. Come raccoglie KMP i set sorgente?
  13. 4. Cosa succede sotto il cofano: come il codice Kotlin diventa eseguibile
  14. 4.1. Passaggio 1: Lo sviluppatore scrive il codice comune
  15. 4.2. Passaggio 2: Gradle configura il progetto
  16. 4.3. Passaggio 3: Il compilatore analizza il codice
  17. 4.4. Passaggio 4: Il codice viene compilato per ciascun target
  18. Percorso Android
  19. Percorso iOS
  20. 4.5. Passaggio 5: Il codice condiviso viene eseguito nell'ambiente di destinazione
  21. 5. Come fa il codice condiviso ad accedere alle funzionalità native?
  22. 5.1. Primo approccio: interfacce e iniezione di dipendenze
  23. 5.2. Secondo approccio: `expect` e `actual`
  24. 5.3. Cosa fare e `actual` cosa `expect` non fare
  25. 6. Come comunica Kotlin Multiplatform con Swift?
  26. Esempio concettuale
  27. E se il progetto utilizza SwiftUI?
  28. 7. Quali responsabilità dovrebbero essere condivise in un'architettura KMP?
  29. La logica aziendale
  30. Modelli e casi d'uso
  31. Accesso alla rete
  32. Persistenza dei dati
  33. Test di lavoro
  34. 8. Esempio di architettura di app Android e iOS con KMP
  35. 9. Cosa succede davvero quando un utente utilizza l'app?
  36. Passaggio 1: L'interfaccia recupera i dati
  37. Passaggio 2: L'applicazione chiama la logica condivisa
  38. Passaggio 3: Il livello di rete esegue la query
  39. Passaggio 4: Il server elabora la richiesta
  40. Passaggio 5: Il modulo condiviso elabora il risultato
  41. Passaggio 6: L'interfaccia mostra il risultato
  42. 10. Kotlin Multiplatform è più potente di un framework ibrido?
  43. 11. Quali sono i vantaggi e i limiti di KMP?
  44. I vantaggi
  45. I limiti
  46. 12. Quando dovresti scegliere Kotlin Multiplatform?
  47. Conclusione

Kotlin Multiplatform (KMP): architettura, funzionamento interno e codice condiviso tra Android e iOS

Introduzione

Nello sviluppo mobile, mantenere un'app Android e un'app iOS spesso implica l'evoluzione di due codebase distinte. La stessa regola di business può essere implementata due volte, l'elaborazione può divergere gradualmente e i test devono essere riprodotti su più piattaforme.

È proprio per affrontare questo tipo di problema che Kotlin Multiplatform, generalmente abbreviato come KMP, ha perfettamente senso.

Sviluppato da JetBrains, Kotlin Multiplatform è una tecnologia che consente la condivisione del codice su più piattaforme, inclusi Android, iOS, applicazioni desktop, web e ambienti server, a seconda del pubblico di riferimento e delle librerie utilizzate.

Ma KMP non si tratta solo di scrivere Kotlin una volta per farlo pubblicare ovunque.

Il suo interesse architettonico è più specifico: consente la condivisione di processi che possono essere comuni pur mantenendo la possibilità di utilizzare tecnologie, librerie e API specifiche per ciascuna piattaforma.

Un'app Android può quindi utilizzare le API Kotlin/JVM e Android, mentre un'app iOS può utilizzare lo stesso codice aziendale compilato in codice nativo e integrarlo nei suoi ambienti Swift e Apple.

Questo approccio solleva diverse domande importanti:

  • Come può lo stesso codice Kotlin funzionare su piattaforme diverse?
  • Cosa fa effettivamente il compilatore?
  • Perché il codice condiviso non utilizza liberamente tutte le API di Android o Java?
  • Come può una funzione Kotlin essere chiamata da Swift?
  • Qual è il ruolo di commonMain, androidMain e iosMain ?
  • KMP condivide anche l'interfaccia grafica?
  • Cosa succede esattamente quando compili e avvii un'applicazione?

Per rispondere a queste domande, è necessario esaminare KMP dalla sua architettura al suo funzionamento interno.

1. Cos'è Kotlin Multiplatform?

Kotlin Multiplatform è una tecnologia di sviluppo multipiattaforma che consente di riutilizzare il codice Kotlin su più target di build.

Il principio è semplice: invece di riscrivere sistematicamente le stesse regole di business in ogni applicazione, puoi inserirle in un modulo condiviso.

Immagina un'app di e-commerce disponibile su Android e iOS.

Entrambe le applicazioni devono calcolare il prezzo totale di un carrello, applicare le stesse regole di sconto, validare i dati inseriti e interpretare le risposte del server.

Questi trattamenti possono generalmente essere condivisi, poiché la loro logica non dipende direttamente dal sistema operativo.

Tuttavia, alcune operazioni sono specifiche per ciascuna piattaforma. L'apertura di determinate interfacce di sistema, l'integrazione con le API Apple o la gestione di componenti Android può richiedere codice separato.

KMP consente proprio di separare queste responsabilità.

Esempio semplice

Immaginiamo che l'app debba calcolare il prezzo di un carrello:

Kotlin
data class Product(
    val name: String,
    val price: Double
)

fun calculateTotal(products: List<Product>): Double {
    return products.sumOf { it.price }
}

Questa funzione è scritta in Kotlin e non dipende da una specifica API Android o Apple.

Può quindi essere inserito nel codice comune del progetto.

La stessa elaborazione può essere compilata per gli obiettivi Android e iOS dichiarati nel progetto. Non è necessario riscrivere l'algoritmo in Java o Swift per ottenere lo stesso risultato.

Attenzione: in un'applicazione reale, l'uso per Double calcoli monetari richiede cautela. Una rappresentazione completa in unità monetarie minime o una libreria decimale adeguata è generalmente preferibile.

L'esempio illustra tuttavia il principio fondamentale di KMP: condividere la logica, non necessariamente l'intera applicazione.

2. KMP è un framework di interfaccia grafica?

No. È una distinzione essenziale.

Kotlin Multiplatform consente principalmente la condivisione del codice. Non determina da solo come costruire l'interfaccia grafica.

Devono essere distinte due tecnologie.

Kotlin Multiplatform (KMP) consente la condivisione del codice su più piattaforme.

Compose Multiplatform (CMP) è un framework di interfaccia dichiarativa che consente anche la condivisione dell'interfaccia grafica tra le piattaforme supportate.

Queste tecnologie possono essere usate insieme, ma non significano la stessa cosa.

Con KMP senza interfaccia condivisa

L'app può mantenere un'interfaccia Android sviluppata con Jetpack Compose o le viste Android tradizionali, e un'interfaccia iOS sviluppata con SwiftUI o UIKit.

Entrambe le interfacce utilizzano lo stesso modulo Kotlin per regole di business, validazioni, template e alcune elaborazioni tecniche.

L'architettura appare quindi così:

Plain text
             APPLICATION MOBILE

       ANDROID                 iOS
    ┌─────────────┐      ┌─────────────┐
    │ Interface   │      │ Interface   │
    │ Jetpack     │      │ SwiftUI     │
    │ Compose     │      │ ou UIKit    │
    └──────┬──────┘      └──────┬──────┘
           │                    │
           └─────────┬──────────┘
                     │
             MODULE KMP PARTAGÉ
          ┌──────────────────────┐
          │ Logique métier       │
          │ Validation           │
          │ Modèles              │
          │ Cas d'utilisation    │
          │ Accès aux données    │
          └──────────────────────┘

Le interfacce rimangono specifiche di sistema, ma l'elaborazione comune non viene duplicata.

Con KMP e Compose Multiplatform

È anche possibile condividere una parte significativa dell'interfaccia.

In questo caso, gli schermi e i componenti visivi vengono scritti in Kotlin con Compose Multiplatform, quindi eseguiti sulle piattaforme supportate.

Questo può ridurre ulteriormente la duplicazione del codice dell'interfaccia, ma comporta anche altre considerazioni riguardanti integrazione, rendering, accessibilità ed esperienza utente.

La scelta dipende quindi dal progetto.

KMP consente la condivisione della logica. Compose Multiplatform consente anche la condivisione dell'interfaccia. È possibile adottare uno senza necessariamente adottare l'altro.

3. L'architettura fondamentale di Kotlin Multiplatform

Per capire KMP, bisogna esaminare i diversi livelli che compongono un progetto.

La sua architettura si basa in particolare su build target, set di sorgenti, dipendenze cross-platform e implementazioni specifiche per piattaforma.

3.1. Obiettivi di compilazione: obiettivi

Un target, o target, indica al sistema di compilazione la piattaforma per cui il codice deve essere preparato.

A seconda del progetto e delle versioni degli strumenti utilizzati, è possibile dichiarare target come Android/JVM, iOS, JVM, JavaScript, WebAssembly o alcune piattaforme desktop.

Ogni obiettivo determina in particolare:

  • Il formato del risultato compilato.
  • Le librerie e le API disponibili.
  • Vincoli di compatibilità.
  • Le operazioni di compilazione necessarie.
  • Possibilità di interoperabilità con la piattaforma.

Prendiamo un progetto rivolto ad Android e iOS.

Lo sviluppatore dichiara i target corrispondenti nella configurazione Kotlin Multiplatform.

Il codice comune verrà quindi integrato nella compilazione di ciascun target.

Questo non significa che il compilatore produca un singolo file binario compatibile con Android e iOS. Produce risultati personalizzati in base ai target dichiarati.

Il codice sorgente può essere condiviso, ma gli artefatti compilati differiscono a seconda della piattaforma.

3.2. Set sorgente: organizzazione del codice in base alle piattaforme

Un set sorgente è un insieme di file sorgente associati a target di compilazione e dipendenze.

Questo è uno dei concetti più importanti del KMP.

Un progetto mobile può contenere in particolare i seguenti insiemi sorgente:

Plain text
shared/
└── src/
    ├── commonMain/
    ├── commonTest/
    ├── androidMain/
    ├── androidUnitTest/
    ├── iosMain/
    └── iosTest/

Ogni directory ha un ruolo specifico.

'commonMain'

Contiene codice destinato a essere condiviso tra tutti i target compatibili.

In genere include template, regole di business, casi d'uso, interfacce di servizio e elaborazioni che non dipendono da un'API specifica per la piattaforma.

'commonTest'

Contiene test comuni che possono essere eseguiti sui bersagli interessati.

Consente in particolare la verifica delle regole aziendali e dei comportamenti condivisi.

'androidMain'

Contiene il codice specifico di Android.

Puoi in particolare utilizzare API Android e dipendenze JVM compatibili con la configurazione del progetto.

'iosMain'

Contiene il codice specifico per le piattaforme iOS prese di mira dal progetto.

Permette in particolare l'accesso alle API Apple disponibili tramite Kotlin/Native.

Set specifici di sorgenti di test

Ti permettono di scrivere test che dipendono dagli strumenti o dalle API specifiche di ciascuna piattaforma.

La separazione tra codice comune e codice specifico non è solo una convenzione di storage. Influisce direttamente sulle API utilizzabili e sulle dipendenze disponibili durante la compilazione.

3.3. Insiemi sorgenti intermedi

In un progetto più complesso, la condivisione non riguarda necessariamente tutte le piattaforme.

Immagina un trattamento comune a iOS, macOS e watchOS, ma che utilizza API disponibili solo all'interno dell'ecosistema Apple.

Sarebbe impraticabile duplicare questa elaborazione in ciascun set di sorgenti.

KMP consente quindi l'uso di un set di sorgente intermedio, ad esempio appleMain, per raggruppare codice condiviso tra i target Apple pertinenti.

La gerarchia diventa:

Plain text
commonMain
    │
    ├── androidMain
    │
    └── appleMain
          ├── iosMain
          ├── macosMain
          └── watchosMain

Questo diagramma è illustrativo: la gerarchia effettiva dipende dai target configurati e dai set sorgenti.

Il vantaggio è condividere il codice al livello appropriato, senza imporre artificialmente codice identico su tutte le piattaforme.

3.4. Come raccoglie KMP i set sorgente?

Quando un target viene compilato, il sistema di compilazione seleziona i set sorgente che contribuiscono a quel target, rispettando la loro gerarchia e le loro dipendenze.

Per una build iOS, vengono presi in considerazione il codice comune, il codice sorgente intermedio compatibile e il codice specifico per il target.

Per Android, vengono selezionati il codice comune e le sorgenti destinate al target Android.

Le dipendenze devono inoltre essere compatibili con il pubblico di riferimento.

Pertanto, il compilatore può verificare che un file inserito in commonMain non dipenda direttamente da una classe che esiste solo nell'ambiente Android.

Questa organizzazione rende possibile il code sharing impedendo al contempo che alcune dipendenze incompatibili entrino nel codice comune.

4. Cosa succede sotto il cofano: come il codice Kotlin diventa eseguibile

È qui che KMP diventa particolarmente interessante.

Uno sviluppatore può scrivere una funzione Kotlin in un modulo condiviso, ma questa funzione non funziona necessariamente allo stesso modo su Android e iOS.

La differenza deriva dal processo di compilazione e dall'ambiente di esecuzione di ciascun target.

4.1. Passaggio 1: Lo sviluppatore scrive il codice comune

Immagina che il modulo condiviso contenga questa funzione:

Kotlin
fun calculateDiscount(
    price: Double,
    percentage: Double
): Double {
    return price * percentage / 100.0
}

Questa funzionalità non dipende da alcuna API specifica per Android o iOS.

Può quindi essere compilato per più target compatibili.

Lo sviluppatore scrive la regola una sola volta.

4.2. Passaggio 2: Gradle configura il progetto

In un tipico progetto KMP, Gradle orchestra il processo di costruzione.

La configurazione del progetto include in particolare:

  • I plugin utilizzati.
  • Costruisci bersagli.
  • La sorgente si stabilisce.
  • I edifici annessi.
  • Opzioni di costruzione.
  • Compiti di costruzione e collaudo.

Quando viene chiesto di costruire l'app Android o il framework iOS, Gradle esegue i compiti necessari per preparare gli artefatti corrispondenti.

Non trasforma il codice Kotlin in istruzioni macchina di per sé. Coordina gli strumenti di compilazione e le fasi di costruzione.

4.3. Passaggio 3: Il compilatore analizza il codice

Il compilatore Kotlin analizza i file sorgente, verifica la sintassi e i tipi, quindi prepara una rappresentazione interna del programma per i passaggi successivi.

Controlla inoltre i vincoli relativi alle claim cross-platform e alle API accessibili da ciascun set di sorgenti.

Ad esempio, questo codice non è adatto per commonMain :

Kotlin
import java.io.File

fun readFile(): String {
    return File("message.txt").readText()
}

Il motivo è semplice: java.io.File appartiene all'ambiente Java/JVM. Non è disponibile su tutti i target multiplatform di Kotlin, specialmente sui target nativi iOS.

Se questa operazione deve essere comune, deve essere utilizzata un'astrazione appropriata o una libreria cross-platform. Se è specifica per piattaforma, deve essere implementata nel set di sorgenti appropriato.

Questa verifica è uno dei meccanismi fondamentali di KMP.

4.4. Passaggio 4: Il codice viene compilato per ciascun target

Il compilatore utilizza un backend adattato al target dichiarato.

Per Android, il codice Kotlin viene generalmente compilato in bytecode JVM, quindi integrato nel processo di compilazione di Android.

Per iOS, Kotlin/Native compila il codice Kotlin in binari nativi, utilizzando una build chain basata su LLVM.

I due percorsi sono diversi.

Percorso Android

Plain text
Code Kotlin partagé
        ↓
Compilation Kotlin/JVM
        ↓
Bytecode JVM (.class)
        ↓
Construction de l'application Android
        ↓
DEX / APK ou App Bundle
        ↓
ART sur l'appareil Android

Questo diagramma rappresenta il percorso generale di un'applicazione Android utilizzando Kotlin/JVM.

Il bytecode JVM prodotto da Kotlin viene trasformato e integrato nel formato eseguibile Android. Sul dispositivo, Android Runtime (ART) esegue il codice secondo i meccanismi della piattaforma.

Pertanto, il bytecode JVM non deve essere confuso con il formato DEX utilizzato nelle applicazioni Android.

Percorso iOS

Plain text
Code Kotlin partagé
        ↓
Compilateur Kotlin
        ↓
Backend Kotlin/Native
        ↓
Chaîne de compilation LLVM
        ↓
Binaire natif / framework
        ↓
Intégration dans l'application iOS
        ↓
Exécution sur iPhone ou iPad

Per iOS, il codice Kotlin viene compilato in codice nativo adattato al pubblico di riferimento di Apple.

Non è necessario una macchina virtuale JVM per eseguire il codice Kotlin condiviso.

Il risultato può essere distribuito in particolare come framework nativo integrato nel progetto iOS.

Va notato che gli artefatti e i passaggi esatti dipendono dal bersaglio, dalla configurazione e dalla catena di costruzione utilizzata.

4.5. Passaggio 5: Il codice condiviso viene eseguito nell'ambiente di destinazione

Su Android, il codice condiviso funziona nell'ambiente Android/JVM.

Su iOS, funziona come codice nativo prodotto da Kotlin/Native.

In entrambi i casi, la logica di business può essere identica, ma la sua integrazione tecnica non è la stessa.

È proprio questo che permette a KMP di conciliare il riutilizzo del codice con l'integrazione della piattaforma.

KMP non esegue semplicemente un programma universale in un livello comune: adatta il codice condiviso ai target di compilazione dichiarati.

5. Come fa il codice condiviso ad accedere alle funzionalità native?

Il codice comune non può utilizzare direttamente tutte le API disponibili su Android o iOS.

Prendiamo un'esigenza semplice: recuperare informazioni specifiche per il dispositivo.

Su Android, queste informazioni possono essere ottenute tramite un'API Android. Su iOS, potrebbe essere necessaria un'API Apple.

KMP offre diversi modi per organizzare questa differenza.

5.1. Primo approccio: interfacce e iniezione di dipendenze

Questo è spesso l'approccio più flessibile.

Il codice comune definisce un'interfaccia:

Kotlin
interface DeviceInfoProvider {
    fun getDeviceName(): String
}

Il codice comune può quindi utilizzare questa interfaccia senza conoscere l'implementazione tecnica.

Ogni piattaforma offre una propria implementazione.

Ad esempio, Android può sfruttare alcune API di Android, mentre iOS può utilizzare le API Apple appropriate.

Viene quindi fornita un'implementazione al codice che ne ha bisogno, ad esempio iniettando dipendenze.

Questo approccio facilita anche i test, poiché una implementazione simulata può essere fornita senza accedere a un dispositivo reale.

5.2. Secondo approccio: `expect` e `actual`

Kotlin Multiplatform dispone anche di un meccanismo per dichiarare una funzionalità attesa nel codice comune e fornire un'implementazione specifica per il pubblico di riferimento.

Questo meccanismo si basa sulle parole chiave expect e actual.

In commonMain :

Kotlin
expect fun getPlatformName(): String

Questa istruzione indica che deve essere disponibile un'implementazione appropriata per i target che utilizzano questa funzionalità.

In androidMain :

Kotlin
actual fun getPlatformName(): String {
    return "Android"
}

In iosMain :

Kotlin
actual fun getPlatformName(): String {
    return "iOS"
}

Il codice comune può quindi chiamare la funzione:

Kotlin
fun greeting(): String {
    return "Bonjour depuis ${getPlatformName()}"
}

Il codice aziendale utilizza una sola funzione, ma l'implementazione selezionata dipende dal target compilato.

Questa non è una funzione magica che rileva arbitrariamente il sistema ad ogni chiamata. La corrispondenza tra istruzioni attese e implementazioni è stabilita all'interno del quadro della compilazione cross-platform.

Questo approccio è utile per alcune differenze tra piattaforme. Tuttavia, non dovrebbe essere utilizzato in modo sistematico: un'interfaccia classica è spesso sufficiente e offre maggiore flessibilità nella gestione di più implementazioni.

5.3. Cosa fare e `actual` cosa `expect` non fare

Questi meccanismi non rendono automaticamente disponibili tutte le API Android o Apple in commonMain.

Se un'applicazione deve utilizzare la fotocamera, il Bluetooth o una particolare API di sistema, deve sempre avere un'implementazione adeguata, una libreria compatibile o un meccanismo di interoperabilità appropriato.

expect e actual consentono di organizzare il contratto comune e le sue implementazioni. Non sostituiscono le API di sistema né i permessi necessari.

6. Come comunica Kotlin Multiplatform con Swift?

Questa domanda è particolarmente importante nello sviluppo di un'app iOS.

Kotlin e Swift sono due linguaggi diversi, associati a ambienti di compilazione distinti.

Per utilizzare codice Kotlin condiviso in un'app iOS, il progetto può produrre un framework nativo che espone le istruzioni Kotlin necessarie.

Il progetto iOS può quindi integrare questo framework e chiamare gli elementi che esposso.

Il processo generale è il seguente:

  1. Lo sviluppatore scrive il codice condiviso in Kotlin.
  2. Kotlin/Native compila questo codice per il target Apple.
  3. Il processo di build produce un framework o un altro artefatto nativo adatto all'integrazione.
  4. Il progetto iOS fa riferimento a questo artefatto.
  5. Swift richiama le API esposte dal framework.

L'interoperabilità si basa su meccanismi nativi forniti dall'ecosistema Apple, in particolare le interfacce Objective-C utilizzate per esporre il framework Kotlin ai progetti Swift.

Tuttavia, non si deve presumere che ogni dichiarazione Kotlin diventi automaticamente un'API Swift perfettamente idiomatica. Bisogna tenere conto della visibilità delle dichiarazioni, dei tipi esposti e della rappresentazione dell'API.

Esempio concettuale

Il modulo condiviso definisce:

Kotlin
class PriceCalculator {
    fun calculate(price: Double, tax: Double): Double {
        return price * (1.0 + tax / 100.0)
    }
}

Una volta compilato e integrato nel progetto iOS, Swift può utilizzare il tipo esposto dal framework per eseguire il calcolo.

Il vantaggio è che la regola di calcolo viene mantenuta in Kotlin, mentre l'interfaccia e il resto dell'app iOS possono rimanere scritti in Swift.

Il nome esatto dei simboli accessibili da Swift dipende dalla configurazione del framework e dalle regole di interoperabilità.

E se il progetto utilizza SwiftUI?

È del tutto possibile.

SwiftUI può rimanere responsabile dell'interfaccia. Il codice Swift chiama quindi il modulo condiviso per eseguire l'elaborazione aziendale.

Ad esempio, una schermata SwiftUI può recuperare i prodotti inseriti dall'utente, chiamare il calcolatore Kotlin e mostrare il totale ottenuto.

L'interfaccia rimane nativa dell'ecosistema Apple, mentre la logica di calcolo è condivisa.

Questo è uno dei modelli di architettura più interessanti di KMP: condividere codice che beneficia della condivisione senza imporre un'unica interfaccia su tutte le piattaforme.

7. Quali responsabilità dovrebbero essere condivise in un'architettura KMP?

Una buona architettura KMP non consiste nello spostare tutti i file in un modulo comune.

È necessario determinare quali responsabilità possano effettivamente essere condivise.

Per un'app mobile, i seguenti sono spesso buoni candidati.

La logica aziendale

Regole di calcolo, validazioni, politiche di prezzo e regole di gestione possono essere condivise quando non dipendono da una piattaforma.

Questo aiuta a evitare discrepanze tra le versioni Android e iOS.

Modelli e casi d'uso

Gli oggetti aziendali, i risultati operativi e i casi d'uso possono essere comuni.

Un'applicazione commerciale può, ad esempio, condividere le regole che determinano se un carrello può essere validato.

Accesso alla rete

Le richieste HTTP, i modelli dati e alcune operazioni di serializzazione possono essere condivisi utilizzando librerie compatibili con i target pertinenti.

Ktor è un esempio di libreria multipiattaforma per costruire client di rete.

Tuttavia, il codice comune non dovrebbe essere considerato automaticamente compatibile con alcuna libreria Java. Le dipendenze devono supportare i target per cui il modulo è destinato.

Persistenza dei dati

È inoltre possibile condividere parte dell'accesso ai dati locali con biblioteche multipiattaforma appropriate.

Tuttavia, devono essere valutate la compatibilità della libreria, le differenze di archiviazione e i vincoli di ciascun sistema.

Test di lavoro

I test di regole comuni possono essere scritti una sola volta ed eseguiti sui target rilevanti.

Questo rende più facile rilevare le discrepanze e rafforzare l'affidabilità del codice condiviso.

D'altra parte, i test di integrazione con la telecamera, le notifiche o le API di sistema devono tenere conto dei comportamenti specifici di ciascuna piattaforma.

8. Esempio di architettura di app Android e iOS con KMP

Immagina che stessimo sviluppando un'applicazione di messaggistica.

L'obiettivo è condividere regole di business e scambi di rete mantenendo interfacce adatte per Android e iOS.

Una possibile architettura sarebbe:

Plain text
                    APPLICATION MOBILE
                            │
              ┌─────────────┴─────────────┐
              │                           │
          ANDROID                       iOS
              │                           │
       Jetpack Compose                 SwiftUI
              │                           │
              └─────────────┬─────────────┘
                            │
                    MODULE KMP PARTAGÉ
                            │
              ┌─────────────┴─────────────┐
              │                           │
         Logique métier              Couche données
              │                           │
       Cas d'utilisation            Client HTTP
       Validation                   Sérialisation
       Modèles                      Repository
              │                           │
              └─────────────┬─────────────┘
                            │
                      API distante

In questa architettura:

  • Android mantiene la propria interfaccia e integrazione specifiche per Android.
  • iOS mantiene la sua interfaccia e integrazione specifiche per Apple.
  • Il modulo KMP centralizza le regole comuni.
  • Il livello di rete aggrega operazioni compatibili.
  • Il server mantiene la responsabilità dei dati e dell'elaborazione che gli appartengono.

Va notato che uno schema del genere è una possibilità architettonica, non una struttura imposta dal KMP.

Un progetto può condividere più componenti, inclusa l'interfaccia grafica con Compose Multiplatform, oppure, al contrario, limitare il modulo comune a poche regole di business.

L'importante è definire chiaramente le responsabilità di ciascun livello.

9. Cosa succede davvero quando un utente utilizza l'app?

Per capire come funziona oltre la compilazione, prendiamo un esempio di connessione a un'applicazione.

L'utente inserisce il proprio indirizzo email e password, quindi preme il pulsante di login.

Passaggio 1: L'interfaccia recupera i dati

Su Android, lo schermo può essere sviluppato con Jetpack Compose.

Su iOS, può essere sviluppato con SwiftUI.

Ogni interfaccia raccoglie le informazioni inserite e attiva l'azione di connessione.

Passaggio 2: L'applicazione chiama la logica condivisa

L'interfaccia trasmette i dati al componente responsabile della connessione.

Questo componente può essere scritto in Kotlin nel modulo KMP.

Applicano validazioni comuni, preparano l'operazione e coordinano l'accesso ai dati.

Passaggio 3: Il livello di rete esegue la query

Se il modulo condiviso utilizza una libreria multipiattaforma come Ktor, può inviare una richiesta HTTP al server.

Il motore di rete utilizzato dipende dalla piattaforma e dalla configurazione del client.

Il codice commerciale può rimanere comune anche se i meccanismi tecnici utilizzati sotto il cofano differiscono.

Passaggio 4: Il server elabora la richiesta

Il server verifica le informazioni secondo le sue regole di sicurezza e restituisce un risultato.

La validazione lato client migliora l'esperienza utente, ma non sostituisce mai la validazione lato server.

Passaggio 5: Il modulo condiviso elabora il risultato

Il codice Kotlin interpreta la risposta, trasforma i dati ed espone un risultato all'applicazione.

Le regole comuni possono quindi rimanere coerenti tra Android e iOS.

Passaggio 6: L'interfaccia mostra il risultato

Android e iOS presentano il risultato con i rispettivi componenti.

L'utente può quindi beneficiare di un'esperienza su misura per ciascuna piattaforma, anche se parte dell'elaborazione è stata scritta solo una volta.

Questo esempio illustra il valore di KMP: condividere trattamenti senza forzare tutti i livelli a essere identici.

10. Kotlin Multiplatform è più potente di un framework ibrido?

Occorre distinguere diversi aspetti: tempo di esecuzione, accesso al sistema, rendering dell'interfaccia e velocità di sviluppo.

KMP consente di compilare codice condiviso in base ai meccanismi della piattaforma target. Su Android, il codice Kotlin/JVM si integra nell'ambiente Android. Su iOS, Kotlin/Native produce codice nativo.

Questa architettura evita la necessità di eseguire tutta la logica condivisa in una macchina virtuale Java su iOS.

Tuttavia, ciò non significa che KMP sia automaticamente più veloce di tutti i framework ibridi o multipiattaforma.

Le prestazioni dipendono in particolare da:

  • Dell'algoritmo utilizzato.
  • Gestione della memoria.
  • Accesso alla rete e al disco.
  • Librerie utilizzate.
  • Architettura applicativa.
  • Il modo in cui viene renderizzata l'interfaccia.
  • Caratteristiche dei dispositivi target.

KMP va inoltre distinto da un framework che fornisce un'interfaccia grafica multipiattaforma. Quando si utilizza Compose Multiplatform, il rendering e l'integrazione con l'interfaccia sono questioni separate dalla compilazione di codice aziendale.

Il principale vantaggio architettonico di KMP è quindi la possibilità di condividere codice mantenendo al contempo un'integrazione adeguata alla piattaforma. Le prestazioni devono essere misurate rispetto alle operazioni effettive del progetto.

11. Quali sono i vantaggi e i limiti di KMP?

I vantaggi

Ridurre la duplicazione del codice

Le regole di business e i trattamenti comuni non devono necessariamente essere riscritti per ogni piattaforma.

Coerenza funzionale

Le app Android e iOS possono utilizzare le stesse regole di validazione e gli stessi algoritmi aziendali.

Conservazione delle tecnologie native

I team possono mantenere le visualizzazioni Jetpack Compose o Android su Android, e SwiftUI o UIKit su iOS.

Integrazione graduale

È possibile introdurre KMP in un progetto esistente partendo da un modulo limitato, senza riscriversi immediatamente l'intera applicazione.

Test comuni

Le regole di business condivise possono essere testate in modo coerente tra gli obiettivi rilevanti.

Flessibilità architettonica

Il progetto può condividere solo elementi che apportano un reale valore, senza imporre una base di codice completamente comune.

I limiti

Complessità costruttiva

La configurazione Gradle, i target, le dipendenze e le catene di build possono rendere il progetto più complesso rispetto a un'applicazione a piattaforma singola.

Interoperabilità con iOS

L'integrazione tra Kotlin/Native e Swift richiede la comprensione delle regole di esposizione delle API e dei vincoli dell'ecosistema Apple.

Disponibilità della biblioteca

Non tutte le librerie Kotlin o Java sono compatibili con tutti i target KMP.

Gestione delle specifiche del sistema

Alcune funzionalità richiedono ancora codice specifico per Android o iOS.

Condivisione non automatica dell'interfaccia

KMP non significa che gli schermi siano condivisi automaticamente. Per questo, è necessario adottare una soluzione di interfaccia multipiattaforma come Compose Multiplatform.

Compromessi architettonici

La condivisione del codice non è sempre vantaggiosa. Un'interfaccia, una funzionalità o un componente fortemente dipendente dal sistema può essere più facile da mantenere quando rimane specifico per la piattaforma.

12. Quando dovresti scegliere Kotlin Multiplatform?

KMP è particolarmente interessante quando un team vuole condividere parte della logica tra Android e iOS mantenendo al contempo la padronanza delle tecnologie specifiche di ciascuna piattaforma.

È particolarmente adatto per progetti che dispongono già di applicazioni native e desiderano ridurre la duplicazione dei processi aziendali.

Può anche essere adattato a una nuova applicazione quando i team vogliono centralizzare le regole aziendali, l'accesso alla rete e alcuni componenti tecnici.

D'altra parte, se l'obiettivo principale è sviluppare un'unica interfaccia per più piattaforme, Compose Multiplatform e altri framework di interfaccia multipiattaforma dovrebbero essere valutati.

La scelta dipende quindi dal livello di condivisione desiderato.

Un team può decidere di condividere solo i modelli e le regole aziendali, per poi estendere gradualmente KMP all'accesso alla rete, alla persistenza e ad altri componenti.

Questa progressione permette di misurare i benefici reali prima di aumentare la complessità del progetto.

Conclusione

Kotlin Multiplatform è molto più di un semplice modo per scrivere codice Kotlin riutilizzabile. È una tecnologia che permette di organizzare la condivisione del codice per piattaforma, compilare componenti comuni per diversi ambienti e mantenere l'accesso alle API specifiche di ciascun sistema.

La sua architettura si basa in particolare su target di compilazione, set di sorgenti, dipendenze compatibili, meccanismi di interoperabilità e, quando necessario, implementazioni specifiche.

Sotto il coperto, il codice condiviso segue un percorso di build adattato a ciascuna piattaforma: Kotlin/JVM per l'ambiente Android/JVM e Kotlin/Native per target nativi come iOS.

Il codice comune quindi non diventa un binario universale. Viene integrato in artefatti adattati alle piattaforme target.

È proprio questo approccio che consente di combinare il riutilizzo del codice, flessibilità architetturale e integrazione nativa.

In definitiva, il punto di forza di Kotlin Multiplatform non è eliminare tutte le differenze tra Android e iOS. Sta nel condividere in modo intelligente ciò che può essere condiviso mantenendo la libertà di sfruttare le specificità di ciascuna piattaforma.

Commenti (0)

Devi aver effettuato l'accesso per lasciare un commento.

Accedi

Ancora nessun commento. Sii il primo a dire la tua!