SDK och ramverk i mobilutveckling: vad de är, vilka typer som finns och hur man väljer

UI-ramverk för mobilutveckling: UIKit, SwiftUI, Jetpack Compose

UI-ramverk bestämmer utseende och beteende hos användargränssnittet. UIKit är huvudramverket för iOS, i bruk sedan 2008 och stöder alla iOS-versioner. SwiftUI är ett mer modernt deklarativt ramverk som introducerades 2019. Att välja UI-ramverk är det första beslutet när man startar mobilutveckling.

SwiftUI vs UIKit

SwiftUI använder ett deklarativt tillvägagångssätt: du beskriver hur gränssnittet ska se ut och ramverket hanterar uppdateringar. SwiftUI minskar kod för enkla skärmar med 2–3 gånger jämfört med UIKit och stöder automatiskt mörkt läge, Dynamic Type och tillgänglighet.

UIKit är ett imperativt ramverk med finare kontroll. UIKit förblir valet för komplexa anpassade gränssnitt och appar som stöder iOS 12 och äldre. Många produktionsappar använder en hybridmetod: UIKit för komplexa skärmar, SwiftUI för nya funktioner.

Jetpack Compose är Googles deklarativa UI-ramverk för Android, liknande SwiftUI. Compose använder Kotlin-kod istället för XML, vilket snabbar upp utveckling och minskar buggar. Det är kompatibelt med befintliga View-baserade appar via AndroidView och ComposeView.

Jetpack är en samling Android-bibliotek som inkluderar Jetpack Compose, Navigation, Room, WorkManager och andra. Jetpack löser vanliga Android-utvecklingsuppgifter — från navigering till bakgrundsuppgifter — via ett enhetligt API med bakåtkompatibilitet.

Exempel på en enkel skärm i Jetpack Compose:

@Composable
fun Greeting(name: String) {
    Column(
        modifier = Modifier.padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "Hello, $name!",
            style = MaterialTheme.typography.h4
        )
        Button(onClick = { /* handle click */ }) {
            Text("Click me")
        }
    }
}

Plattformsoberoende SDK: Flutter, React Native, Xamarin

Plattformsoberoende SDK för mobilutveckling gör det möjligt att skriva en kodbas för iOS och Android. Att välja ett plattformsoberoende SDK kan spara 30–50% av utvecklingsbudgeten, men kräver kompromisser i prestanda och tillgång till inbyggda API:er.

Flutter vs React Native

Flutter från Google levererar bättre prestanda tack vare sin anpassade Skia-renderingsmotor. Flutter är idealiskt för projekt med rik animation och anpassad design. React Native passar bättre för team med JavaScript-erfarenhet och för appar med enkla gränssnitt.

Kotlin Multiplatform Mobile (KMM) är ett alternativt tillvägagångssätt där delad kod skrivs i Kotlin medan UI är inbyggt. KMM gör det möjligt att dela affärslogik, nätverk och modeller mellan iOS och Android med bibehållen inbyggd UX för varje plattform. Det är IT Sectrs val för enterprise-projekt.

Ionic och Apache Cordova använder WebView för rendering. WebView-metoden ger sämre prestanda och UI, men låter webbutvecklare använda JS/HTML/CSS. Lämplig för enkla wrapper-appar över webbplatser.

DI-ramverk: Dagger/Hilt, Koin, Swinject

Beroendeinjektion (DI) är ett mönster där beroenden skickas till ett objekt utifrån. Inom mobilutveckling automatiserar DI-ramverk skapandet och injiceringen av beroenden, vilket gör koden mer testbar och underhållbar.

Dagger/Hilt för Android

Dagger är det mest populära DI-ramverket för Android, som använder kodgenerering. Dagger/Hilt är Googles officiella DI-bibliotek för Android, byggt ovanpå Dagger. Hilt förenklar Dagger-konfigurationen och integreras automatiskt med Jetpack-komponenter.

Koin är ett DI-ramverk för Kotlin utan kodgenerering. Koin är enklare att konfigurera men fungerar långsammare under initiering på grund av avsaknad av kompileringskontroller. Lämplig för små projekt där konfigurationshastighet är viktigare än prestanda.

Exempel på konfiguration av en modul i Koin:

