diff --git a/adb.cpp b/adb.cpp
index 3b860c0..d0602ec 100644
--- a/adb.cpp
+++ b/adb.cpp
@@ -45,6 +45,8 @@
 #include <android-base/parsenetaddress.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <diagnose_usb.h>
+
 #include <build/version.h>
 #include <platform_tools_version.h>
 
@@ -108,8 +110,36 @@
     return sum;
 }
 
-apacket* get_apacket(void)
-{
+std::string to_string(ConnectionState state) {
+    switch (state) {
+        case kCsOffline:
+            return "offline";
+        case kCsBootloader:
+            return "bootloader";
+        case kCsDevice:
+            return "device";
+        case kCsHost:
+            return "host";
+        case kCsRecovery:
+            return "recovery";
+        case kCsRescue:
+            return "rescue";
+        case kCsNoPerm:
+            return UsbNoPermissionsShortHelpText();
+        case kCsSideload:
+            return "sideload";
+        case kCsUnauthorized:
+            return "unauthorized";
+        case kCsAuthorizing:
+            return "authorizing";
+        case kCsConnecting:
+            return "connecting";
+        default:
+            return "unknown";
+    }
+}
+
+apacket* get_apacket(void) {
     apacket* p = new apacket();
     if (p == nullptr) {
         LOG(FATAL) << "failed to allocate an apacket";
@@ -1326,7 +1356,7 @@
                 s->transport ? s->transport
                              : acquire_one_transport(type, serial, transport_id, nullptr, &error);
         if (t) {
-            SendOkay(reply_fd, t->connection_state_name());
+            SendOkay(reply_fd, to_string(t->GetConnectionState()));
         } else {
             SendFail(reply_fd, error);
         }
@@ -1353,8 +1383,8 @@
                                                              &response, true);
         if (t != nullptr) {
             kick_transport(t, true);
-            response =
-                    "reconnecting " + t->serial_name() + " [" + t->connection_state_name() + "]\n";
+            response = "reconnecting " + t->serial_name() + " [" +
+                       to_string(t->GetConnectionState()) + "]\n";
         }
         SendOkay(reply_fd, response);
         return HostRequestResult::Handled;
diff --git a/adb.h b/adb.h
index 437a207..801da1d 100644
--- a/adb.h
+++ b/adb.h
@@ -115,6 +115,8 @@
     kCsRescue,
 };
 
+std::string to_string(ConnectionState state);
+
 inline bool ConnectionStateIsOnline(ConnectionState state) {
     switch (state) {
         case kCsBootloader:
@@ -201,8 +203,6 @@
 bool local_connect(int port);
 int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error);
 
-ConnectionState connection_state(atransport* t);
-
 extern const char* adb_device_banner;
 
 #define CHUNK_SIZE (64 * 1024)
diff --git a/transport.cpp b/transport.cpp
index 1e13655..cfae25d 100644
--- a/transport.cpp
+++ b/transport.cpp
@@ -44,7 +44,6 @@
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android-base/thread_annotations.h>
-
 #include <diagnose_usb.h>
 
 #include "adb.h"
@@ -1203,38 +1202,6 @@
     });
 }
 
-std::string atransport::connection_state_name() const {
-    ConnectionState state = GetConnectionState();
-    switch (state) {
-        case kCsOffline:
-            return "offline";
-        case kCsBootloader:
-            return "bootloader";
-        case kCsDevice:
-            return "device";
-        case kCsHost:
-            return "host";
-        case kCsRecovery:
-            return "recovery";
-        case kCsRescue:
-            return "rescue";
-        case kCsNoPerm:
-            return UsbNoPermissionsShortHelpText();
-        case kCsSideload:
-            return "sideload";
-        case kCsUnauthorized:
-            return "unauthorized";
-        case kCsAuthorizing:
-            return "authorizing";
-        case kCsConnecting:
-            return "connecting";
-        case kCsDetached:
-            return "detached";
-        default:
-            return "unknown";
-    }
-}
-
 void atransport::update_version(int version, size_t payload) {
     protocol_version = std::min(version, A_VERSION);
     max_payload = std::min(payload, MAX_PAYLOAD);
@@ -1399,10 +1366,10 @@
     if (!long_listing) {
         *result += serial;
         *result += '\t';
-        *result += t->connection_state_name();
+        *result += to_string(t->GetConnectionState());
     } else {
         android::base::StringAppendF(result, "%-22s %s", serial.c_str(),
-                                     t->connection_state_name().c_str());
+                                     to_string(t->GetConnectionState()).c_str());
 
         append_transport_info(result, "", t->devpath, false);
         append_transport_info(result, "product:", t->product, false);
diff --git a/transport.h b/transport.h
index 20c47a1..35cecf8 100644
--- a/transport.h
+++ b/transport.h
@@ -335,7 +335,6 @@
     size_t failed_auth_attempts = 0;
 
     std::string serial_name() const { return !serial.empty() ? serial : "<unknown>"; }
-    std::string connection_state_name() const;
 
     void update_version(int version, size_t payload);
     int get_protocol_version() const;
diff --git a/transport_test.cpp b/transport_test.cpp
index 8579ff4..1a047aa 100644
--- a/transport_test.cpp
+++ b/transport_test.cpp
@@ -21,6 +21,19 @@
 #include "adb.h"
 #include "fdevent/fdevent_test.h"
 
+TEST(ConnectionStateTest, to_string) {
+    ASSERT_EQ("offline", to_string(ConnectionState::kCsOffline));
+    ASSERT_EQ("bootloader", to_string(ConnectionState::kCsBootloader));
+    ASSERT_EQ("device", to_string(ConnectionState::kCsDevice));
+    ASSERT_EQ("host", to_string(ConnectionState::kCsHost));
+    ASSERT_EQ("recovery", to_string(ConnectionState::kCsRecovery));
+    ASSERT_EQ("rescue", to_string(ConnectionState::kCsRescue));
+    ASSERT_EQ("sideload", to_string(ConnectionState::kCsSideload));
+    ASSERT_EQ("unauthorized", to_string(ConnectionState::kCsUnauthorized));
+    ASSERT_EQ("authorizing", to_string(ConnectionState::kCsAuthorizing));
+    ASSERT_EQ("connecting", to_string(ConnectionState::kCsConnecting));
+}
+
 struct TransportTest : public FdeventTest {};
 
 static void DisconnectFunc(void* arg, atransport*) {