added more safety to IoTStreamThread

Author: harsh62

AWSIoT/Internal/AWSIoTStreamThread.m

@@ -46,27 +46,6 @@ - (void)dealloc {
     [self performMinimalCleanup];
 }
 
-/**
- * MINIMAL CLEANUP - Used during dealloc for crash safety
- * 
- * What it does:
- * - Stops timer to prevent callbacks
- * - Closes all streams and session directly with @synchronized for thread safety
- * - Clears delegates and blocks
- * - NO runloop operations (removeFromRunLoop)
- * - NO conditional logic based on shouldDisconnect
- * 
- * Why minimal:
- * - Safe during object deallocation
- * - Avoids method calls that could crash
- * - Simple operations only
- * - Prevents use-after-free crashes
- * 
- * Thread Safety:
- * - Uses @synchronized per stream object (customer's proven approach)
- * - Combined with atomic properties for comprehensive protection
- * - Double-checks stream existence within synchronized blocks
- */
 - (void)performMinimalCleanup {
     if (_didCleanUp) {
         return;
@@ -159,16 +138,13 @@ - (void)main {
     [self.session connectToInputStream:self.decoderInputStream
                           outputStream:self.encoderOutputStream];
 
-    // Add protection against runloop corruption from multiple threads
-    @try {
-        while ([self shouldContinueRunning]) {
-            //This will continue run until the thread is cancelled
-            //Run one cycle of the runloop. This will return after a input source event or timer event is processed
-            [self.runLoopForStreamsThread runMode:NSDefaultRunLoopMode
-                                       beforeDate:[NSDate dateWithTimeIntervalSinceNow:self.defaultRunLoopTimeInterval]];
-        }
-    } @catch (NSException *exception) {
-        AWSDDLogError(@"Exception in runloop execution: %@", exception);
+    // Capture values locally to prevent crashes if self is deallocated
+    NSRunLoop *runLoop = self.runLoopForStreamsThread;
+    NSTimeInterval interval = self.defaultRunLoopTimeInterval;
+    
+    while ([self shouldContinueRunning] && runLoop) {
+        [runLoop runMode:NSDefaultRunLoopMode
+              beforeDate:[NSDate dateWithTimeIntervalSinceNow:interval]];
     }
 
     [self cleanUp];
@@ -181,7 +157,11 @@ - (BOOL)shouldContinueRunning {
         return NO;
     }
 
-    return self.isRunning && !self.isCancelled && self.defaultRunLoopTimer != nil;
+    if (!self.runLoopForStreamsThread || !self.defaultRunLoopTimer) {
+        return NO;
+    }
+    
+    return self.isRunning && !self.isCancelled;
 }
 
 - (void)cancel {
@@ -191,6 +171,12 @@ - (void)cancel {
         return;
     }
 
+    // Invalidate timer immediately to break retain cycle
+    if (self.defaultRunLoopTimer) {
+        [self.defaultRunLoopTimer invalidate];
+        self.defaultRunLoopTimer = nil;
+    }
+    
     // Atomic property, no synchronization needed
     self.isRunning = NO;
     [super cancel];
@@ -203,39 +189,18 @@ - (void)cancelAndDisconnect:(BOOL)shouldDisconnect {
         return;
     }
 
+    // Invalidate timer immediately to break retain cycle
+    if (self.defaultRunLoopTimer) {
+        [self.defaultRunLoopTimer invalidate];
+        self.defaultRunLoopTimer = nil;
+    }
+    
     // Set flags and cancel - properties are atomic
     self.shouldDisconnect = shouldDisconnect;
     self.isRunning = NO;
     [super cancel];
 }
 
-/**
- * FULL CLEANUP - Called during normal thread shutdown
- * 
- * When used:
- * - Thread finishes main() execution normally
- * - Thread is cancelled via cancel() or cancelAndDisconnect()
- * - App is terminating or going to background
- * 
- * What it does:
- * - Stops timer to prevent callbacks
- * - Conditionally closes streams based on shouldDisconnect flag
- * - Properly removes streams from runloop before closing with @synchronized
- * - Follows original disconnect logic
- * - Handles onStop callback on main thread
- * 
- * Why full cleanup is safe here:
- * - Object is still valid and not being deallocated
- * - Safe to perform runloop operations
- * - Need to respect shouldDisconnect flag for proper behavior
- * - Can safely dispatch onStop callback to main thread
- * 
- * Thread Safety Strategy:
- * - @synchronized blocks prevent race conditions during stream operations
- * - Atomic properties ensure consistent state across threads
- * - Double-checks within sync blocks prevent operating on closed streams
- * - Combines customer's surgical approach with our comprehensive coverage
- */
 - (void)cleanUp {
     if (self.didCleanUp) {
         return;
@@ -248,6 +213,9 @@ - (void)cleanUp {
         self.defaultRunLoopTimer = nil;
     }
 
+    // Clear runloop reference
+    self.runLoopForStreamsThread = nil;
+    
     // Conditional cleanup based on shouldDisconnect flag
     if (self.shouldDisconnect) {
         // Close session first to cleanly terminate MQTT connection
@@ -260,10 +228,6 @@ - (void)cleanUp {
         @synchronized(self.outputStream) {
             if (self.outputStream) {
                 self.outputStream.delegate = nil;
-                // Safe to do runloop operations during normal cleanup
-                if (self.runLoopForStreamsThread) {
-                    [self.outputStream removeFromRunLoop:self.runLoopForStreamsThread forMode:NSDefaultRunLoopMode];
-                }
                 [self.outputStream close];
                 self.outputStream = nil;
             }