Mobile App Architecture, Lifecycle, and Performance Questions

Approach overview
Use server-side cursor pagination + client-side virtualization and a small sliding data window so the app never holds thousands of full objects in memory.

Backend pagination

• Cursor-based API returning lightweight DTOs (id, title, small meta, imageUrl, updatedAt) and nextCursor. Cursor is stable (opaque token).
• Support server-side filtering/sorting and search endpoints with query and pagination.

Client virtualization & windowing

• Use platform-native recycled lists (RecyclerView / UICollectionView / Flutter ListView/React Native FlatList) that only instantiate visible cells.
• Maintain a data window in memory: visible range ± buffer (e.g., visibleCount + 2x screenfuls). Keep only those items; evict older ones with an LRU.

Lightweight in-memory representations

• Store minimal model: id, text fields, thumbnail URL; lazy-load heavy assets (images) into disk cache and memory-limited image cache (e.g., Glide/Picasso/SDWebImage).
• Use value objects, not full view models; compute derived fields on demand.

Prefetching & thresholds

• When scroll reaches within threshold (e.g., last 20% of loaded range or within N items of end), fetch next page async.
• Use single inflight request per direction, exponential backoff on failure.
• Prefetch images for the buffer range into disk/memory cache.

Search & filtering

• Perform search and filter on server (typed query + pagination). Client sends debounced requests (300–500ms) and cancels prior inflight queries.
• For incremental UX, show local client-side filtering only over current window while server results arrive.

Performance & reliability

• Use DiffUtil / performBatchUpdates to apply minimal UI changes.
• Handle connectivity: show cached pages, graceful retries, and consistent cursors.
• Monitor memory with tooling, tune buffer sizes per device memory class.

This keeps memory low, UX smooth, and search/filters responsive without pulling the full dataset.

Step-by-step approach (high level)

1. Confirm reproduction: run the app on the same physical device and emulator to verify difference. Note exact steps to reproduce.

Quick triage checks

• Reboot device, reinstall app (adb uninstall/install), clear app data.
• Toggle dev vs release build (debug vs release). Check whether Hermes/AOT/JIT differences matter (React Native Hermes, Flutter AOT vs JIT).
• Disable dev-only features (remote JS debugger, hot reload) and third-party plugins.

Logs & tools to collect

• adb logcat -v threadtime > device-log.txt (capture from app launch through crash).
• For React Native: Metro/JS logs (react-native log-android) and JS stack traces (Sentry/Flipper).
• For Flutter: flutter run --verbose and collect Dart/Flutter stack traces; use Observatory/DevTools.
• Capture tombstones: adb shell tombstoned or check /data/anr/traces.txt for native crashes.
• Collect ANR traces and Android system logs (adb bugreport > bugreport.zip).

Device metadata to capture

• Android version, security patch, device model, CPU architecture (adb shell getprop ro.product.cpu.abi), kernel version, free RAM/storage, adb shell dumpsys battery, SELinux mode.

Deeper analysis steps

• Symbolicate native crashes (NDK stack) with ndk-stack or addr2line using app’s native symbols.
• Reproduce with instrumentation: run with StrictMode, enable Flutter --track-widget-creation or RN Dev Support.
• Bisect commits/versions to isolate regression; test on additional physical devices/OS versions.

Outcome

• Prioritize fixes with crash frequency and impact; add automated device tests and crash monitoring to prevent regressions.

Approach (brief)
Use ImageIO to create a thumbnail while decoding (CGImageSourceCreateThumbnailAtIndex) to downsample during decode, run off the main thread, preserve aspect ratio by target width, and return UIImage on main thread.

Sample Swift implementation

import UIKit
import ImageIO
import MobileCoreServices

