proxy: fix listener restart on connectivity change

When a device wakes up from Doze mode or switches networks (e.g. WiFi to 4G),
old TCP sockets may become silently dead. When connectivityChanged() is
called, the proxy client triggers a new HTTP request (getProxyInfos)
which succeeds since it uses a fresh socket, leading the client to
believe the connection is still UP.

Because the status doesn't change (Connected -> Connected),
launchConnectedCbs_ was not set, and restartListeners() was never invoked.
Consequently, push subscriptions and permanent puts were not renewed
on the proxy, causing the device to appear offline on the DHT.

This forces launchConnectedCbs_ to true on connectivityChanged, ensuring
that listeners and subscriptions are properly restarted.

include/opendht/default_types.h

@@ -159,13 +159,7 @@ public:
     {}
 
     static Value::Filter getFilter() { return EncryptedValue::getFilter(); }
-    virtual void unpackValue(const dht::Value& v) override
-    {
-        BaseClass::unpackValue(v);
-        id = v.id;
-    }
 
-    dht::Value::Id id {0}; /// Value ID of the trust request, used for deserialization only.
     std::string service;
     std::string conversationId;
     Blob payload;

include/opendht/dht_proxy_client.h

@@ -291,9 +291,14 @@ public:
     virtual size_t getStorageLimit() const override { return 0; }
     void setLocalStorageLimit(size_t) override {}
     virtual size_t getLocalStorageLimit() const override { return STORAGE_LIMIT_UNLIMITED; }
-    void connectivityChanged(sa_family_t) override { getProxyInfos(); }
+    void connectivityChanged(sa_family_t) override
+    {
+        launchConnectedCbs_ = true;
+        getProxyInfos();
+    }
     void connectivityChanged() override
     {
+        launchConnectedCbs_ = true;
         getProxyInfos();
         loopSignal_();
     }

include/opendht/dht_proxy_server.h

@@ -146,26 +146,6 @@ public:
 
     std::shared_ptr<DhtRunner> getNode() const { return dht_; }
 
-#ifdef OPENDHT_PUSH_NOTIFICATIONS
-    /**
-     * Decide whether a batch of values notified to a push listener must be
-     * delivered as a high (urgent) priority push notification.
-     *
-     * Only real-time call signaling — values whose pushType is "audioCall" or
-     * "videoCall", published at high priority (priority == 0) — warrants an
-     * urgent push. Every other notification (presence/connection-request
-     * refreshes carrying an empty pushType, value expirations, etc.) is sent at
-     * normal priority so it does not saturate the mobile platform's adaptive
-     * high-priority quota; once that quota is tripped, the platform silently
-     * drops genuine call pushes.
-     *
-     * @param values the values being notified to the listener.
-     * @param expired whether this notification is for expired (removed) values.
-     * @return true if the notification must be sent at high priority.
-     */
-    static bool isHighPriorityPush(const std::vector<std::shared_ptr<Value>>& values, bool expired) noexcept;
-#endif // OPENDHT_PUSH_NOTIFICATIONS
-
 private:
     class ConnectionListener;
     struct RestRouterTraitsTls;

src/dht_proxy_server.cpp

@@ -1134,25 +1134,6 @@ DhtProxyServer::handleCancelPushListen(const asio::error_code& ec,
         pushListeners_.erase(pushListener);
 }
 
