链接处理。

ClientCore/ClientCore.cpp

@@ -22,31 +22,66 @@ void ClientCore::DoConnect(const QString& ip, quint16 port)
 {
     // qDebug() << "doConnect thread:" << QThread::currentThread();
     emit connecting();
-    if (!Connect(ip, port)) {
+    asio::co_spawn(
-        emit conFailed();
+        mSocket_.get_executor(),
-        return;
+        [this, ip, port]() -> asio::awaitable<void> {
-    }
+            try {
-    emit conSuccess();
+                bool success = co_await Connect(ip, port);
+
+                QMetaObject::invokeMethod(this, [this, success]() {
+                    if (success) {
+                        emit conSuccess();
+                    } else {
+                        emit conFailed();
+                    }
+                });
+            } catch (const std::exception& ex) {
+                QString error = ex.what();
+                QMetaObject::invokeMethod(this, [this, error]() {
+                    qCritical() << "连接异常:" << error;
+                    emit conFailed();
+                });
+            }
+        },
+        asio::detached);
 }
 
-bool ClientCore::Connect(const QString& ip, quint16 port)
+asio::awaitable<bool> ClientCore::Connect(const QString& ip, quint16 port)
 {
     if (connected_) {
         qInfo() << QString(tr("已连接。"));
-        return true;
+        co_return true;
     }
     try {
-        asio::ip::tcp::resolver resolver(ioContext_);
+        asio::steady_timer timer(co_await asio::this_coro::executor);
-        asio::ip::tcp::resolver::results_type endpoints = resolver.resolve(ip.toStdString(), std::to_string(port));
+        timer.expires_after(std::chrono::seconds(5));
-        asio::connect(mSocket_, endpoints);
+
-        return true;
+        asio::cancellation_signal cancelSignal;
+        auto cancelSlot = cancelSignal.slot();
+
+        asio::co_spawn(
+            co_await asio::this_coro::executor,
+            [this, &cancelSignal, &timer]() -> asio::awaitable<void> {
+                try {
+                    co_await timer.async_wait(asio::use_awaitable);
+                } catch (...) {
+                    co_return;
+                }
+            },
+            asio::detached);
+
+        asio::ip::tcp::resolver resolver(co_await asio::this_coro::executor);
+        auto endpoints = co_await resolver.async_resolve(ip.toStdString(), std::to_string(port), asio::use_awaitable);
+        auto endpoint =
+            co_await asio::async_connect(mSocket_, endpoints, asio::bind_cancellation_slot(cancelSlot, asio::use_awaitable));
+        co_return true;
     } catch (const std::exception& ex) {
         qCritical() << QString(tr("%1:%2 连接失败。%3")).arg(ip).arg(port).arg(ex.what());
-        return false;
+        co_return false;
     }
     qInfo() << QString(tr("%1:%2 连接成功。")).arg(ip).arg(port);
     connected_ = true;
-    return true;
+    co_return true;
 }
 
 void ClientCore::Disconnect()
@@ -316,7 +351,7 @@ asio::awaitable<bool> ClientCore::Send(QSharedPointer<FrameBuffer> frame)
 asio::awaitable<bool> ClientCore::Send(const char* data, size_t size)
 {
     try {
-        //auto c = mSocket_.get_executor();
+        // auto c = mSocket_.get_executor();
         auto bytes_transferred = co_await asio::async_write(mSocket_, asio::buffer(data, size), asio::use_awaitable);
         co_return bytes_transferred == size;
     } catch (std::exception& e) {

ClientCore/ClientCore.h

@@ -34,7 +34,7 @@ public slots:
 
 public:
     void Instance();
-    bool Connect(const QString& ip, quint16 port);
+    asio::awaitable<bool> Connect(const QString& ip, quint16 port);
     bool IsConnect();
     const asio::any_io_executor& get_executor();
     template <typename T> asio::awaitable<bool> Send(const T& info, FrameBufferType type, const QString& tid)