don't break existing api and just use the atomic bool to do the checks

Author: sbSteveK

include/aws/crt/mqtt/Mqtt5Client.h

@@ -343,13 +343,15 @@ namespace Aws
             /**
              * Type signature of the callback invoked when a PacketPublish message received (OnMessageHandler).
              *
-             * Return true if you called acquirePubackControl() and will invoke the PUBACK manually later via
-             * Mqtt5Client::InvokePuback(). Return false (or do not return a value) to have the client
-             * automatically send the PUBACK on your behalf after this callback returns.
+             * To take manual control of the PUBACK for a QoS 1 message, call
+             * eventData.acquirePubackControl() within this callback. If you do so, the client will NOT
+             * automatically send the PUBACK; you are responsible for calling Mqtt5Client::InvokePuback()
+             * later with the returned handle.
              *
-             * For QoS 0 messages, the return value is ignored.
+             * If you do not call acquirePubackControl() (or it returns nullptr), the client will
+             * automatically send the PUBACK after this callback returns.
              */
-            using OnPublishReceivedHandler = std::function<bool(const PublishReceivedEventData &)>;
+            using OnPublishReceivedHandler = std::function<void(const PublishReceivedEventData &)>;
 
             /**
              * Callback for users to invoke upon completion of, presumably asynchronous, OnWebSocketHandshakeIntercept

source/mqtt/Mqtt5ClientCore.cpp

@@ -212,7 +212,9 @@ namespace Aws
                         auto available = std::make_shared<std::atomic<bool>>(true);
                         if (publish->qos == AWS_MQTT5_QOS_AT_LEAST_ONCE)
                         {
-                            /* Eagerly acquire the puback control before invoking the user callback */
+                            /* Eagerly acquire the puback control before invoking the user callback.
+                             * An opaque wrapper (PubackControlHandle) is provided to the user callback via
+                             * acquirePubackControl(). */
                             pubackControlId = aws_mqtt5_client_acquire_puback(client_core->m_client, publish);
 
                             if (pubackControlId != 0)
@@ -226,22 +228,30 @@ namespace Aws
                                     {
                                         return nullptr;
                                     }
+                                    /* Mark as consumed so a second call returns nullptr */
                                     *available = false;
                                     return handle;
                                 };
                             }
                         }
 
-                        bool pubackTaken = client_core->onPublishReceived(eventData);
+                        client_core->onPublishReceived(eventData);
 
-                        /* Explicitly invalidate the lambda now that the callback scope has ended.
-                         * Any copy of the lambda saved by the user will now return nullptr
-                         * immediately. */
-                        *available = false;
+                        /* Detect whether the user called acquirePubackControl() during the callback:
+                         * - If they called it and got a handle, *available was set to false inside
+                         *   the lambda, so it is already false here.
+                         * - If they did NOT call it, *available is still true here.
+                         *
+                         * We use exchange(false) to atomically read the current value and set it to
+                         * false in one step. If it returns true, the user did NOT take control and
+                         * we must auto-invoke the PUBACK. If it returns false, the user already
+                         * consumed the handle and is responsible for calling InvokePuback() later.
+                         *
+                         * This also serves as the post-callback invalidation: after this point any
+                         * saved copy of the lambda will return nullptr immediately. */
+                        bool userDidNotTakeControl = available->exchange(false);
 
-                        /* If the user did not take manual control of the PUBACK (returned false),
-                         * auto-invoke it now. Also auto-invoke on error to avoid losing the PUBACK. */
-                        if (pubackControlId != 0 && !pubackTaken)
+                        if (pubackControlId != 0 && userDidNotTakeControl)
                         {
                             aws_mqtt5_client_invoke_puback(client_core->m_client, pubackControlId, nullptr);
                         }