val appModule = module {
    single { ApiService() }
    factory { Repository(get()) }
    viewModel { MainViewModel(get()) }
}

fun main() {
    startKoin {
        modules(appModule)
    }
}

Swinject är ett DI-ramverk för Swift med ett enkelt API. Swinject stöder konstruktorinjektion, egenskapsinjektion och metodinjektion via en Service Container. Det integreras med UIKit och SwiftUI via SwinjectStoryboard och SwinjectAutoregistration.

Valet av DI-ramverk beror på plattform och projektstorlek. För Android-projekt rekommenderar IT Sectr Hilt, för iOS — Swinject, för Kotlin Multiplatform — Koin på grund av minimal konfigurationsoverhead.

Nätverksbibliotek: Retrofit, Alamofire, Ktor

Nätverksbibliotek för mobilutveckling förenklar arbete med HTTP-förfrågningar och REST API:er. Retrofit (Android/Kotlin) är den mest populära HTTP-klienten för JVM med typade gränssnitt. Den serialiserar/deserialiserar automatiskt JSON via OkHttp och omvandlare (Gson, Moshi, Kotlinx Serialization).

Alamofire är standard HTTP-klient för iOS/macOS i Swift. Alamofire tillhandahåller ett kedjbart API, automatisk sessionshantering, svarsvalidering och felhantering. En grundläggande HTTP-förfrågan i Alamofire ser ut som en rad kod.

Ktor Client är en plattformsoberoende HTTP-klient från JetBrains. Ktor körs på JVM, iOS, macOS, Windows, Linux och JavaScript med ett enhetligt API. Utmärkt för KMM-projekt där delad kod måste fungera på båda plattformarna.

RxSwift och RxJava är bibliotek för reaktiv programmering. Rx-bibliotek används för komplexa asynkrona operationer — kombinera nätverksförfrågningar, debounce, throttle, sammanfoga dataströmmar. Combine är Apples moderna alternativ för Swift.

Bildladdning: Glide, Coil, Kingfisher

Bildladdningsbibliotek inom mobilutveckling löser tre uppgifter: asynkron laddning, cachning och visning. Glide är standard för Android, använt i miljontals appar. Stöder GIF, videoramar, animationer, automatisk cachning i minne och på disk.

Coil (Coroutine Image Loader) är ett modernt alternativ till Glide för Kotlin. Coil är 30% snabbare än Glide vid första laddning och fungerar med coroutines (suspend functions, Flow). Använder OkHttp för nätverk och stöder SVG, GIF direkt ur lådan.

Kingfisher är det ledande biblioteket för iOS skapat av en enskild utvecklare. Kingfisher stöder cachning, platshållare, förloppsindikatorer, felhantering och övergångsanimationer. SDWebImage är ett äldre men fortfarande populärt alternativ med stor community.

Lottie är ett bibliotek för att rendera After Effects-animationer i realtid. Lottie spelar vektoranimationer från JSON-filer utan kvalitetsförlust och med minimal filstorlek. Stöder färgväxling, hastighet, förlopp och loopning.

Spelmotorer: Unity, Unreal Engine

För mobilspelsutveckling används specialiserade SDK och motorer. Unity är den mest populära spelmotorn för mobila plattformar, som driver över 50% av alla mobilspel. Den använder C# och stöder iOS, Android, WebGL och skrivbord.

Unreal Engine fokuserar på fotorealistisk grafik. Unreal Engine 5 använder Nanite (virtuell geometri) och Lumen (dynamisk belysning), vilket ger konsolkvalitet på mobila enheter. Kräver kraftfullare hårdvara och erfarenhet av C++.

SpriteKit och SceneKit är inbyggda 2D- och 3D-motorer från Apple för iOS/macOS. SpriteKit är optimerat för 2D-spel med minimal batteriförbrukning och idealiskt för casualspel. SceneKit hanterar 3D-scener med fysik, belysning och animation.

Metal (Apple) och Vulkan (plattformsoberoende) är lågnivågrafik-API:er. Metal ger maximal prestanda på Apple-enheter, Vulkan på Android och skrivbord (liknande DirectX 12 för Windows). OpenGL ES är föråldrat men används fortfarande för äldre enheter.