func downsampleImage(data: Data, targetWidth: CGFloat, scale: CGFloat = UIScreen.main.scale, completion: @escaping (UIImage?) -> Void) {
    DispatchQueue.global(qos: .userInitiated).async {
        let options: CFDictionary = [
            kCGImageSourceShouldCache: false,
            kCGImageSourceCreateThumbnailFromImageAlways: true,
            kCGImageSourceCreateThumbnailWithTransform: true
        ] as CFDictionary

        guard let src = CGImageSourceCreateWithData(data as CFData, nil),
              let properties = CGImageSourceCopyPropertiesAtIndex(src, 0, nil) as? [CFString: Any],
              let width = properties[kCGImagePropertyPixelWidth] as? CGFloat,
              let height = properties[kCGImagePropertyPixelHeight] as? CGFloat
        else {
            DispatchQueue.main.async { completion(nil) }
            return
        }

        let aspect = height / width
        let targetPixelWidth = max(1, targetWidth * scale)
        let targetPixelHeight = max(1, targetPixelWidth * aspect)

        let thumbOptions: CFDictionary = [
            kCGImageSourceShouldCache: false,
            kCGImageSourceCreateThumbnailFromImageAlways: true,
            kCGImageSourceCreateThumbnailWithTransform: true,
            kCGImageSourceThumbnailMaxPixelSize: max(targetPixelWidth, targetPixelHeight)
        ] as CFDictionary

        guard let cgThumb = CGImageSourceCreateThumbnailAtIndex(src, 0, thumbOptions) else {
            DispatchQueue.main.async { completion(nil) }
            return
        }

        let image = UIImage(cgImage: cgThumb, scale: scale, orientation: .up)
        DispatchQueue.main.async { completion(image) }
    }
}

Notes, complexity & edge cases

• Time: O(pixels) for decode; Memory: low because ImageIO decodes into thumbnail not full bitmap.
• Handle progressive JPEGs, very small/large images, and invalid data.
• Use kCGImageSourceShouldCache = false to avoid main-thread caching; ensure completion runs on main thread for UI updates.

Overview (platform notifications)

• Android: System calls Component.onTrimMemory(level) and Application.onTrimMemory(level); older devices call onLowMemory(). onTrimMemory provides levels (examples):
  • TRIM_MEMORY_UI_HIDDEN: app UI no longer visible — safe to release UI caches.
  • TRIM_MEMORY_RUNNING_MODERATE / RUNNING_LOW / RUNNING_CRITICAL: device is low while app is running — progressively free memory.
  • TRIM_MEMORY_BACKGROUND / MODERATE: app in background; free resources.
  • TRIM_MEMORY_COMPLETE: process around to be killed soon — aggressively release memory.
• iOS: UIViewController.didReceiveMemoryWarning and UIApplicationDelegate.applicationDidReceiveMemoryWarning; backgrounded apps may be suspended (no CPU) and can be terminated without further callbacks.

Recommended actions (to preserve state and avoid kill)

• Immediately free caches and large in-memory buffers (images, decoded bitmaps).
• Release nonessential resources: cached network responses, temporary data, heavy view hierarchies.
• Persist critical state to disk (SharedPreferences/UserDefaults, SQLite, files, Keychain) so you can restore after kill.
• Stop or throttle background work, timers, ongoing animations, and heavy tasks.
• Unsubscribe listeners/observers to avoid memory leaks.
• For TRIM_MEMORY_UI_HIDDEN or didReceiveMemoryWarning in controllers: clear view-related caches; keep minimal state for fast restore.
• For CRITICAL/COMPLETE: aggressively null references, call System.gc() only as hint on Android rarely; prepare for process restart.

Why these actions matter

• Releasing memory reduces chance OS will kill process; persisting state ensures UX continuity if killed or suspended. Prioritize user-visible state and save asynchronously to avoid blocking main thread.

Approach (brief)

Design a small Kotlin/JVM class that evaluates device conditions and decides immediate, delayed, or skipped sync. Persist minimal state (lastSyncTime, backoffUntil) using an abstract KeyValueStore. Support urgency override and energy-aware thresholds.

Signatures & Pseudo-implementation

