iOS: Not Running → Inactive → Active → Background → Suspended. Key callbacks: didFinishLaunching, willResignActive, didEnterBackground, willEnterForeground.

Android: onCreate → onStart → onResume → onPause → onStop → onDestroy. Plus onSaveInstanceState for configuration changes.

• Key-value: UserDefaults/SharedPreferences for settings
• Database: Core Data, Room, SQLite, Realm for structured data
• Files: Documents/cache directories for large files
• Secure storage: Keychain/Keystore for credentials

Strong: Increases retain count, keeps object alive (default)

Weak: Doesn't increase retain count, becomes nil when deallocated. Use for delegates, avoiding retain cycles.

Unowned: Like weak but never nil—crashes if accessed after deallocation. Use when reference outlives owner.

Model: Data and business logic

View: UI components (UIKit/SwiftUI, Android Views/Compose)

ViewModel: Transforms model data for view, handles user actions, survives configuration changes

Benefits: Testable ViewModels, separation of concerns, reactive data binding.

URL Schemes: Custom schemes (myapp://). Simple but can be hijacked.

Universal Links (iOS) / App Links (Android): Use HTTPS domain, verified ownership. More secure, fallback to web.

Implementation: Register domains, handle incoming URLs in app delegate/activity, parse and navigate.

Memory leaks occur when objects are retained longer than needed, often from retain cycles.

Detection: Instruments (iOS), LeakCanary/Profiler (Android), memory graphs.

Common causes: Closures capturing self strongly, delegates not weak, NotificationCenter observers not removed.

1. App registers with APNs/FCM, receives device token
2. Token sent to your backend
3. Backend sends notification to APNs/FCM with token
4. APNs/FCM delivers to device
5. App handles in foreground/background differently

• Local database as source of truth
• Queue actions for sync when online
• Conflict resolution strategy
• Network reachability monitoring
• Optimistic UI updates with rollback

iOS: Events travel up view hierarchy until handled. First responder, next responder chain. Used for keyboard, gestures.

Android: Touch events dispatched down view tree (dispatchTouchEvent), then up (onTouchEvent). Parent can intercept (onInterceptTouchEvent).

• Keychain (iOS) / Keystore (Android) for credentials
• Certificate pinning for network security
• Encrypt local databases
• Obfuscate code (ProGuard/R8)
• Don't hardcode secrets—use secure config
• Biometric authentication where appropriate

DI provides dependencies externally rather than creating them internally, improving testability.

Tools: Hilt/Dagger (Android), Swinject (iOS), or manual constructor injection. Key: Program to interfaces, inject via constructor.

Frame: Position and size in superview's coordinate system

Bounds: Position and size in view's own coordinate system (origin usually 0,0)

SwiftUI: Declarative, less code, live previews, newer APIs. Best for new projects targeting iOS 15+.

UIKit: Imperative, mature, full control, better for complex custom UI. Required for older iOS support.

Combine is Apple's reactive framework for processing values over time using Publishers and Subscribers.

vs RxSwift: Combine is native (no dependency), better performance, but iOS 13+ only. RxSwift has larger ecosystem, cross-platform with RxJava.

@State: Local view state, view owns it

@Binding: Reference to parent's state, two-way binding

@ObservedObject: External ObservableObject, doesn't own lifecycle

@StateObject: ObservableObject owned by view, survives view updates

NSManagedObjectModel: Schema definition

NSPersistentStoreCoordinator: Manages storage

NSManagedObjectContext: Scratchpad for changes

Modern: NSPersistentContainer wraps all three. CloudKit integration available.

Actors isolate mutable state, ensuring only one task accesses state at a time. Compiler enforces isolation.

@MainActor: Runs on main thread—use for UI updates. Prevents data races without manual locking.

Content Hugging: Resistance to growing beyond intrinsic size (high = won't grow)

Compression Resistance: Resistance to shrinking below intrinsic size

Priority: 1000 = required, <1000 = optional. Lower priority constraints break first.

Create URLSessionConfiguration (set timeouts, headers, cache policy), create URLSession with delegate for advanced handling (auth challenges, background downloads), create URLRequest and dataTask/downloadTask.

ATS enforces secure network connections—requires HTTPS, TLS 1.2+, forward secrecy.

Can configure exceptions in Info.plist but Apple reviews carefully. Best practice: use HTTPS everywhere.

• Reuse cells (dequeueReusableCell)
• Pre-calculate cell heights
• Avoid layout passes in cellForRow
• Async image loading with caching
• Diffable data sources for efficient updates
• Prefetching for smooth scrolling

GCD: Low-level, lightweight, fire-and-forget tasks. DispatchQueue, async/sync.

OperationQueue: Higher-level, dependencies between tasks, cancellation, KVO on state. Use for complex task graphs.

Compose: Declarative UI, less code, single source of truth for state. Modern approach.

XML Views: Imperative, mature, larger ecosystem. Still needed for some complex customizations.

• ViewModel: Survives configuration changes
• LiveData/StateFlow: Observable data holders
• Room: SQLite abstraction with compile-time verification
• Navigation: Type-safe navigation between destinations
• WorkManager: Deferrable background work

Coroutines: Lightweight threads for async code. suspend functions, structured concurrency with scopes.

Flow: Cold asynchronous data stream. Replaces RxJava for many cases. StateFlow/SharedFlow for hot streams.

Activity is destroyed and recreated. Data loss without proper handling.

Solutions: ViewModel (survives), onSaveInstanceState (small data), handle config changes manually (android:configChanges).

Service: Long-running operations, runs on main thread by default

IntentService: Deprecated. Used worker thread, stopped when done.

WorkManager: Modern solution for deferrable work. Survives app restarts, respects Doze mode.

Activity: Entry point, manages window, has its own lifecycle

Fragment: Modular UI component within Activity, reusable, can combine multiple fragments. Modern: Single Activity + multiple Fragments/Compose screens.

ANR: Application Not Responding—main thread blocked >5 seconds.

Prevention: Move I/O, network, database to background threads. Use coroutines/RxJava. Profile with StrictMode.

Code optimization and obfuscation for release builds.

Features: Shrinking (removes unused code), optimization, obfuscation (renames classes/methods), requires keep rules for reflection/serialization.

Interface for sharing data between apps securely. URI-based access, permissions controlled.

Use cases: Sharing data with other apps, FileProvider for secure file sharing, required for widgets accessing app data.

Hilt is built on Dagger, simplified for Android. Predefined components matching Android lifecycles.

Annotations: @HiltAndroidApp, @AndroidEntryPoint, @Inject, @Module, @Provides, @Singleton, @ViewModelScoped.

React Native: JavaScript/TypeScript, uses native components, larger ecosystem, hot reload.

Flutter: Dart, custom rendering engine (Skia), consistent UI across platforms, faster performance in complex animations.

JavaScript runs in JSC/Hermes, communicates with native via async JSON bridge.

New Architecture: JSI (JavaScript Interface) enables synchronous calls, TurboModules for lazy loading, Fabric for concurrent rendering.

React Native: Native Modules (write native code exposed to JS), community packages.

Flutter: Platform Channels (method channels for async communication), plugins.

StatefulWidget: createState → initState → didChangeDependencies → build → didUpdateWidget → dispose. setState triggers rebuild. build can be called many times.

• Local: useState, useReducer
• Global: Context API, Redux, Zustand, Jotai
• Server state: React Query, SWR
• Navigation state: React Navigation

• Minimize bridge crossings (React Native)
• Use FlatList/SectionList, avoid ScrollView for long lists
• Memoize expensive computations
• Optimize images (caching, proper sizing)
• Profile with Flipper/DevTools
• Use Hermes engine (React Native)

Use relative sizing (flex, percentages), responsive breakpoints, safe area handling, test on multiple devices/simulators. Consider tablets and foldables.

• Unit: Business logic, ViewModels (Jest, XCTest, JUnit)
• Integration: Multiple components together
• UI: XCUITest, Espresso, Detox
• Snapshot: Visual regression testing
• E2E: Full user flows on real devices