Mc/send heartbeat when presence no op (#341)

* Fix: when heartbeat interval is 0 SDK should send heartbeat on subscribe.

* PubNub SDK v10.4.7 release.

---------

Co-authored-by: PubNub Release Bot <[email protected]>

Author: marcin-cebo

.pubnub.yml

@@ -1,9 +1,9 @@
 name: kotlin
-version: 10.4.6
+version: 10.4.7
 schema: 1
 scm: github.com/pubnub/kotlin
 files:
-  - build/libs/pubnub-kotlin-10.4.6-all.jar
+  - build/libs/pubnub-kotlin-10.4.7-all.jar
 sdks:
   - 
       type: library
@@ -23,8 +23,8 @@ sdks:
             -
               distribution-type: library
               distribution-repository: maven
-              package-name: pubnub-kotlin-10.4.6
-              location: https://repo.maven.apache.org/maven2/com/pubnub/pubnub-kotlin/10.4.6/pubnub-kotlin-10.4.6.jar
+              package-name: pubnub-kotlin-10.4.7
+              location: https://repo.maven.apache.org/maven2/com/pubnub/pubnub-kotlin/10.4.7/pubnub-kotlin-10.4.7.jar
               supported-platforms:
                 supported-operating-systems:
                   Android:
@@ -121,6 +121,11 @@ sdks:
                   license-url: https://www.apache.org/licenses/LICENSE-2.0.txt
                   is-required: Required
 changelog:
+  - date: 2025-04-15
+    version: v10.4.7
+    changes:
+      - type: bug
+        text: "Heartbeat is sent for subscribe when presenceTimeout or heartbeatInterval not set."
   - date: 2025-03-20
     version: v10.4.6
     changes:

CHANGELOG.md

@@ -1,3 +1,9 @@
+## v10.4.7
+April 15 2025
+
+#### Fixed
+- Heartbeat is sent for subscribe when presenceTimeout or heartbeatInterval not set.
+
 ## v10.4.6
 March 20 2025
 

README.md

@@ -20,7 +20,7 @@ You will need the publish and subscribe keys to authenticate your app. Get your
      <dependency>
         <groupId>com.pubnub</groupId>
         <artifactId>pubnub-kotlin</artifactId>
-        <version>10.4.6</version>
+        <version>10.4.7</version>
      </dependency>
      ```
 

gradle.properties

@@ -18,7 +18,7 @@ RELEASE_SIGNING_ENABLED=true
 SONATYPE_HOST=DEFAULT
 SONATYPE_AUTOMATIC_RELEASE=false
 GROUP=com.pubnub
-VERSION_NAME=10.4.6
+VERSION_NAME=10.4.7
 POM_PACKAGING=jar
 
 POM_NAME=PubNub SDK

pubnub-gson/pubnub-gson-impl/config/ktlint/baseline.xml

@@ -4,6 +4,6 @@
         <error line="1" column="1" source="standard:no-empty-file" />
     </file>
     <file name="src/test/kotlin/com/pubnub/api/PNConfigurationTest.kt">
-        <error line="120" column="13" source="standard:function-naming" />
+        <error line="93" column="13" source="standard:function-naming" />
     </file>
 </baseline>

pubnub-gson/pubnub-gson-impl/src/integrationTest/java/com/pubnub/api/integration/managers/subscription/ReconnectionProblemWithoutReconnectionPolicyIT.java renamed to pubnub-gson/pubnub-gson-impl/src/integrationTest/java/com/pubnub/api/integration/managers/subscription/ReconnectionProblemWithoutRetryConfigurationIT.java

@@ -11,7 +11,7 @@
 import static com.pubnub.api.enums.PNLogVerbosity.BODY;
 
 
-public class ReconnectionProblemWithoutReconnectionPolicyIT extends AbstractReconnectionProblemIT {
+public class ReconnectionProblemWithoutRetryConfigurationIT extends AbstractReconnectionProblemIT {
     @Override
     protected @NotNull PubNub privilegedClientPubNub() {
         com.pubnub.api.java.v2.PNConfiguration.Builder pnConfiguration;

pubnub-gson/pubnub-gson-impl/src/test/kotlin/com/pubnub/api/PNConfigurationTest.kt

@@ -62,33 +62,6 @@ class PNConfigurationTest {
 //    }
 //
 //    @Test
-//    fun `reconnection policy should set retry configuration`() {
-//        val config = PNConfiguration(UserId(PubNub.generateUUID()))
-//        config.setReconnectionPolicy(PNReconnectionPolicy.NONE)
-//        Assert.assertTrue(config.retryConfiguration is RetryConfiguration.None)
-//
-//        config.setReconnectionPolicy(PNReconnectionPolicy.LINEAR)
-//        Assert.assertTrue(config.retryConfiguration is RetryConfiguration.Linear)
-//
-//        config.setReconnectionPolicy(PNReconnectionPolicy.EXPONENTIAL)
-//        Assert.assertTrue(config.retryConfiguration is RetryConfiguration.Exponential)
-//    }
-//
-//    @Test
-//    fun `maximumReconnectionRetries policy should reset retry configuration`() {
-//        val config = PNConfiguration(UserId(PubNub.generateUUID()))
-//
-//        config.setReconnectionPolicy(PNReconnectionPolicy.LINEAR)
-//        config.setMaximumReconnectionRetries(5)
-//        Assert.assertTrue(config.retryConfiguration is RetryConfiguration.Linear)
-//        Assert.assertEquals(5, (config.retryConfiguration as RetryConfiguration.Linear).maxRetryNumber)
-//
-//        config.setMaximumReconnectionRetries(10)
-//        Assert.assertTrue(config.retryConfiguration is RetryConfiguration.Linear)
-//        Assert.assertEquals(10, (config.retryConfiguration as RetryConfiguration.Linear).maxRetryNumber)
-//    }
-//
-//    @Test
 //    fun `cryptomodule uses cipherKey when cryptomodule is not set`() {
 //        val config = PNConfiguration(UserId(PubNub.generateUUID()))
 //

pubnub-kotlin/pubnub-kotlin-impl/src/integrationTest/kotlin/com/pubnub/api/integration/PresenceEventsIntegrationTests.kt

@@ -5,8 +5,10 @@ import com.pubnub.api.callbacks.SubscribeCallback
 import com.pubnub.api.enums.PNStatusCategory
 import com.pubnub.api.models.consumer.PNStatus
 import com.pubnub.api.models.consumer.pubsub.PNPresenceEventResult
+import com.pubnub.api.v2.callbacks.EventListener
 import com.pubnub.api.v2.subscriptions.SubscriptionOptions
 import com.pubnub.test.CommonUtils
+import com.pubnub.test.CommonUtils.DEFAULT_LISTEN_DURATION
 import com.pubnub.test.CommonUtils.generatePayload
 import com.pubnub.test.CommonUtils.randomChannel
 import com.pubnub.test.listen
@@ -58,6 +60,67 @@ class PresenceEventsIntegrationTests : BaseIntegrationTest() {
         success.listen()
     }
 
+    @Test
+    fun testMultipleSubscribeShouldCauseJoinEventToAppear() {
+        // “Generate Leave on TCP FIN or RST” should be disabled
+        val countDownLatchForJoinChannel01 = CountDownLatch(1)
+        val countDownLatchForJoinChannel02 = CountDownLatch(1)
+        val countDownLatchForJoinChannel03 = CountDownLatch(1)
+        val channel01Name = randomChannel() + "chan01"
+        val channel02Name = randomChannel() + "chan02"
+        val channel03Name = randomChannel() + "chan03"
+
+        pubnub.addListener(object : EventListener {
+            override fun presence(pubnub: PubNub, result: PNPresenceEventResult) {
+                if (result.event == "join") {
+                    when (result.channel) {
+                        channel01Name -> countDownLatchForJoinChannel01.countDown()
+                        channel02Name -> countDownLatchForJoinChannel02.countDown()
+                        channel03Name -> countDownLatchForJoinChannel03.countDown()
+                    }
+                }
+            }
+        })
+
+        pubnub.subscribe(channels = listOf(channel01Name), withPresence = true)
+        Thread.sleep(2000)
+        pubnub.subscribe(channels = listOf(channel01Name, channel02Name), withPresence = true)
+        Thread.sleep(2000)
+        pubnub.subscribe(channels = listOf(channel03Name), withPresence = true)
+
+        assertTrue(countDownLatchForJoinChannel01.await(DEFAULT_LISTEN_DURATION.toLong(), TimeUnit.SECONDS))
+        assertTrue(countDownLatchForJoinChannel02.await(DEFAULT_LISTEN_DURATION.toLong(), TimeUnit.SECONDS))
+        assertTrue(countDownLatchForJoinChannel03.await(DEFAULT_LISTEN_DURATION.toLong(), TimeUnit.SECONDS))
+    }
+
+    @Test
+    fun testMultipleSubscribeOnChannelEntitiesShouldCauseJoinEventToAppear() {
+        // “Generate Leave on TCP FIN or RST” should be disabled
+        val countDownLatchForJoinPubNubUser = CountDownLatch(1)
+        val countDownLatchForJoinPubQuestUser = CountDownLatch(1)
+        val channel01Name = randomChannel() + "chan01"
+
+        val subscription01 = pubnub.channel(channel01Name).subscription(SubscriptionOptions.receivePresenceEvents())
+        val subscription02 = guest.channel(channel01Name).subscription(SubscriptionOptions.receivePresenceEvents())
+
+        subscription01.onPresence = { pnPresenceEventResult: PNPresenceEventResult ->
+            if (pubnub.configuration.userId.value == pnPresenceEventResult.uuid && pnPresenceEventResult.event == "join") {
+                countDownLatchForJoinPubNubUser.countDown()
+            }
+            if (guest.configuration.userId.value == pnPresenceEventResult.uuid && pnPresenceEventResult.event == "join") {
+                countDownLatchForJoinPubQuestUser.countDown()
+            }
+        }
+
+        subscription01.subscribe()
+        Thread.sleep(2000)
+        subscription02.subscribe()
+        Thread.sleep(2000)
+
+        assertTrue(countDownLatchForJoinPubNubUser.await(DEFAULT_LISTEN_DURATION.toLong(), TimeUnit.SECONDS))
+        assertTrue(countDownLatchForJoinPubQuestUser.await(DEFAULT_LISTEN_DURATION.toLong(), TimeUnit.SECONDS))
+    }
+
     @Test
     fun testJoinChannelUsingOnPresenceField() {
         val successPresenceEventCont = AtomicInteger()

pubnub-kotlin/pubnub-kotlin-impl/src/main/kotlin/com/pubnub/internal/presence/Presence.kt

@@ -1,6 +1,9 @@
 package com.pubnub.internal.presence
 
+import com.pubnub.api.PubNubException
 import com.pubnub.api.enums.PNHeartbeatNotificationOptions
+import com.pubnub.api.enums.PNStatusCategory
+import com.pubnub.api.models.consumer.PNStatus
 import com.pubnub.internal.eventengine.EffectDispatcher
 import com.pubnub.internal.eventengine.EventEngineConf
 import com.pubnub.internal.managers.ListenerManager
@@ -31,37 +34,41 @@ internal interface Presence {
             executorService: ScheduledExecutorService,
         ): Presence {
             if (heartbeatInterval <= Duration.ZERO) {
-                return PresenceNoOp(suppressLeaveEvents, leaveProvider)
-            }
-
-            val effectFactory =
-                PresenceEffectFactory(
-                    heartbeatProvider = heartbeatProvider,
-                    leaveProvider = leaveProvider,
-                    presenceEventSink = eventEngineConf.eventSink,
-                    executorService = executorService,
-                    heartbeatInterval = heartbeatInterval,
-                    suppressLeaveEvents = suppressLeaveEvents,
-                    heartbeatNotificationOptions = heartbeatNotificationOptions,
-                    statusConsumer = listenerManager,
-                    presenceData = presenceData,
-                    sendStateWithHeartbeat = sendStateWithHeartbeat,
+                return PresenceNoOp(
+                    suppressLeaveEvents,
+                    leaveProvider,
+                    heartbeatProvider,
+                    listenerManager,
+                    heartbeatNotificationOptions,
+                    presenceData,
+                    sendStateWithHeartbeat
                 )
+            }
 
-            val eventEngineManager =
-                PresenceEventEngineManager(
-                    eventEngine =
-                        PresenceEventEngine(
-                            effectSink = eventEngineConf.effectSink,
-                            eventSource = eventEngineConf.eventSource,
-                        ),
-                    eventSink = eventEngineConf.eventSink,
-                    effectDispatcher =
-                        EffectDispatcher(
-                            effectFactory = effectFactory,
-                            effectSource = eventEngineConf.effectSource,
-                        ),
-                ).also { it.start() }
+            val effectFactory = PresenceEffectFactory(
+                heartbeatProvider = heartbeatProvider,
+                leaveProvider = leaveProvider,
+                presenceEventSink = eventEngineConf.eventSink,
+                executorService = executorService,
+                heartbeatInterval = heartbeatInterval,
+                suppressLeaveEvents = suppressLeaveEvents,
+                heartbeatNotificationOptions = heartbeatNotificationOptions,
+                statusConsumer = listenerManager,
+                presenceData = presenceData,
+                sendStateWithHeartbeat = sendStateWithHeartbeat,
+            )
+
+            val eventEngineManager = PresenceEventEngineManager(
+                eventEngine = PresenceEventEngine(
+                    effectSink = eventEngineConf.effectSink,
+                    eventSource = eventEngineConf.eventSource,
+                ),
+                eventSink = eventEngineConf.eventSink,
+                effectDispatcher = EffectDispatcher(
+                    effectFactory = effectFactory,
+                    effectSource = eventEngineConf.effectSource,
+                ),
+            ).also { it.start() }
 
             return EnabledPresence(eventEngineManager)
         }
@@ -101,6 +108,11 @@ internal interface Presence {
 internal class PresenceNoOp(
     private val suppressLeaveEvents: Boolean = false,
     private val leaveProvider: LeaveProvider,
+    private val heartbeatProvider: HeartbeatProvider,
+    private val listenerManager: ListenerManager,
+    private val heartbeatNotificationOptions: PNHeartbeatNotificationOptions,
+    private val presenceData: PresenceData,
+    private val sendStateWithHeartbeat: Boolean,
 ) : Presence {
     private val log = LoggerFactory.getLogger(PresenceNoOp::class.java)
     private val channels = mutableSetOf<String>()
@@ -113,6 +125,32 @@ internal class PresenceNoOp(
     ) {
         this.channels.addAll(channels)
         this.channelGroups.addAll(channelGroups)
+
+        // for subscribe with tt=0 this heartbeat call will be not needed because server generates implicit heartbeat for it
+        // but for now we don't offer possibility to enable smartHeartbeat that would eliminate this shortcoming.
+        if (channels.isNotEmpty() || channelGroups.isNotEmpty()) {
+            heartbeatProvider.getHeartbeatRemoteAction(
+                channels = channels,
+                channelGroups = channelGroups,
+                state = if (sendStateWithHeartbeat) {
+                    presenceData.channelStates
+                } else {
+                    null
+                },
+            ).async { result ->
+                result.onFailure { exception ->
+                    if (heartbeatNotificationOptions == PNHeartbeatNotificationOptions.ALL ||
+                        heartbeatNotificationOptions == PNHeartbeatNotificationOptions.FAILURES
+                    ) {
+                        listenerManager.announce(PNStatus(PNStatusCategory.PNHeartbeatFailed, PubNubException.from(exception)))
+                    }
+                }.onSuccess {
+                    if (heartbeatNotificationOptions == PNHeartbeatNotificationOptions.ALL) {
+                        listenerManager.announce(PNStatus(PNStatusCategory.PNHeartbeatSuccess))
+                    }
+                }
+            }
+        }
     }
 
     @Synchronized

pubnub-kotlin/pubnub-kotlin-impl/src/test/kotlin/com/pubnub/api/legacy/BaseTest.kt

@@ -2,6 +2,10 @@ package com.pubnub.api.legacy
 
 import com.github.tomakehurst.wiremock.WireMockServer
 import com.github.tomakehurst.wiremock.client.WireMock
+import com.github.tomakehurst.wiremock.client.WireMock.aResponse
+import com.github.tomakehurst.wiremock.client.WireMock.get
+import com.github.tomakehurst.wiremock.client.WireMock.stubFor
+import com.github.tomakehurst.wiremock.client.WireMock.urlMatching
 import com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig
 import com.pubnub.api.UserId
 import com.pubnub.api.enums.PNLogVerbosity
@@ -71,4 +75,36 @@ abstract class BaseTest {
     fun clearConfiguration() {
         config = PNConfiguration.builder(userId = UserId(PubNubImpl.generateUUID()), "")
     }
+
+    protected fun stubForHeartbeatWhenHeartbeatIntervalIs0ThusPresenceEEDoesNotWork(
+        channels: Set<String>,
+        channelGroups: Set<String> = emptySet()
+    ) {
+        val channelsAsString = if (channels.isEmpty()) {
+            ","
+        } else {
+            channels.joinToString(separator = ",")
+        }
+        val channelGroupsAsString = if (channelGroups.isEmpty()) {
+            null
+        } else {
+            channelGroups.joinToString(separator = "%2C") // URL encode the comma separator
+        }
+
+        val baseUrl = "/v2/presence/sub-key/mySubscribeKey/channel/$channelsAsString/heartbeat"
+        val urlPattern = if (channelGroupsAsString != null) {
+            "$baseUrl\\?.*channel-group=$channelGroupsAsString.*"
+        } else {
+            "$baseUrl\\?.*"
+        }
+        stubFor(
+            get(urlMatching(urlPattern)).willReturn(
+                aResponse().withBody(
+                    """
+                    {"message":"OK","service":"Presence","status":200}  
+                    """.trimIndent()
+                )
+            )
+        )
+    }
 }

pubnub-kotlin/pubnub-kotlin-impl/src/test/kotlin/com/pubnub/api/legacy/PubNubImplTest.kt

@@ -56,7 +56,7 @@ class PubNubImplTest : BaseTest() {
     fun getVersionAndTimeStamp() {
         val version = PubNubImpl.SDK_VERSION
         val timeStamp = PubNubImpl.timestamp()
-        assertEquals("10.4.6", version)
+        assertEquals("10.4.7", version)
         assertTrue(timeStamp > 0)
     }