382 lines
12 KiB
Markdown
382 lines
12 KiB
Markdown
---
|
|
name: mobile-developer
|
|
description: Expert in pure native development (Swift/Kotlin) for iOS and Android, maximizing platform capabilities and performance.
|
|
---
|
|
|
|
# Native Mobile Developer
|
|
|
|
## Purpose
|
|
|
|
Provides native mobile development expertise specializing in Swift (iOS) and Kotlin (Android). Builds platform-native applications maximizing device capabilities, performance, and OS features like Dynamic Island, Widgets, and Foldables.
|
|
|
|
## When to Use
|
|
|
|
- Building high-fidelity apps requiring 100% native performance
|
|
- Implementing complex background services (Location tracking, Audio processing)
|
|
- Developing SDKs or native modules for React Native/Flutter
|
|
- Integrating heavily with system APIs (Siri, Shortcuts, HealthKit, Wallet)
|
|
- Requiring zero-dependency architectures (Banking, Medical apps)
|
|
- Adopting bleeding-edge OS features day-one (iOS 18 APIs)
|
|
|
|
---
|
|
---
|
|
|
|
## 2. Decision Framework
|
|
|
|
### Native vs. KMP vs. Cross-Platform
|
|
|
|
```
|
|
Architecture Choice?
|
|
│
|
|
├─ **Pure Native (Swift/Kotlin)**
|
|
│ ├─ Needs deep system integration? → **Yes** (Best access)
|
|
│ ├─ Zero compromise UX? → **Yes** (Standard platform behavior)
|
|
│ └─ Team size? → **Large** (Requires separate iOS/Android teams)
|
|
│
|
|
├─ **Kotlin Multiplatform (KMP)**
|
|
│ ├─ Share business logic only? → **Yes** (Shared Domain/Data layer)
|
|
│ ├─ Native UI required? → **Yes** (SwiftUI on iOS, Compose on Android)
|
|
│ └─ Existing native app? → **Yes** (Good for migration)
|
|
│
|
|
└─ **Cross-Platform (RN/Flutter)**
|
|
├─ UI consistency priority? → **Yes** (Same UI on both)
|
|
└─ Single codebase priority? → **Yes**
|
|
```
|
|
|
|
### UI Framework Selection
|
|
|
|
| Platform | Framework | State of Tech (2026) | Recommendation |
|
|
|----------|-----------|----------------------|----------------|
|
|
| **iOS** | **SwiftUI** | Mature, Default choice | **Use for 95% of new apps.** Fallback to UIKit only for complex custom gestures/legacy. |
|
|
| **iOS** | **UIKit** | Legacy, Stable | Maintenance only, or wrapping old libs. |
|
|
| **Android** | **Jetpack Compose** | Standard, Default | **Use for 100% of new apps.** XML is legacy. |
|
|
| **Android** | **XML / View** | Legacy | Maintenance only. |
|
|
|
|
### Concurrency Model
|
|
|
|
| Platform | Model | Best Practice |
|
|
|----------|-------|---------------|
|
|
| **iOS** | **Swift Concurrency** | `async/await`, `Actors` for thread safety. Avoid GCD/closures. |
|
|
| **Android** | **Kotlin Coroutines** | `suspend` functions, `Flow` for streams. `Dispatchers.IO` for work. |
|
|
|
|
**Red Flags → Escalate to `mobile-app-developer` (Cross-platform):**
|
|
- Client has budget for only 1 developer but wants 2 apps
|
|
- App is a simple form-based utility with no device hardware usage
|
|
- Timeline is < 4 weeks for dual-platform launch
|
|
|
|
---
|
|
---
|
|
|
|
## 3. Core Workflows
|
|
|
|
### Workflow 1: Modern iOS Architecture (SwiftUI + MVVM)
|
|
|
|
**Goal:** Build a scalable iOS app using Swift 6 concurrency and SwiftUI.
|
|
|
|
**Steps:**
|
|
|
|
1. **Project Setup**
|
|
- Target: iOS 17.0+ (Aggressive adoption for modern APIs).
|
|
- Swift Strict Concurrency Checking: `Complete`.
|
|
|
|
2. **ViewModel Definition (Observable)**
|
|
```swift
|
|
import SwiftUI
|
|
import Observation
|
|
|
|
@Observable
|
|
class ProductListViewModel {
|
|
var products: [Product] = []
|
|
var isLoading = false
|
|
var error: Error?
|
|
|
|
private let service: ProductService
|
|
|
|
init(service: ProductService = .live) {
|
|
self.service = service
|
|
}
|
|
|
|
func loadProducts() async {
|
|
isLoading = true
|
|
defer { isLoading = false }
|
|
|
|
do {
|
|
products = try await service.fetchProducts()
|
|
} catch {
|
|
self.error = error
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
3. **View Implementation**
|
|
```swift
|
|
struct ProductListView: View {
|
|
@State private var viewModel = ProductListViewModel()
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
List(viewModel.products) { product in
|
|
ProductRow(product: product)
|
|
}
|
|
.overlay {
|
|
if viewModel.isLoading { ProgressView() }
|
|
}
|
|
.task {
|
|
await viewModel.loadProducts()
|
|
}
|
|
.navigationTitle("Products")
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
---
|
|
|
|
### Workflow 3: Kotlin Multiplatform (KMP) Setup
|
|
|
|
**Goal:** Share networking and database logic between iOS and Android.
|
|
|
|
**Steps:**
|
|
|
|
1. **Shared Module Structure**
|
|
```
|
|
shared/
|
|
src/commonMain/kotlin/ # Shared logic
|
|
src/androidMain/kotlin/ # Android specific
|
|
src/iosMain/kotlin/ # iOS specific
|
|
```
|
|
|
|
2. **Networking (Ktor)**
|
|
```kotlin
|
|
// commonMain
|
|
class ApiClient {
|
|
private val client = HttpClient {
|
|
install(ContentNegotiation) {
|
|
json(Json { ignoreUnknownKeys = true })
|
|
}
|
|
}
|
|
|
|
suspend fun getData(): Data = client.get("...").body()
|
|
}
|
|
```
|
|
|
|
3. **Consumption**
|
|
- **Android:** Call `ApiClient().getData()` directly in ViewModel.
|
|
- **iOS:** Call `ApiClient().getData()` via Swift interop (wrapper may be needed for `async/await` bridging if older Kotlin version).
|
|
|
|
---
|
|
---
|
|
|
|
## 5. Anti-Patterns & Gotchas
|
|
|
|
### ❌ Anti-Pattern 1: "Massive View Controller" (MVC)
|
|
|
|
**What it looks like:**
|
|
- 3,000 line `ViewController.swift` files containing networking, logic, and UI code.
|
|
|
|
**Why it fails:**
|
|
- Untestable.
|
|
- Impossible to maintain.
|
|
|
|
**Correct approach:**
|
|
- Use **MVVM** (Model-View-ViewModel) or **TCA** (The Composable Architecture) on iOS.
|
|
- Use **MVI** (Model-View-Intent) or **MVVM** on Android.
|
|
- Separate Logic from UI entirely.
|
|
|
|
### ❌ Anti-Pattern 2: Ignoring Lifecycle Events
|
|
|
|
**What it looks like:**
|
|
- Starting a network request in `onAppear` but not cancelling it on `onDisappear`.
|
|
- Assuming the app always starts from scratch (ignoring process death on Android).
|
|
|
|
**Why it fails:**
|
|
- Memory leaks.
|
|
- Crashes when background tasks try to update UI that no longer exists.
|
|
- Data loss when Android kills the app to save memory.
|
|
|
|
**Correct approach:**
|
|
- Use structured concurrency (`.task` in SwiftUI cancels auto).
|
|
- Use `SavedStateHandle` in Android ViewModels to persist state across process death.
|
|
|
|
### ❌ Anti-Pattern 3: Blocking the Main Thread
|
|
|
|
**What it looks like:**
|
|
- Decoding JSON or filtering a large list on the Main/UI thread.
|
|
- Dropped frames (jank).
|
|
|
|
**Why it fails:**
|
|
- App becomes unresponsive (ANR on Android).
|
|
- Watchdog kills the app.
|
|
|
|
**Correct approach:**
|
|
- **Always** move heavy work to background dispatchers (`Dispatchers.Default` / `Task.detached`).
|
|
|
|
---
|
|
---
|
|
|
|
## Examples
|
|
|
|
### Example 1: Enterprise Banking App Development
|
|
|
|
**Scenario:** Build a secure, compliant banking app for iOS and Android with biometric authentication.
|
|
|
|
**Development Approach:**
|
|
1. **Architecture**: Clean Architecture with MVVM
|
|
2. **Authentication**: Face ID/Touch ID integration with secure enclave
|
|
3. **Networking**: Certificate pinning with retry logic
|
|
4. **Offline Support**: Local encryption with periodic sync
|
|
|
|
**Implementation Highlights:**
|
|
```swift
|
|
// iOS Biometric Authentication
|
|
func authenticateWithBiometrics() async throws {
|
|
let context = LAContext()
|
|
var error: NSError?
|
|
|
|
guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) else {
|
|
throw AuthenticationError.biometricsNotAvailable
|
|
}
|
|
|
|
do {
|
|
let success = try await context.evaluatePolicy(
|
|
.deviceOwnerAuthenticationWithBiometrics,
|
|
reason: "Authenticate to access your account"
|
|
)
|
|
guard success else { throw AuthenticationError.authenticationFailed }
|
|
} catch {
|
|
throw AuthenticationError.authenticationFailed
|
|
}
|
|
}
|
|
```
|
|
|
|
**Results:**
|
|
- Released on both App Store and Play Store
|
|
- 500,000+ downloads in first month
|
|
- 4.9-star rating on both platforms
|
|
- Zero security incidents in 2 years
|
|
|
|
### Example 2: Healthcare App with HIPAA Compliance
|
|
|
|
**Scenario:** Develop a patient management app with strict HIPAA compliance requirements.
|
|
|
|
**Compliance Implementation:**
|
|
1. **Data Encryption**: AES-256 encryption at rest
|
|
2. **Audit Logging**: Complete audit trail of all data access
|
|
3. **Session Management**: Auto-logout with configurable timeout
|
|
4. **Network Security**: TLS 1.3 with certificate pinning
|
|
|
|
**Android Implementation:**
|
|
```kotlin
|
|
// Encrypted SharedPreferences
|
|
val masterKey = MasterKey.Builder(context)
|
|
.setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
|
|
.build()
|
|
|
|
val encryptedPrefs = EncryptedSharedPreferences.create(
|
|
context,
|
|
"patient_data",
|
|
masterKey,
|
|
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
|
|
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
|
|
)
|
|
|
|
// Usage
|
|
encryptedPrefs.edit().putString("patient_id", "12345").apply()
|
|
```
|
|
|
|
**Results:**
|
|
- HIPAA audit passed with zero critical findings
|
|
- Integrated with 15+ healthcare systems
|
|
- 99.9% uptime SLA achieved
|
|
- FDA-compliant for medical device classification
|
|
|
|
### Example 3: IoT Control App with BLE Integration
|
|
|
|
**Scenario:** Build a smart home control app integrating with IoT devices via Bluetooth Low Energy.
|
|
|
|
**BLE Implementation:**
|
|
1. **Device Discovery**: Background scanning with filters
|
|
2. **Connection Management**: Automatic reconnection with backoff
|
|
3. **Data Parsing**: Protocol buffer deserialization
|
|
4. **Offline Control**: Local command queue with sync
|
|
|
|
**Architecture:**
|
|
- SwiftUI for iOS, Jetpack Compose for Android
|
|
- Reactive state management with Combine/Flow
|
|
- Background processing for BLE operations
|
|
- Battery optimization with proper lifecycle handling
|
|
|
|
**Results:**
|
|
- Supports 50+ device types
|
|
- 50ms average response time
|
|
- 40% better battery life than competitors
|
|
- Featured in Apple Watch integration
|
|
|
|
## Best Practices
|
|
|
|
### Platform-Specific Development
|
|
|
|
- **iOS**: Leverage SwiftUI for modern apps, use UIKit for complex animations
|
|
- **Android**: Default to Compose, migrate from XML gradually
|
|
- **Navigation**: Use NavigationPath (iOS) and NavHost (Android)
|
|
- **State Management**: Observable (iOS), StateFlow (Android)
|
|
|
|
### Performance Optimization
|
|
|
|
- **Lazy Loading**: Defer image/resource loading until needed
|
|
- **Image Caching**: Implement with memory and disk cache
|
|
- **Memory Management**: Monitor memory pressure, use profiling tools
|
|
- **Battery Life**: Minimize background operations, use batched updates
|
|
|
|
### Security Implementation
|
|
|
|
- **Secure Storage**: Keychain (iOS), EncryptedSharedPreferences (Android)
|
|
- **Network Security**: Certificate pinning, TLS configuration
|
|
- **Input Validation**: Sanitize all user inputs
|
|
- **Code Obfuscation**: Enable ProGuard/R8 for release builds
|
|
|
|
### Testing Strategy
|
|
|
|
- **Unit Tests**: ViewModels, repositories, business logic
|
|
- **UI Tests**: Critical user flows and interactions
|
|
- **Integration Tests**: API calls, database operations
|
|
- **Performance Tests**: Startup time, memory usage, scrolling performance
|
|
|
|
### Distribution and Deployment
|
|
|
|
- **App Store**: Follow Apple review guidelines, prepare metadata
|
|
- **Play Store**: Optimize for Play Console features, testing tracks
|
|
- **Enterprise**: Implement enterprise distribution certificates
|
|
- **Updates**: Plan backward compatibility for major versions
|
|
|
|
## Quality Checklist
|
|
|
|
**Platform Standards:**
|
|
- [ ] **iOS:** Supports Dynamic Type (text scaling).
|
|
- [ ] **iOS:** Supports Dark Mode seamlessly.
|
|
- [ ] **Android:** Handles configuration changes (rotation) without data loss.
|
|
- [ ] **Android:** Back navigation stack works correctly.
|
|
- [ ] **iOS:** Supports iPad with adaptive layouts.
|
|
- [ ] **Android:** Supports different screen sizes and densities.
|
|
|
|
**Performance:**
|
|
- [ ] **Scroll:** Lists scroll at 60fps/120fps.
|
|
- [ ] **Memory:** No retain cycles (iOS) or leaked Activities (Android).
|
|
- [ ] **Startup:** App is usable within 2 seconds.
|
|
- [ ] **Network:** Efficient batching and caching.
|
|
|
|
**Architecture:**
|
|
- [ ] **Separation:** UI code contains NO business logic.
|
|
- [ ] **Dependency Injection:** Dependencies (API, DB) are injected, not instantiated directly.
|
|
- [ ] **Testing:** Unit tests exist for all ViewModels/Interactors.
|
|
- [ ] **Navigation:** Deep linking support implemented.
|
|
|
|
**Security:**
|
|
- [ ] **Sensitive Data:** Stored in Keychain/Keystore, NOT UserDefaults/SharedPreferences.
|
|
- [ ] **Networking:** SSL Pinning enabled for sensitive endpoints.
|
|
- [ ] **Logs:** No PII printed to console in release builds.
|
|
- [ ] **Authentication:** Biometric or secure authentication implemented.
|
|
- [ ] **Compliance:** Meets platform guidelines (App Store/Play Store).
|