20 häufig gestellte Interviewfragen für Mobile Developers. Mobile Entwicklung ist ein gefragtes Feld für zuverlässige iOS-, Android- und Cross-Platform-Apps und behandelt Produkt-, Performance-, Release-, Offline- und Geräteintegrationsaufgaben. Die Fragen decken verschiedene Niveaus ab, und du kannst mündliche Antworten in unserem Interview-Trainer üben.
1Was ist der Unterschied zwischen dem Speichern eines Authentifizierungs-Tokens in einem standardmäßigen Key-Value-Speicher wie SharedPreferences oder UserDefaults und einem sicheren Plattform-Speicher wie dem Android Keystore oder der iOS Keychain?
SharedPreferences und UserDefaults sind Einstellungsspeicher und keine speziellen Geheimnisspeicher. Ihre Dateien sind durch die Anwendungs-Sandbox und die jeweils geltenden Speicherschutzmechanismen des Betriebssystems geschützt; die Einstellungs-APIs ergänzen jedoch keine spezielle Verschlüsselung oder Zugriffsrichtlinien für Geheimnisse. Die iOS Keychain speichert Geheimnisse wie Tokens mit konfigurierbaren Richtlinien für Zugänglichkeit, Synchronisierung und Zugriffskontrolle. Android Keystore speichert kryptografische Schlüssel und führt damit Operationen aus, statt beliebige Token-Zeichenfolgen aufzunehmen. Eine App kann einen Token mit einem vom Keystore verwalteten Schlüssel verschlüsseln und den Geheimtext separat speichern. Keystore-Schlüssel können je nach Gerät, Algorithmus und Konfiguration software- oder hardwaregestützt sein. Prüfen Sie das Sicherheitsniveau, statt eine vertrauenswürdige Ausführungsumgebung (TEE) oder StrongBox vorauszusetzen. Hardwaregestützte Schlüssel können nicht exportierbar bleiben; entschlüsselte Tokens gelangen dennoch in den Anwendungsspeicher, und ein kompromittiertes Gerät beziehungsweise eine kompromittierte App kann autorisierte Operationen missbrauchen. Wählen Sie Sicherungs- und Authentifizierungsrichtlinien bewusst.
// --- ANDROID ---
// INSECURE (Plain SharedPreferences):
val prefs = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
prefs.edit().putString("auth_token", token).apply() // Plaintext XML on disk
// SECURE (EncryptedSharedPreferences backed by Android Keystore):
val masterKey = MasterKey.Builder(context)
.setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
.build()
val securePrefs = EncryptedSharedPreferences.create(
context,
"secure_prefs",
masterKey,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
securePrefs.edit().putString("auth_token", token).apply()
// --- IOS (Swift) ---
// INSECURE:
UserDefaults.standard.set(token, forKey: "auth_token") // Plain plist on disk
// SECURE (Keychain Services API):
let query: [String: Any] = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String: "user_auth_token",
kSecValueData as String: token.data(using: .utf8)!,
kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlocked
]
SecItemAdd(query as CFDictionary, nil)
2Wozu dient eine Pipeline für kontinuierliche Integration und Auslieferung (CI/CD) bei mobilen Apps? Was unterscheidet sie von der Bereitstellung im Web oder Backend?
Die Pipeline prüft Änderungen automatisch und erzeugt reproduzierbare, signierte App-Pakete für Testgruppen oder Stores. Neben statischen Prüfungen und Unit-Tests gehören je nach App Tests auf Simulatoren oder Geräten, Versionsverwaltung und sichere Signierung dazu. Die Toolchain muss zur Plattform passen, etwa Xcode auf macOS für den iOS-Build. Bei der Verteilung sind Freigabeverfahren und Aktualisierungsverhalten der Geräte zu berücksichtigen. Ein gestoppter Rollout entfernt eine bereits installierte Version nicht. Korrekturen brauchen oft ein neues signiertes Paket. Serverseitige Schalter können nur Verhalten begrenzen, das die installierte App dafür vorgesehen hat.
name: Mobile CI/CD Workflow
on:
pull_request:
branches: [main]
push:
tags:
- 'v*.*.*'
jobs:
ci_validation:
name: Lint & Unit Tests
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Run Linter
run: ./gradlew lint
- name: Run Unit Tests
run: ./gradlew testDebugUnitTest
cd_release_ios:
name: Build & Distribute iOS
needs: ci_validation
if: startsWith(github.ref, 'refs/tags/v')
runs-on: macos-14
steps:
- uses: actions/checkout@v4
- name: Install Signing Certificates
run: fastlane match appstore --readonly
- name: Build & Upload to TestFlight
run: fastlane ios beta
3Warum trennt man in einer plattformübergreifenden App Präsentation, Fachlogik und Datenzugriff, und wie erleichtert das gemeinsame Implementierungen für iOS und Android?
Die Präsentationsschicht zeigt Inhalte an und verarbeitet Eingaben und Bildschirmzustand. Die Domänenschicht enthält Fachregeln und Anwendungsfälle. Die Datenschicht liest und schreibt Daten aus Schnittstellen, lokalen Datenbanken oder Caches. Wenn Fachlogik nicht von konkreten Plattformklassen abhängt, kann sie auf beiden Systemen unverändert verwendet und separat getestet werden. Auch Teile des Datenzugriffs lassen sich teilen, sofern Bibliotheken und Schnittstellen auf beiden Plattformen passen. Für plattformspezifische Speicherung oder Oberflächen kannst du getrennte Implementierungen hinter gemeinsamen Verträgen behalten. Wie viel Code geteilt wird, hängt von Anforderungen und Werkzeugen ab.
[Presentation Layer] (UI, Screens, ViewModels)
│
▼ calls
[Domain Layer] (Use Cases, Business Rules, Entities)
▲
│ implements interfaces
[Data Layer] (Repositories, API Clients, Local Storage)
4Worin unterscheiden sich imperative und deklarative Oberflächen, und wie setzen Flutter und React Native den deklarativen Ansatz um?
Imperativ änderst du konkrete Elemente, etwa indem du Text setzt oder eine Ansicht ausblendest. Deklarativ beschreibst du, welche Oberfläche zu den aktuellen Eingaben und zum Zustand gehört. Das Framework ermittelt daraus die nötigen Änderungen. In Flutter liefert `build` unveränderliche Widget-Beschreibungen, die mit bestehenden Elementen abgeglichen werden. In React Native geben Komponenten eine Elementbeschreibung zurück, oft als JSX. React gleicht neue und bisherige Beschreibungen ab und aktualisiert die entsprechenden Plattformansichten. In beiden Fällen kann Anwendungslogik weiterhin Ereignisse verarbeiten; die Darstellung wird aus dem Zustand abgeleitet.
5Was unterscheidet Kaltstart, Warmstart und Hotstart einer mobilen App, und warum ist der Kaltstart für Leistungsziele besonders wichtig?
Beim Kaltstart muss das System den Prozess neu starten und die App sowie ihren ersten Bildschirm initialisieren. Bei einem Warmstart ist ein Teil des vorherigen Zustands vorhanden; etwa kann der Prozess noch laufen, während die Ansicht neu erstellt wird. Beim Hotstart kann eine noch vorhandene Ansicht in den Vordergrund zurückkehren. Die genaue Einordnung hängt von Plattform und Messwerkzeug ab. Der Kaltstart enthält meist die meiste Initialisierungsarbeit und prägt den ersten Eindruck. Miss die Zeit bis zum ersten sichtbaren Bild und bis zur tatsächlichen Bedienbarkeit unter repräsentativen Bedingungen. Berücksichtige auch häufige Warm- und Hotstarts; ein langsamer Kaltstart führt nicht automatisch zu einer schlechteren Store-Platzierung.
6Was ist eine native Bridge in einer plattformübergreifenden mobilen App, und wann sollte man eine solche verwenden, anstatt das Feature vollständig in Flutter oder React Native zu schreiben?
Eine native Bridge ist die Kommunikationsschicht, die es plattformübergreifendem Code ermöglicht, plattformspezifischen iOS- oder Android-Code aufzurufen, und nativem Code erlaubt, Ergebnisse zurückzugeben oder Events zu senden. In Flutter geschieht dies üblicherweise über Platform Channels oder Plugins. In React Native wird dies meist über Native Modules, TurboModules oder native UI-Komponenten umgesetzt. Eine Bridge kommt zum Einsatz, wenn ein Feature etwas benötigt, worauf reiner Flutter- oder React-Native-Code nicht ausreichend zugreifen kann, wie etwa eine Plattform-API, eine Gerätefunktion, ein natives SDK (Software Development Kit), eine leistungskritische native Implementierung oder eine native UI-Komponente. Typische Beispiele sind Kamerafunktionen, Bluetooth, Push-Benachrichtigungen, Zahlungsabwicklungen, sichere Speicher, Hintergrunddienste, Health-APIs oder SDKs, die ausschließlich Swift/Objective-C- oder Kotlin/Java-Integrationen bereitstellen. Eine gute Bridge stellt der plattformübergreifenden Schicht in der Regel eine schlanke, klare API bereit, wie getBatteryLevel, startBluetoothScan oder openNativePaymentSheet, während die plattformspezifische Implementierung die eigentlichen iOS- und Android-Details verarbeitet.
7Was bedeutet Offline-First bei mobilen Apps, und wie unterscheidet es sich vom Zwischenspeichern von HTTP-Antworten?
Eine Offline-First-App kann wichtige Abläufe mit lokal gespeicherten Fachdaten auch ohne Verbindung ausführen. Sie liest etwa aus einer lokalen Datenbank und legt unterstützte Änderungen dauerhaft für eine spätere Synchronisierung ab. Der Server kann weiterhin über die endgültige Annahme und gemeinsame Daten entscheiden. Die App muss ausstehende Änderungen und Konflikte behandeln. Ein HTTP-Cache speichert nach HTTP-Regeln wiederverwendbare Antworten für spätere Anfragen. Er ist vor allem eine Leseoptimierung und stellt von sich aus weder eine dauerhafte Warteschlange für lokale Änderungen noch einen fachlichen Abgleich bereit.
/* Network-First with HTTP Caching */
UI -> Network Request -> [Cache Hit ? Return Cached JSON : Fetch from API -> Save to HTTP Cache] -> UI
// Limitation: Read-only optimization; offline writes fail immediately.
/* Offline-First with Local Source of Truth */
UI <-> Observes Local DB (e.g., Room / Core Data / SQLite)
User Write -> Write to Local DB -> Queue Sync Task
Sync Worker (Background) -> Send queued mutations to Server -> Update Local DB with Server Response
8Worin unterscheiden sich lokale und entfernte Push-Benachrichtigungen einer mobilen App?
Eine lokale Benachrichtigung wird auf dem Gerät erzeugt oder geplant, etwa als Erinnerung zu einer Uhrzeit. Sie braucht für die Zustellung keinen Server und keine Internetverbindung. Eine entfernte Push-Benachrichtigung geht vom Server über einen Pushdienst an das Gerät, etwa wenn eine neue Chatnachricht vorliegt. Ob das System etwas anzeigt oder der App Hintergrundarbeit erlaubt, hängt von Nachrichtentyp, Berechtigungen und Systemzustand ab. Zustellung und Ausführungszeit sind nicht garantiert. Verwende Push als Hinweis auf neue Daten; die App kann den maßgeblichen Stand anschließend vom Server abrufen.
let content = UNMutableNotificationContent()
content.title = "Workout Reminder"
content.body = "Time for your daily exercise routine."
content.sound = .default
// Triggers locally after 1 hour (3600 seconds) without any server interaction
let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 3600, repeats: false)
let request = UNNotificationRequest(identifier: "dailyWorkout", content: content, trigger: trigger)
UNUserNotificationCenter.current().add(request) { error in
if let error = error {
print("Failed to schedule notification: \(error)")
}
}
9Worin unterscheiden sich Android App Bundle (AAB), APK und IPA bei der Verteilung mobiler Apps?
Ein APK enthält Android-Code und Ressourcen und lässt sich bei passender Signatur und Gerätekompatibilität installieren. Ein APK kann für viele Geräte oder nur für eine Konfiguration gebaut sein. Ein AAB dient zur Veröffentlichung. Es enthält die Module, aus denen Google Play passende Basis-, Funktions- und Konfigurations-APKs erzeugt und signiert. Ein AAB lässt sich nicht direkt installieren; für lokale Tests kann ein Werkzeug daraus installierbare APKs erzeugen. Eine IPA-Datei ist ein Paket mit einer iOS-App. Eine direkte Testinstallation setzt eine dafür geeignete Signierung und Provisionierung voraus. Für den App Store läuft die Verteilung über App Store Connect; der Store kann gerätespezifische Varianten ausliefern.
# 1. Standalone APK installs directly via ADB
adb install myapp-universal.apk
# 2. AAB requires bundletool to generate device-tailored split APKs
bundletool build-apks --bundle=myapp.aab --output=myapp.apks --connected-device
# 3. Install the generated split APK set onto the connected device
bundletool install-apks --apks=myapp.apks
10Welchen Schutz bietet TLS (Transportschichtsicherheit) für Netzwerkverbindungen einer mobilen App, und wie unterstützen iOS und Android sichere Standardeinstellungen?
TLS verschlüsselt übertragene Daten, erkennt Änderungen unterwegs und authentifiziert den Server, wenn die App Zertifikat und Servernamen korrekt prüft. Auf iOS verlangt App Transport Security (ATS) bei Standardverbindungen über das URL Loading System, etwa mit URLSession, grundsätzlich HTTPS und mindestens TLS 1.2. Auf Android ist Klartextverkehr bei Apps mit Ziel-API 28 oder höher standardmäßig deaktiviert, sofern der verwendete Netzwerkstack diese Richtlinie berücksichtigt. Ausnahmen hängen von der App-Konfiguration ab. Verwende für sensible Daten HTTPS und prüfe die tatsächliche Konfiguration und das Verhalten der eingesetzten Bibliothek.
11Welche Aufgaben haben RTSP, RTMP und HLS bei der Videoübertragung?
RTSP steuert Sitzungen, etwa Setup, Play und Pause; Mediendaten laufen oft über RTP. RTMP bündelt Medien und Steuerung auf einer dauerhaften Verbindung, häufig vom Sender zum Ingest-Server. HLS verwendet HTTP-Wiedergabelisten und Segmente oder Teilsegmente und ermöglicht CDN-Auslieferung und adaptive Bitraten. Man kann RTMP entgegennehmen, mehrere Qualitätsstufen transkodieren, als HLS verpacken und per HTTP verteilen. Kameras können stattdessen RTSP/RTP einspeisen. Das sind typische Rollen, keine Codecs oder ausschließlichen Möglichkeiten. Die Gesamtlatenz hängt auch von Kodierung, Segmentlänge, Pufferung und Netz ab.
12Wie erkennt ein DLNA-Kontrollpunkt, dass ein Wiedergabegerät offline ist, und wie stellt er die Verbindung wieder her?
Ich verarbeite SSDP-byebye-Meldungen und lasse Einträge nach ihrer angekündigten Lebensdauer verfallen. Wiederholte Transportfehler oder fehlgeschlagene Aboverlängerungen sind weitere Hinweise; ein verlorenes Paket soll die Auswahl nicht löschen. Die Oberfläche kennzeichnet das Gerät als unerreichbar, begrenzt ausstehende Befehle und wiederholt die Suche mit wachsendem, gedeckeltem Abstand unter Berücksichtigung von Netzwechseln. Beim Wiederfinden verwende ich die beständige Geräte-ID, aktualisiere Dienstendpunkte und erneuere Ereignisabonnements. Vor dem Fortsetzen frage ich den Wiedergabestatus ab, da das Gerät neu gestartet oder von einem anderen Controller bedient worden sein kann. Befehle wiederhole ich nur, wenn das sicher ist.
13Wie vermeidet ein Player nach dem ersten Videobild wiederholte Stopps bei langsamer oder schwankender Verbindung?
Ich messe abspielbare Puffersekunden und den letzten Segmentdurchsatz und wähle eine Qualität mit Abstand unterhalb der dauerhaft verfügbaren Bandbreite. Bei schrumpfendem Puffer schalte ich früh herunter, mit Hysterese vorsichtig wieder hoch. Nach einem Stopp fülle ich vor dem Neustart genügend nach. Bei Abrufvideo ist mehr Vorpufferung vertretbar; live erhöht sie den Abstand zur Übertragung. Segmentplanung, wiederverwendete Verbindungen und weniger konkurrierende Downloads helfen. Ich trenne Downloadzeit von Dekodierzeit und erfasse verworfene Bilder, da eine niedrigere Netzbitrate einen überlasteten Decoder nicht zwingend entlastet. Entscheidend sind weniger Stillstandssekunden bei vertretbarer Qualität, Startzeit und Liveverzögerung.
14Wie unterscheiden sich Weex und React Native beim Erstellen einer nativen mobilen Oberfläche mit JavaScript?
Beide bilden JavaScript-Oberflächen auf native Komponenten ab, statt lediglich eine Webseite in einer WebView zu zeigen. Weex trennt Rendering-Engine und Frontend-Syntax und hat etwa Vue und Rax unterstützt. React Native nutzt React-Komponenten; Fabric und die neuere native Integration unterscheiden sich von der früheren asynchronen Bridge. Weder vollständiges Browser-CSS noch identisches Verhalten auf iOS und Android sind garantiert. Ich vergleiche konkrete Versionen, native Module, Layout, Debugging, Barrierefreiheit und Upgradepfad mit dem Bedarf der App. Gemeinsame Geschäftslogik reduziert Doppelarbeit; plattformspezifische Komponenten und Integrationen bleiben nötig. Die tatsächliche Leistung prüfe ich mit einem repräsentativen Prototyp.
15Wie definieren und messen Sie iOS-App-Startzeit für einen Vergleich zwischen Releases?
Ich messe vom Auslösen bis zum ersten App-Frame nach der dokumentierten Werkzeugdefinition und getrennt bis zur Benutzbarkeit oder sinnvollem Inhalt. Der Startbildschirm allein zeigt keine Bereitschaft. Prozessstart und Wiederaufnahme sowie kalte und warme Bedingungen trenne ich wegen Caches und Vorwärmung. Ich verwende Release-Builds auf vergleichbaren Geräten und OS-Versionen mit konstanten Daten, Netz-, Installations- und Temperaturbedingungen, ohne störenden Debugger. Aus Wiederholungen berichte ich Median und hohe Perzentile. Instruments und XCTest reproduzieren Rückschritte, MetricKit oder Organizer liefern Feldverteilungen. Signposts um Initialisierung, Datenladen und Szenenaufbau lokalisieren die Änderung.
16Wie gehst du mit Thread-Grenzen an nativen Schnittstellen um, damit umfangreiche native Arbeit die Oberfläche nicht ausbremst?
Prüfe für das konkrete Framework und Modul, auf welchem Thread Aufruf, Handler und Antwort ausgeführt werden. Auch eine asynchrone Methode kann ihren Handler auf dem Hauptthread beginnen. Führe teure Berechnungen und blockierende Ein- und Ausgabe auf geeigneten, begrenzten Hintergrund-Executors aus. Kehre für die Antwort oder Oberflächenoperationen nur dann auf den erforderlichen Thread zurück, wenn der Vertrag es verlangt. Bündele kleine Nachrichten, vermeide unnötige Wechsel und begrenze Datenkopien. Behandle Abbruch und späte Antworten. Miss mit Ablaufspuren die Wartezeit pro Thread, statt aus der Schnittstelle auf die Ausführung zu schließen.
class ImageProcessorPlugin : MethodChannel.MethodCallHandler {
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
if (call.method == "applyFilter") {
val imageBytes = call.argument<ByteArray>("image") ?: return result.error("INVALID_ARG", "Image null", null)
// Dispatch heavy computation off the main UI thread
scope.launch {
try {
val processed = processBitmapBytes(imageBytes) // CPU heavy work
withContext(Dispatchers.Main) {
result.success(processed)
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
result.error("PROCESSING_FAILED", e.localizedMessage, null)
}
}
}
} else {
result.notImplemented()
}
}
}
17Wie entwirfst du für Listen und Feeds eine Cache-Strategie mit Hintergrundaktualisierung und bedingten HTTP-Anfragen?
Zeige den lokal gespeicherten Stand sofort, wenn die Aktualitätsregeln das zulassen, und prüfe parallel auf Änderungen. Verwende für dieselbe Repräsentation den gespeicherten ETag mit `If-None-Match` oder einen passenden Änderungszeitpunkt. Bei `304 Not Modified` behältst du den Inhalt und aktualisierst die zugehörigen Cache-Metadaten. Bei `200 OK` übernimmst du Inhalt und Kennung gemeinsam. Trenne Caches nach Konto, Filtern und weiteren für die Darstellung relevanten Varianten. Nach lokalen Änderungen oder veralteten Seitentokens muss die App betroffene Seiten neu prüfen. Manuelles Aktualisieren kann ebenfalls eine bedingte Anfrage verwenden. Beachte sowohl die HTTP-Cache-Regeln als auch die fachliche Zulässigkeit älterer Daten.
fun getFeed(): Flow<List<FeedItem>> = flow {
val cached = feedDao.getFeedItems()
if (cached.isNotEmpty()) emit(cached)
val lastEtag = feedDao.getFeedEtag()
try {
val response = api.fetchFeed(ifNoneMatch = lastEtag)
if (response.code() == 200 && response.body() != null) {
feedDao.updateFeedTransaction(response.body()!!, response.headers()["ETag"])
emit(feedDao.getFeedItems())
}
} catch (e: Exception) {
if (cached.isEmpty()) throw e
}
}
18Eine mobile Finanzanwendung muss Refresh-Tokens sicher auf dem Gerät speichern, biometrisches Entsperren unterstützen, Betriebssystemaktualisierungen überstehen und während vorübergehender Offline-Sitzungen sicher funktionieren. Wie würden Sie diese Speicher- und Zugriffsarchitektur entwerfen?
Speichern Sie Refresh-Tokens in der iOS Keychain mit ausdrücklich festgelegten Richtlinien zur Zugänglichkeit und biometrischen Zugriffskontrolle, oder verschlüsseln Sie sie mit einem Android-Keystore-Schlüssel, der biometrische Autorisierung verlangt. `AfterFirstUnlockThisDeviceOnly` steuert Zugänglichkeit und Übertragbarkeit und verlangt für sich allein keine Biometrie. Prüfen Sie die Hardwareunterstützung, statt StrongBox oder eine allgemeine Speicherung in der Secure Enclave vorauszusetzen. Halten Sie Access-Tokens kurzlebig und vorzugsweise im Arbeitsspeicher; serialisieren Sie Token-Aktualisierungen und speichern Sie rotierte Tokens atomar. Testen Sie Betriebssystemaktualisierungen, Änderungen registrierter biometrischer Merkmale, Sperrungen, Neuinstallation, Sicherung und Wiederherstellung sowie Schlüsselinvalidierung. Sehen Sie einen Wiederherstellungsweg mit erneuter Anmeldung vor, statt einen garantierten Fortbestand anzunehmen. Offline-Zugriff sollte gemäß einer dokumentierten Richtlinie nur begrenzte verschlüsselte lokale Daten zugänglich machen, zeitlich beschränkt sein und zwischengespeicherte Aktionen nach Wiederherstellung der Verbindung erneut autorisieren. Ein getrennter Client kann aktuelle serverseitige Widerrufe nicht erfahren; alleinige Prüfungen der lokalen Uhr bieten keinen starken Manipulationsschutz. Verschieben Sie Token-Aktualisierungen und hochwertige serverseitige Transaktionen bis zur erneuten Verbindung. Widerrufen Sie bei bestätigter Invalidierung betroffene Serversitzungen und löschen Sie zugehörige lokale Zugangsdaten und Daten.
val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
val spec = KeyGenParameterSpec.Builder(
"refreshTokenKeyAlias",
KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
)
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
.setUserAuthenticationRequired(true)
.setUserAuthenticationParameters(0, KeyProperties.AUTH_BIOMETRIC_STRONG)
.setInvalidatedByBiometricEnrollment(true)
.build()
keyGenerator.init(spec)
keyGenerator.generateKey()
19Wie entwirfst du die CI/CD eines mobilen Monorepos für mehrere Teams, wenn macOS-Runner knapp und teuer sind?
Ermittle betroffene Module aus Änderungen und ihrem Abhängigkeitsgraphen. Berücksichtige gemeinsame Konfiguration, Lockfiles und nachgelagerte Verbraucher. Lass plattformneutrale Prüfungen und passende Android-Aufgaben auf günstigeren Runnern laufen. Reserviere macOS für Xcode, iOS-Signierung und entsprechende Simulator- oder Gerätetests. Nutze reproduzierbare Runner-Images und geteilte Build-Caches mit vollständigen Eingabeschlüsseln und getrennten Vertrauensbereichen. Plane Kapazität nach Warteschlange und Priorität, mit reserviertem Platz für Freigaben. Führe bei unklarem Einfluss und regelmäßig vollständige Prüfungen aus. Miss Wartezeit, Cache-Treffer und Kosten pro erfolgreichem Build.
20Wie würden Sie eine plattformübergreifende Mobile-Architektur für ein Produkt entwerfen, bei dem der Großteil der Geschäftslogik zwischen iOS und Android geteilt werden soll, während sich plattformspezifische UI (User Interface), Navigation und native Integrationen unabhängig voneinander weiterentwickeln können?
Ich würde die App um einen gemeinsamen Kern herum aufbauen, der die stabile Geschäftslogik verwaltet: Domänenmodelle, Validierungen, Use Cases, Geschäftsregeln und Datenzugriffsverträge. Plattformspezifische UI, Navigation, native SDKs, Berechtigungen, Lebenszyklus-Handling und App-Shell-Belange sollten außerhalb dieses Kerns verbleiben.
Der geteilte Code sollte weder UIKit, SwiftUI, Jetpack, Android-Framework-APIs, React Native Navigation, Flutter Navigation noch native SDK-Details importieren. Stattdessen sollte er von präzisen Schnittstellen wie `AuthRepository`, `SecureStorage`, `Analytics`, `CameraService` oder `PaymentProvider` abhängen, die von der jeweiligen Plattform implementiert werden.
Ich würde den Code so weit wie möglich nach Features strukturieren, anstatt eine einzige große gemeinsame Schicht zu erstellen. Beispielsweise können Checkout, Suche, Account und Messaging jeweils über geteilten Domain-/Use-Case-Code, Zustandskontrakte und Repository-Interfaces verfügen. Die iOS- und Android-Shells steuern dann den Aufbau der Bildschirme, native UI-Muster, Navigationsstapel, Berechtigungen und das Adapter-Wiring.
Präsentationslogik kann geteilt werden, wenn sie vollständig unabhängig vom UI-Framework ist – wie z. B. Reducer, Zustandsautomaten oder View-Model-Verträge, die einfache Zustände und Aktionen ausgeben. Die eigentlichen Views und die Navigation sollten jedoch plattformspezifisch bleiben, damit sich jede Plattform unabhängig weiterentwickeln kann.
Der zentrale Kompromiss besteht darin, gemeinsame, stabile Geschäftslogik konsequent zu teilen, während Abstraktionen vermieden werden, die reale Plattformunterschiede verschleiern. Ich würde Modulgrenzen durch Abhängigkeitsregeln, Dependency Injection, öffentliche APIs, Contract-Tests, Architekturprüfungen und klare Ownership durchsetzen. Native Integrationen sollten Ports und Adapter nutzen, sodass der geteilte Feature-Code eine einheitliche Funktionalität sieht, während jede Plattform SDK-Verhalten, Lebenszyklus, Berechtigungen, Fehler und UX-Unterschiede in ihrer eigenen Schicht handhabt.