@rejourneyco/react-native 1.0.2 → 1.0.3

package/android/src/main/java/com/rejourney/capture/VideoEncoder.kt

@@ -59,7 +59,6 @@ interface VideoEncoderDelegate {
 
 class VideoEncoder(private val segmentDir: File) {
 
-    // Configuration - matching iOS RJVideoEncoder defaults for quality and efficiency
     /** Target video bitrate in bits per second. Default: 1.5 Mbps - matches iOS */
     var targetBitrate: Int = 1_500_000
 
@@ -84,7 +83,6 @@ class VideoEncoder(private val segmentDir: File) {
     /** Delegate for receiving segment completion notifications */
     var delegate: VideoEncoderDelegate? = null
 
-    // State
     private var encoder: MediaCodec? = null
     private var muxer: MediaMuxer? = null
     private var inputSurface: Surface? = null
@@ -101,37 +99,24 @@ class VideoEncoder(private val segmentDir: File) {
     private val presentationTimesUs = ArrayDeque<Long>()
     private var lastPresentationTimeUs = 0L
     
-    // CRITICAL FIX: Track original unscaled dimensions for segment rotation
-    // Without this, finishSegmentAndContinue() would pass already-scaled dimensions
-    // to startSegment(), causing double-scaling and degrading video quality
     private var originalRequestedWidth = 0
     private var originalRequestedHeight = 0
 
     private var sessionId: String? = null
 
-    // Encoding thread
     private var encodingThread: HandlerThread? = null
     private var encodingHandler: Handler? = null
 
-    // Buffer info for draining encoder
     private val bufferInfo = MediaCodec.BufferInfo()
     
-    // Lock for thread-safe encoder access
-    // Prevents concurrent calls to drainEncoder from appendFrame and finishSegment
     private val encoderLock = ReentrantLock()
 
-    // isRecording: Allow frames once encoder and surface are ready
-    // NOTE: The muxer starts asynchronously when the first frame is encoded and 
-    // drainEncoder receives INFO_OUTPUT_FORMAT_CHANGED. We cannot require muxerStarted
-    // here because that would create a chicken-and-egg problem where no frames can be
-    // appended to trigger the muxer to start.
     val isRecording: Boolean
         get() = encoder != null && inputSurface != null
 
     val currentFrameCount: Int
         get() = frameCount.get()
 
-    // Prewarm state
     private var isPrewarmed = false
 
     init {
@@ -147,7 +132,6 @@ class VideoEncoder(private val segmentDir: File) {
         if (isPrewarmed) return
         
         try {
-            // Pre-query available H.264 encoders to cache codec info
             val codecInfo = findEncoder(MediaFormat.MIMETYPE_VIDEO_AVC)
             if (codecInfo != null) {
                 Logger.debug("[VideoEncoder] Prewarm: found encoder ${codecInfo.name}")
@@ -178,22 +162,17 @@ class VideoEncoder(private val segmentDir: File) {
     fun startSegment(width: Int, height: Int): Boolean {
         Logger.debug("[VideoEncoder] startSegment: ${width}x${height}")
 
-        // If already recording, finish current segment first
         if (isRecording) {
             Logger.debug("[VideoEncoder] Already recording, finishing previous segment")
             finishSegment()
         }
 
-        // CRITICAL FIX: Store original unscaled dimensions BEFORE scaling
-        // Used by finishSegmentInternal() during segment rotation to prevent double-scaling
         originalRequestedWidth = width
         originalRequestedHeight = height
 
-        // Apply scale factor using native pixels (matching iOS)
         var scaledWidth = (width * captureScale).toInt()
         var scaledHeight = (height * captureScale).toInt()
 
-        // Apply max dimension cap (like iOS)
         val maxDim = maxOf(scaledWidth, scaledHeight)
         if (maxDim > maxDimension) {
             val scale = maxDimension.toFloat() / maxDim.toFloat()
@@ -202,11 +181,9 @@ class VideoEncoder(private val segmentDir: File) {
             Logger.debug("[VideoEncoder] Applied max dimension cap: ${scaledWidth}x${scaledHeight}")
         }
 
-        // Ensure dimensions are even (required for H.264)
         scaledWidth = (scaledWidth / 2) * 2
         scaledHeight = (scaledHeight / 2) * 2
 
-        // Minimum size check
         if (scaledWidth < 100 || scaledHeight < 100) {
             Logger.warning("[VideoEncoder] Frame size too small, using minimum 100x100")
             scaledWidth = 100
@@ -216,7 +193,6 @@ class VideoEncoder(private val segmentDir: File) {
         currentFrameWidth = scaledWidth
         currentFrameHeight = scaledHeight
 
-        // Reset counters
         frameCount.set(0)
         lastFrameTimestamp.set(0)
         segmentFirstFrameTimestamp.set(0)
@@ -224,21 +200,17 @@ class VideoEncoder(private val segmentDir: File) {
         lastPresentationTimeUs = 0L
         segmentStartTime.set(System.currentTimeMillis())
 
-        // Generate unique filename
         val sessionPrefix = sessionId ?: "unknown"
         val filename = "seg_${sessionPrefix}_${segmentStartTime.get()}.mp4"
         currentSegmentFile = File(segmentDir, filename)
 
-        // Delete existing file if any
         currentSegmentFile?.delete()
 
         Logger.debug("[VideoEncoder] Creating segment: $filename (${scaledWidth}x${scaledHeight})")
 
         return try {
-            // Start encoding thread
             startEncodingThread()
 
-            // Configure encoder
             configureEncoder(scaledWidth, scaledHeight)
 
             true
@@ -274,20 +246,17 @@ class VideoEncoder(private val segmentDir: File) {
         }
 
         try {
-            // Scale bitmap if needed
             val scaledBitmap = if (bitmap.width != currentFrameWidth || bitmap.height != currentFrameHeight) {
                 Bitmap.createScaledBitmap(bitmap, currentFrameWidth, currentFrameHeight, true)
             } else {
                 bitmap
             }
 
-            // Track first frame timestamp for presentation time calculation
             if (frameCount.get() == 0) {
                 segmentFirstFrameTimestamp.set(timestamp)
             }
 
 
-            // Draw bitmap to encoder input surface
             val canvas = surface.lockHardwareCanvas()
             try {
                 canvas.drawBitmap(scaledBitmap, 0f, 0f, null)
@@ -295,12 +264,10 @@ class VideoEncoder(private val segmentDir: File) {
                 surface.unlockCanvasAndPost(canvas)
             }
 
-            // Recycle scaled bitmap if we created a new one
             if (scaledBitmap != bitmap) {
                 scaledBitmap.recycle()
             }
 
-            // Drain encoder output (thread-safe)
             encoderLock.withLock {
                 val presentationTimeUs = computePresentationTimeUs(timestamp)
                 presentationTimesUs.add(presentationTimeUs)
@@ -314,7 +281,6 @@ class VideoEncoder(private val segmentDir: File) {
                 Logger.debug("[VideoEncoder] Frame appended: ${frameCount.get()}/$framesPerSegment")
             }
 
-            // Auto-rotate segment if we've reached the limit
             if (frameCount.get() >= framesPerSegment) {
                 Logger.info("[VideoEncoder] Segment full (${frameCount.get()} frames), rotating")
                 finishSegmentAndContinue()
@@ -364,7 +330,6 @@ class VideoEncoder(private val segmentDir: File) {
         val width = currentFrameWidth
         val height = currentFrameHeight
 
-        // Skip if no frames were written
         if (count == 0) {
             Logger.debug("[VideoEncoder] No frames in segment, canceling")
             cancelSegment()
@@ -372,25 +337,19 @@ class VideoEncoder(private val segmentDir: File) {
         }
 
         try {
-            // Thread-safe: Lock to prevent race with appendFrame's drainEncoder
             encoderLock.withLock {
-                // Signal end of stream
                 enc.signalEndOfInputStream()
                 
-                // Drain remaining output
                 drainEncoder(true)
             }
 
-            // Stop and release muxer
             if (muxerStarted.get()) {
                 muxer?.stop()
             }
 
-            // Get file size for logging
             val fileSize = segmentFile?.length() ?: 0
             Logger.info("[VideoEncoder] Segment complete - $count frames, ${fileSize / 1024.0} KB, ${(endTime - startTime) / 1000.0}s")
 
-            // Notify delegate
             segmentFile?.let {
                 delegate?.onSegmentFinished(it, startTime, endTime, count)
             }
@@ -401,13 +360,8 @@ class VideoEncoder(private val segmentDir: File) {
         } finally {
             cleanup()
 
-            // Start new segment if requested
             if (shouldContinue && sessionId != null) {
                 Logger.debug("[VideoEncoder] Starting new segment after rotation")
-                // CRITICAL FIX: Use original unscaled dimensions, NOT width/height
-                // which are the already-scaled currentFrameWidth/currentFrameHeight.
-                // Using scaled dimensions would cause double-scaling:
-                // 1080x2424 -> 356x800 (first segment) -> 142x320 (second segment)
                 startSegment(originalRequestedWidth, originalRequestedHeight)
             }
         }
@@ -482,12 +436,9 @@ class VideoEncoder(private val segmentDir: File) {
         Logger.warning("[VideoEncoder] Emergency flush - attempting to save ${frameCount.get()} frames")
 
         return try {
-            // Save segment metadata to disk for recovery
             saveCrashSegmentMetadata()
 
-            // Thread-safe: Lock to prevent race with appendFrame
             encoderLock.withLock {
-                // Try to finalize
                 encoder?.signalEndOfInputStream()
                 drainEncoder(true)
             }
@@ -525,32 +476,27 @@ class VideoEncoder(private val segmentDir: File) {
     }
 
     private fun configureEncoder(width: Int, height: Int) {
-        // Find H.264 encoder
         val codecInfo = findEncoder(MediaFormat.MIMETYPE_VIDEO_AVC)
             ?: throw IllegalStateException("No H.264 encoder available")
 
-        // Configure format - matching iOS RJVideoEncoder settings
         val format = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height).apply {
             setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface)
             setInteger(MediaFormat.KEY_BIT_RATE, targetBitrate)
             setInteger(MediaFormat.KEY_FRAME_RATE, fps)
-            setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, keyframeInterval) // 10s keyframes like iOS for smaller files
+            setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, keyframeInterval)
 
-            // Baseline profile to reduce encoder CPU cost (matches iOS Baseline+CAVLC change)
             if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
                 setInteger(MediaFormat.KEY_PROFILE, MediaCodecInfo.CodecProfileLevel.AVCProfileBaseline)
                 setInteger(MediaFormat.KEY_LEVEL, MediaCodecInfo.CodecProfileLevel.AVCLevel31)
             }
         }
 
-        // Create encoder
         encoder = MediaCodec.createByCodecName(codecInfo.name).apply {
             configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
             inputSurface = createInputSurface()
             start()
         }
 
-        // Create muxer
         muxer = MediaMuxer(currentSegmentFile!!.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
 
         Logger.debug("[VideoEncoder] Encoder configured: ${codecInfo.name} ${width}x${height} @ ${targetBitrate}bps")
@@ -589,7 +535,6 @@ class VideoEncoder(private val segmentDir: File) {
             when {
                 outputBufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER -> {
                     if (!endOfStream) break
-                    // Continue draining if end of stream
                 }
 
                 outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
@@ -608,7 +553,6 @@ class VideoEncoder(private val segmentDir: File) {
                         ?: throw RuntimeException("Encoder output buffer $outputBufferIndex was null")
 
                     if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0) {
-                        // Codec config data - skip
                         bufferInfo.size = 0
                     }
 
@@ -662,7 +606,6 @@ class VideoEncoder(private val segmentDir: File) {
     }
 
     companion object {
-        // Class-level prewarm state (matching iOS +prewarmEncoderAsync)
         @Volatile
         private var staticPrewarmed = false
         
@@ -687,7 +630,6 @@ class VideoEncoder(private val segmentDir: File) {
                 try {
                     val startTime = System.nanoTime()
                     
-                    // Query available H.264 encoders to cache codec info in system
                     val codecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
                     val codecInfos = codecList.codecInfos
                     
@@ -698,7 +640,6 @@ class VideoEncoder(private val segmentDir: File) {
                             val types = info.supportedTypes
                             if (types.any { it.equals(MediaFormat.MIMETYPE_VIDEO_AVC, ignoreCase = true) }) {
                                 encoderName = info.name
-                                // Touch capabilities to trigger JIT/caching
                                 val caps = info.getCapabilitiesForType(MediaFormat.MIMETYPE_VIDEO_AVC)
                                 caps.videoCapabilities
                                 caps.encoderCapabilities
@@ -731,7 +672,6 @@ class VideoEncoder(private val segmentDir: File) {
             return try {
                 val json = metaFile.readText()
                 val result = mutableMapOf<String, Any>()
-                // Simple JSON parsing (avoiding JSONObject for minimal dependencies)
                 json.lines().forEach { line ->
                     val trimmed = line.trim().removeSuffix(",")
                     when {

package/android/src/main/java/com/rejourney/capture/ViewHierarchyScanner.kt

@@ -627,7 +627,9 @@ class ViewHierarchyScanner(val config: ViewHierarchyScannerConfig = ViewHierarch
             "AIRMap",
             "AIRMapView",
             "RNMMapView",
-            "GMSMapView"
+            "GMSMapView",
+            "Mapbox",
+            "MGLMapView"
         )
     }
 }

package/android/src/main/java/com/rejourney/lifecycle/SessionLifecycleService.kt

@@ -47,24 +47,18 @@ class SessionLifecycleService : Service() {
     companion object {
         private const val TAG = "SessionLifecycleService"
         
-        // Static listener reference - set by RejourneyModuleImpl
         @Volatile
         var taskRemovedListener: TaskRemovedListener? = null
         
-        // Track if service is running
         @Volatile
         var isRunning = false
             private set
         
-        // Minimum time between service start and onTaskRemoved to be considered valid
-        // Samsung devices sometimes fire onTaskRemoved immediately on app launch
-        private const val MIN_TIME_BEFORE_TASK_REMOVED_MS = 2000L // 2 seconds
+        private const val MIN_TIME_BEFORE_TASK_REMOVED_MS = 2000L
     }
     
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     
-    // Track service start time to detect false positives (Samsung bug)
-    // Instance variable, not static, since each service instance has its own start time
     private var serviceStartTime: Long = 0
     
     override fun onCreate() {
@@ -78,8 +72,6 @@ class SessionLifecycleService : Service() {
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         serviceStartTime = SystemClock.elapsedRealtime()
         Logger.debug("[$TAG] Service started (startId=$startId, OEM: ${OEMDetector.getOEM()})")
-        // Return START_STICKY to allow system to restart service if killed
-        // This helps ensure the service stays alive to catch termination events
         return START_STICKY
     }
     
@@ -106,9 +98,6 @@ class SessionLifecycleService : Service() {
         
         Logger.debug("[$TAG] ⚠️ onTaskRemoved() called (OEM: $oem, timeSinceStart: ${timeSinceStart}ms)")
         
-        // SAMSUNG BUG FIX: Samsung devices sometimes fire onTaskRemoved() immediately
-        // after app launch (within 1-2 seconds). This is a known bug on Samsung devices.
-        // We filter out these false positives by checking the time since service start.
         if (OEMDetector.isSamsung() && timeSinceStart < Companion.MIN_TIME_BEFORE_TASK_REMOVED_MS) {
             Logger.warning("[$TAG] ⚠️ Ignoring onTaskRemoved() - likely Samsung false positive (fired ${timeSinceStart}ms after start, expected > ${MIN_TIME_BEFORE_TASK_REMOVED_MS}ms)")
             Logger.warning("[$TAG] This is a known Samsung bug where onTaskRemoved fires on app launch")
@@ -116,20 +105,12 @@ class SessionLifecycleService : Service() {
             return
         }
         
-        // For other OEMs with aggressive task killing, log but still process
         if (OEMDetector.hasAggressiveTaskKilling()) {
             Logger.debug("[$TAG] OEM has aggressive task killing - onTaskRemoved may be unreliable")
         }
         
         Logger.debug("[$TAG] ✅ Valid onTaskRemoved() - app is being killed/swiped away")
         
-        // CRITICAL: Notify the listener IMMEDIATELY and SYNCHRONOUSLY
-        // The previous implementation used a coroutine with 100ms delay which caused
-        // the process to be killed before session end could complete.
-        // 
-        // We now call the listener directly on the main thread. The listener
-        // (RejourneyModuleImpl) is responsible for doing synchronous work as fast
-        // as possible since the process may be killed immediately after this returns.
         try {
             Logger.debug("[$TAG] Calling listener synchronously...")
             taskRemovedListener?.onTaskRemoved()
@@ -138,7 +119,6 @@ class SessionLifecycleService : Service() {
             Logger.error("[$TAG] Error notifying task removed listener", e)
         }
         
-        // Stop the service - no need for async since listener is already done
         try {
             stopSelf()
         } catch (e: Exception) {
@@ -149,7 +129,6 @@ class SessionLifecycleService : Service() {
     }
     
     override fun onBind(intent: Intent?): IBinder? {
-        // This is a started service, not a bound service
         return null
     }
     

package/android/src/main/java/com/rejourney/network/DeviceAuthManager.kt

@@ -57,9 +57,8 @@ class DeviceAuthManager private constructor(private val context: Context) {
         private const val KEYSTORE_ALIAS = "com.rejourney.devicekey"
         private const val ANDROID_KEYSTORE = "AndroidKeyStore"
         
-        // Rate limiting constants for auto-registration
-        private const val AUTH_COOLDOWN_BASE_MS = 5000L  // 5 second base cooldown
-        private const val AUTH_COOLDOWN_MAX_MS = 300000L  // 5 minute max cooldown
+        private const val AUTH_COOLDOWN_BASE_MS = 5000L  
+        private const val AUTH_COOLDOWN_MAX_MS = 300000L  
         private const val AUTH_MAX_CONSECUTIVE_FAILURES = 10
 
         fun getInstance(context: Context): DeviceAuthManager {
@@ -69,10 +68,8 @@ class DeviceAuthManager private constructor(private val context: Context) {
         }
     }
 
-    // Listener for authentication failures (set by RejourneyModuleImpl)
     var authFailureListener: AuthFailureListener? = null
 
-    // Use shared client (SSL pinning removed)
     private val client = HttpClientProvider.shared
 
     private val prefs: SharedPreferences by lazy {
@@ -143,7 +140,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
             .putString(KEY_SDK_VERSION, sdkVersion)
             .apply()
 
-        // Check if already registered
         val existingCredentialId = prefs.getString(KEY_CREDENTIAL_ID, null)
         if (!existingCredentialId.isNullOrEmpty()) {
             Logger.debug("Device already registered with credential: $existingCredentialId")
@@ -151,7 +147,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
             return
         }
 
-        // Generate or load ECDSA keypair
         val publicKeyPEM = try {
             getOrCreatePublicKeyPEM()
         } catch (e: Exception) {
@@ -165,7 +160,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
             return
         }
 
-        // Register with backend
         val requestBody = JSONObject().apply {
             put("projectPublicKey", projectKey)
             put("bundleId", bundleId)
@@ -241,7 +235,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
     fun getUploadToken(
         callback: (success: Boolean, token: String?, expiresIn: Int, error: String?) -> Unit
     ) {
-        // Check cached token
         val cachedToken = prefs.getString(KEY_UPLOAD_TOKEN, null)
         val tokenExpiry = prefs.getLong(KEY_TOKEN_EXPIRY, 0)
         
@@ -261,14 +254,12 @@ class DeviceAuthManager private constructor(private val context: Context) {
         
         val savedApiUrl = prefs.getString(KEY_API_URL, null)?.takeIf { it.startsWith("http") } ?: "https://api.rejourney.co"
 
-        // Step 1: Request challenge
         requestChallenge(credentialId) { challengeSuccess, challenge, nonce, challengeError ->
             if (!challengeSuccess || challenge == null || nonce == null) {
                 callback(false, null, 0, challengeError ?: "Failed to get challenge")
                 return@requestChallenge
             }
 
-            // Step 2: Sign challenge
             val signature = try {
                 signChallenge(challenge)
             } catch (e: Exception) {
@@ -282,7 +273,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
                 return@requestChallenge
             }
 
-            // Step 3: Start session with signed challenge
             startSession(credentialId, challenge, nonce, signature, callback)
         }
     }
@@ -434,7 +424,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
     suspend fun ensureValidToken(): Boolean {
         Logger.debug("[DeviceAuthManager] ensureValidToken() called")
 
-        // Always refresh from SharedPreferences before network operations
         loadStoredRegistrationInfo()
 
         return kotlinx.coroutines.suspendCancellableCoroutine { continuation ->
@@ -478,7 +467,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
             .remove(KEY_TOKEN_EXPIRY)
             .apply()
         
-        // Also delete the private key from Keystore
         try {
             val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE)
             keyStore.load(null)
@@ -506,7 +494,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
         }
     }
 
-    // ==================== ECDSA Keypair Management ====================
 
     /**
      * Get or create ECDSA P-256 keypair and return public key in PEM format.
@@ -515,14 +502,12 @@ class DeviceAuthManager private constructor(private val context: Context) {
         val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE)
         keyStore.load(null)
 
-        // Try to load existing key
         if (keyStore.containsAlias(KEYSTORE_ALIAS)) {
             Logger.debug("Loaded existing ECDSA private key")
             val certificate = keyStore.getCertificate(KEYSTORE_ALIAS)
             return exportPublicKeyToPEM(certificate.publicKey)
         }
 
-        // Generate new keypair
         Logger.debug("Generating new ECDSA P-256 keypair")
         
         val keyPairGenerator = KeyPairGenerator.getInstance(
@@ -536,7 +521,7 @@ class DeviceAuthManager private constructor(private val context: Context) {
         )
             .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1")) // P-256
             .setDigests(KeyProperties.DIGEST_SHA256)
-            .setUserAuthenticationRequired(false) // No biometric required
+            .setUserAuthenticationRequired(false) 
             .build()
 
         keyPairGenerator.initialize(parameterSpec)
@@ -551,7 +536,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
      */
     private fun exportPublicKeyToPEM(publicKey: PublicKey): String? {
         return try {
-            // Get the raw public key bytes (X.509 SubjectPublicKeyInfo format)
             val encoded = publicKey.encoded
             val base64 = Base64.encodeToString(encoded, Base64.NO_WRAP)
             
@@ -574,10 +558,8 @@ class DeviceAuthManager private constructor(private val context: Context) {
             val privateKey = keyStore.getKey(KEYSTORE_ALIAS, null) as? PrivateKey
                 ?: throw Exception("Private key not found")
 
-            // Decode base64 challenge
             val challengeBytes = Base64.decode(challenge, Base64.DEFAULT)
 
-            // Sign with ECDSA-SHA256
             val signature = Signature.getInstance("SHA256withECDSA")
             signature.initSign(privateKey)
             signature.update(challengeBytes)
@@ -591,7 +573,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
         }
     }
 
-    // ==================== Backend Communication ====================
 
     /**
      * Request challenge from backend.
@@ -638,7 +619,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
                         
                         when (errorCode) {
                             403 -> {
-                                // Access forbidden - security error
                                 Logger.error("SECURITY: Challenge request forbidden")
                                 val errorMessage = parseErrorMessage(errorBody) ?: "Access forbidden"
                                 clearCredentials()
@@ -646,7 +626,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
                                 callback(false, null, null, errorMessage)
                             }
                             404 -> {
-                                // Device credential rejected by backend (likely DB reset or invalid)
                                 Logger.error("SECURITY: Device credential not found")
                                 val errorMessage = parseErrorMessage(errorBody) ?: "Credential not found"
                                 clearCredentials()
@@ -720,7 +699,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
                         
                         when (errorCode) {
                             403 -> {
-                                // Access forbidden - security error
                                 Logger.error("SECURITY: Start-session forbidden")
                                 val errorMessage = parseErrorMessage(errorBody) ?: "Access forbidden"
                                 clearCredentials()
@@ -728,7 +706,6 @@ class DeviceAuthManager private constructor(private val context: Context) {
                                 callback(false, null, 0, errorMessage)
                             }
                             404 -> {
-                                // Credential or project not found
                                 Logger.error("SECURITY: Start-session resource not found")
                                 val errorMessage = parseErrorMessage(errorBody) ?: "Resource not found"
                                 clearCredentials()

package/android/src/main/java/com/rejourney/network/NetworkMonitor.kt

@@ -108,11 +108,9 @@ class NetworkMonitor private constructor(private val context: Context) {
             connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
             telephonyManager = context.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
 
-            // Check initial state
             updateCurrentNetworkState()
             listener?.onNetworkChanged(currentQuality)
 
-            // Register for updates
             networkCallback = object : ConnectivityManager.NetworkCallback() {
                 override fun onAvailable(network: Network) {
                     updateCurrentNetworkState()