-bool
-DhtProxyServer::isHighPriorityPush(const std::vector<std::shared_ptr<Value>>& values, bool expired) noexcept
-{
-    // Expired-value notifications (de-registration) are never time-critical.
-    if (expired)
-        return false;
-    // Promote to high (urgent) push priority only for real-time call signaling.
-    // Background traffic — most notably connection-request refreshes, which
-    // carry an empty pushType — stays at normal priority so it does not trip the
-    // mobile platform's adaptive high-priority quota, which would otherwise
-    // silently drop genuine call pushes once the high-priority noise ratio gets
-    // too high.
-    for (const auto& v : values) {
-        if (v->priority == 0 and (v->pushType == "videoCall" or v->pushType == "audioCall"))
-            return true;
-    }
-    return false;
-}
-
 bool
 DhtProxyServer::handlePushListen(const InfoHash& infoHash,
                                  const std::string& pushToken,
@@ -1195,23 +1176,20 @@ DhtProxyServer::handlePushListen(const InfoHash& infoHash,
         json["exp"] = json["ids"];
     }
 
-    const bool highPriority = isHighPriorityPush(values, expired);
+    auto minPriority = 1000u;
+    for (const auto& v : values)
+        minPriority = std::min(minPriority, v->priority);
 
-    if (logger_) {
-        auto minPriority = 1000u;
-        for (const auto& v : values)
-            minPriority = std::min(minPriority, v->priority);
-        logger_->debug("[proxy:server] [listen {}] [client {}] [session {}] [expired {}] [priority {}] [high {}] [values {}]",
+    if (logger_)
+        logger_->debug("[proxy:server] [listen {}] [client {}] [session {}] [expired {}] [priority {}] [values {}]",
                        infoHash,
                        clientId,
                        sessionCtx->sessionId,
                        expired,
                        minPriority,
-                       highPriority,
                        values.size());
-    }
 
-    sendPushNotification(pushToken, std::move(json), type, highPriority, topic);
+    sendPushNotification(pushToken, std::move(json), type, !expired and minPriority == 0, topic);
 
     return true;
 }

tests/test_dhtproxy.cpp

@@ -327,39 +327,4 @@ DhtProxyTester::testShutdownStop()
     CPPUNIT_ASSERT_EQUAL(2 * C, callback_count.load());
 }
 
-#ifdef OPENDHT_PUSH_NOTIFICATIONS
-void
-DhtProxyTester::testPushNotificationPriority()
-{
-    auto mkValue = [](unsigned priority, const std::string& pushType) {
-        auto v = std::make_shared<dht::Value>();
-        v->priority = priority;
-        v->pushType = pushType;
-        return v;
-    };
-
-    // Real-time call signaling at high priority => urgent push.
-    CPPUNIT_ASSERT(dht::DhtProxyServer::isHighPriorityPush({mkValue(0, "videoCall")}, false));
-    CPPUNIT_ASSERT(dht::DhtProxyServer::isHighPriorityPush({mkValue(0, "audioCall")}, false));
-
-    // Connection-request refresh (empty pushType) is noise => normal push.
-    CPPUNIT_ASSERT(!dht::DhtProxyServer::isHighPriorityPush({mkValue(0, "")}, false));
-
-    // Any other pushType is not a call => normal push.
-    CPPUNIT_ASSERT(!dht::DhtProxyServer::isHighPriorityPush({mkValue(0, "message")}, false));
-
-    // Expired (de-registration) notifications are never urgent, even for calls.
-    CPPUNIT_ASSERT(!dht::DhtProxyServer::isHighPriorityPush({mkValue(0, "videoCall")}, true));
-
-    // A call value explicitly published at normal priority stays normal.
-    CPPUNIT_ASSERT(!dht::DhtProxyServer::isHighPriorityPush({mkValue(1, "videoCall")}, false));
-
-    // Mixed batch: a single high-priority call value is enough to make it urgent.
-    CPPUNIT_ASSERT(dht::DhtProxyServer::isHighPriorityPush({mkValue(0, ""), mkValue(0, "videoCall")}, false));
-
-    // Empty batch => normal.
-    CPPUNIT_ASSERT(!dht::DhtProxyServer::isHighPriorityPush({}, false));
-}
-#endif // OPENDHT_PUSH_NOTIFICATIONS
-
 } // namespace test

tests/test_dhtproxy.h

@@ -21,9 +21,6 @@ class DhtProxyTester : public CppUnit::TestFixture
     CPPUNIT_TEST(testPutGet40KChars);
     CPPUNIT_TEST(testFuzzy);
     CPPUNIT_TEST(testShutdownStop);
-#ifdef OPENDHT_PUSH_NOTIFICATIONS
-    CPPUNIT_TEST(testPushNotificationPriority);
-#endif
     CPPUNIT_TEST_SUITE_END();
 
 public:
@@ -58,15 +55,6 @@ public:
 
     void testShutdownStop();
 
-#ifdef OPENDHT_PUSH_NOTIFICATIONS
-    /**
-     * The proxy must only request a high-priority push for real-time call
-     * signaling (audioCall/videoCall at priority 0); everything else stays at
-     * normal priority.
-     */
-    void testPushNotificationPriority();
-#endif
-
 private:
     dht::DhtRunner::Config clientConfig {};
     dht::DhtRunner nodePeer;