// simple key-value store abstraction for minimal persistence
interface KeyValueStore {
  fun putLong(key: String, value: Long)
  fun getLong(key: String, default: Long = 0L): Long
}

// possible results
enum class ScheduleDecision { RUN_NOW, SCHEDULE_DELAYED, SKIP }

// device snapshot provided to decision engine
data class DeviceState(
  val batteryPct: Int,          // 0-100
  val isCharging: Boolean,
  val networkType: NetworkType, // WIFI, CELLULAR, NONE
  val nowMillis: Long
)

enum class NetworkType { WIFI, CELLULAR, NONE }

// adaptive scheduler core
class AdaptiveScheduler(private val store: KeyValueStore) {
  private val LAST_SYNC = "last_sync"
  private val BACKOFF_UNTIL = "backoff_until"

  // parameters tunable for energy-awareness
  private val minIntervalWifi = 10 * 60_000L      // 10 min
  private val minIntervalCellular = 30 * 60_000L // 30 min
  private val lowBatteryThreshold = 20           // %
  private val aggressiveWhileCharging = true

  fun recordSync(nowMillis: Long) {
    store.putLong(LAST_SYNC, nowMillis)
    store.putLong(BACKOFF_UNTIL, 0L)
  }

  fun setBackoff(untilMillis: Long) {
    store.putLong(BACKOFF_UNTIL, untilMillis)
  }

  /**
   * Decide: RUN_NOW, SCHEDULE_DELAYED (with suggested delay), or SKIP.
   * urgencyOverride: if true, prefer RUN_NOW unless device is critical (no network).
   */
  fun decide(state: DeviceState, urgencyOverride: Boolean = false): Pair<ScheduleDecision, Long?> {
    val last = store.getLong(LAST_SYNC, 0L)
    val backoff = store.getLong(BACKOFF_UNTIL, 0L)
    if (state.networkType == NetworkType.NONE) return ScheduleDecision.SKIP to null
    if (backoff > state.nowMillis) return ScheduleDecision.SCHEDULE_DELAYED to (backoff - state.nowMillis)

    val minInterval = when (state.networkType) {
      NetworkType.WIFI -> minIntervalWifi
      NetworkType.CELLULAR -> minIntervalCellular
      else -> minIntervalCellular
    }

    val timeSince = state.nowMillis - last

    // urgency override: run immediately on urgent unless no network
    if (urgencyOverride && state.networkType != NetworkType.NONE) return ScheduleDecision.RUN_NOW to null

    // energy-aware rules
    if (state.batteryPct <= lowBatteryThreshold && !state.isCharging) {
      // conservative: skip unless on wifi and sufficient interval elapsed
      if (state.networkType == NetworkType.WIFI && timeSince >= minIntervalWifi * 2) {
        return ScheduleDecision.RUN_NOW to null
      }
      // schedule longer delay (exponential backoff heuristic)
      val delay = (minIntervalCellular * 2).coerceAtMost(60 * 60_000L)
      return ScheduleDecision.SCHEDULE_DELAYED to delay
    }

    // charging or good battery: be more permissive
    if (state.isCharging || state.batteryPct > 50) {
      if (timeSince >= minInterval) return ScheduleDecision.RUN_NOW to null
      return ScheduleDecision.SCHEDULE_DELAYED to (minInterval - timeSince)
    }

    // default conservative path
    return if (timeSince >= minInterval * 2) ScheduleDecision.RUN_NOW to null
           else ScheduleDecision.SCHEDULE_DELAYED to (minInterval * 2 - timeSince)
  }
}

Why this design

• Minimal persisted state (last sync, backoff) for resilience across restarts.
• Energy-aware thresholds: longer intervals on cellular, aggressive when charging.
• Urgency override bypasses conservative logic.
• Simple to integrate with WorkManager/AlarmManager: map ScheduleDecision to immediate work or schedule with suggested delay.

Edge cases

• Clock changes: store times in elapsedRealtime if available.
• Rapid toggling network: debounce before RUN_NOW.
• Parameterize thresholds for remote config/tests.