Improve ADB utilization within Android platform

[ovyalov]

Summary

• Extract sync commands like push/pull file and stat into SyncService so ADB connection that's switched in sync mode can be reused for multiple sync commands. Improves a few aspects:
  1. No ADB re-connection on every file push/pull
     1. host:transport: and sync commands are called only once per connection.
• Reuse the same ADB connection for all shell commands fired by PlatformAndroid. Improves following aspects:
  1. No ADB re-connection on every shell command
     1. host:transport: is called only once per connection.

[labath]

Is AdbClient getting big enough to deserve a couple of unit tests? All it would take is to add the ability to specify the address to connect to and make a small mock server that listens at that address?

[ovyalov]

In D21770#469876, @labath wrote:

Is AdbClient getting big enough to deserve a couple of unit tests? All it would take is to add the ability to specify the address to connect to and make a small mock server that listens at that address?

It makes sense to do - presumably it might be a non-trivial change but worth doing as a long-term investment.

[ovyalov]

If you okay with that I'd like to submit this CL as-is and come up with unit test with a separate change list.

[labath]

ok, sounds good.

[ovyalov]

Files:

/lldb/trunk/source/Plugins/Platform/Android/AdbClient.cpp
/lldb/trunk/source/Plugins/Platform/Android/AdbClient.h
/lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp
/lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.h
/lldb/trunk/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

Users:

ovyalov (Author)

http://reviews.llvm.org/rL274256

source/Plugins/Platform/Android/AdbClient.h

 #ifndef liblldb_AdbClient_h_
 #define liblldb_AdbClient_h_
 
 // C Includes
 
 // C++ Includes
 
 #include <list>
+#include <memory>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/Core/Error.h"
-#include "lldb/Host/ConnectionFileDescriptor.h"
 
 namespace lldb_private {
 
 class FileSpec;
 
 namespace platform_android {
 
 class AdbClient
 {
 public:
     enum UnixSocketNamespace
     {
         UnixSocketNamespaceAbstract,
         UnixSocketNamespaceFileSystem,
     };
 
     using DeviceIDList = std::list<std::string>;
 
+    class SyncService
+    {
+        friend class AdbClient;
+
+    public:
+        ~SyncService ();
+
+        Error
+        PullFile (const FileSpec &remote_file, const FileSpec &local_file);
+
+        Error
+        PushFile (const FileSpec &local_file, const FileSpec &remote_file);
+
+        Error
+        Stat (const FileSpec &remote_file, uint32_t &mode, uint32_t &size, uint32_t &mtime);
+
+    private:
+        explicit SyncService (std::unique_ptr<Connection> &&conn);
+
+        Error
+        SendSyncRequest (const char *request_id, const uint32_t data_len, const void *data);
+
+        Error
+        ReadSyncHeader (std::string &response_id, uint32_t &data_len); 
+
+        Error
+        PullFileChunk (std::vector<char> &buffer, bool &eof);
+
+        Error
+        ReadAllBytes (void *buffer, size_t size);
+
+
+        const std::unique_ptr<Connection> m_conn;   
+    };
+
     static Error
     CreateByDeviceID(const std::string &device_id, AdbClient &adb);
 
-    AdbClient () = default;
+    AdbClient ();
     explicit AdbClient (const std::string &device_id);
 
+    ~AdbClient();
+
     const std::string&
     GetDeviceID() const;
 
     Error
     GetDevices (DeviceIDList &device_list);
 
     Error
     SetPortForwarding (const uint16_t local_port, const uint16_t remote_port);
 
     Error
     SetPortForwarding (const uint16_t local_port,
                        const char* remote_socket_name,
                        const UnixSocketNamespace socket_namespace);
 
     Error
     DeletePortForwarding (const uint16_t local_port);
 
     Error
-    PullFile (const FileSpec &remote_file, const FileSpec &local_file);
-
-    Error
-    PushFile (const FileSpec &local_file, const FileSpec &remote_file);
+    Shell (const char* command, uint32_t timeout_ms, std::string* output);
 
-    Error
-    Stat (const FileSpec &remote_file, uint32_t &mode, uint32_t &size, uint32_t &mtime);
+    std::unique_ptr<SyncService>
+    GetSyncService (Error &error);
 
     Error
-    Shell (const char* command, uint32_t timeout_ms, std::string* output);
+    SwitchDeviceTransport ();
 
 private:
     Error
     Connect ();
 
     void
     SetDeviceID (const std::string &device_id);
 
     Error
-    SendMessage (const std::string &packet, const bool reconnect = true);
+    SendMessage (const std::string &packet);
 
     Error
     SendDeviceMessage (const std::string &packet);
 
     Error
-    SendSyncRequest (const char *request_id, const uint32_t data_len, const void *data);
-
-    Error
-    ReadSyncHeader (std::string &response_id, uint32_t &data_len);
-
-    Error
     ReadMessage (std::vector<char> &message);
 
     Error
     ReadMessageStream (std::vector<char> &message, uint32_t timeout_ms);
 
     Error
     GetResponseError (const char *response_id);
 
     Error
     ReadResponseStatus ();
 
     Error
-    SwitchDeviceTransport ();
-
-    Error
     Sync ();
 
     Error
     StartSync ();
 
     Error
-    PullFileChunk (std::vector<char> &buffer, bool &eof);
-
-    Error
     ReadAllBytes (void *buffer, size_t size);
 
     std::string m_device_id;
-    ConnectionFileDescriptor m_conn;
+    std::unique_ptr<Connection> m_conn;
 };
 
 } // namespace platform_android
 } // namespace lldb_private
 
 #endif  // liblldb_AdbClient_h_
+

source/Plugins/Platform/Android/AdbClient.cpp

 //===-- AdbClient.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Other libraries and framework includes
+#include "AdbClient.h"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/FileUtilities.h"
+
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataEncoder.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/StreamString.h"
+#include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/FileUtilities.h"
-
-// Project includes
-#include "AdbClient.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <fstream>
 #include <sstream>
 
 using namespace lldb;

 // Maximum size of a filesync DATA packet.
 const size_t kMaxPushData = 2*1024;
 // Default mode for pushed files.
 const uint32_t kDefaultMode = 0100770; // S_IFREG | S_IRWXU | S_IRWXG
 
 const char * kSocketNamespaceAbstract = "localabstract";
 const char * kSocketNamespaceFileSystem = "localfilesystem";
 
+Error
+ReadAllBytes (Connection &conn, void *buffer, size_t size)
+{
+    using namespace std::chrono;
+
+    Error error;
+    ConnectionStatus status;
+    char *read_buffer = static_cast<char*>(buffer);
+
+    auto now = steady_clock::now();
+    const auto deadline = now + kReadTimeout;
+    size_t total_read_bytes = 0;
+    while (total_read_bytes < size && now < deadline)
+    {
+        uint32_t timeout_usec = duration_cast<microseconds>(deadline - now).count();
+        auto read_bytes =
+            conn.Read(read_buffer + total_read_bytes, size - total_read_bytes, timeout_usec, status, &error);
+        if (error.Fail ())
+            return error;
+        total_read_bytes += read_bytes;
+        if (status != eConnectionStatusSuccess)
+            break;
+        now = steady_clock::now();
+    }
+    if (total_read_bytes < size)
+        error = Error("Unable to read requested number of bytes. Connection status: %d.", status);
+    return error;
+}
+
 }  // namespace
 
 Error
 AdbClient::CreateByDeviceID(const std::string &device_id, AdbClient &adb)
 {
     DeviceIDList connect_devices;
     auto error = adb.GetDevices(connect_devices);
     if (error.Fail())
else
         if (find_it == connect_devices.end())
             return Error("Device \"%s\" not found", device_id.c_str());
 
         adb.SetDeviceID(*find_it);
     }
     return error;
 }
 
+AdbClient::AdbClient () {}
+
 AdbClient::AdbClient (const std::string &device_id)
     : m_device_id (device_id)
 {
 }
 
+AdbClient::~AdbClient() {}
+
 void
 AdbClient::SetDeviceID (const std::string &device_id)
 {
     m_device_id = device_id;
 }
 
 const std::string&
 AdbClient::GetDeviceID() const
 {
     return m_device_id;
 }
 
 Error
 AdbClient::Connect ()
 {
     Error error;
-    m_conn.Connect ("connect://localhost:5037", &error);
+    m_conn.reset (new ConnectionFileDescriptor);
+    m_conn->Connect ("connect://localhost:5037", &error);
 
     return error;
 }
 
 Error
 AdbClient::GetDevices (DeviceIDList &device_list)
 {
     device_list.clear ();
AdbClient::GetDevices (DeviceIDList &device_list)
 
     llvm::StringRef response (&in_buffer[0], in_buffer.size ());
     llvm::SmallVector<llvm::StringRef, 4> devices;
     response.split (devices, "\n", -1, false);
 
     for (const auto device: devices)
         device_list.push_back (device.split ('\t').first);
 
+    // Force disconnect since ADB closes connection after host:devices
+    // response is sent.
+    m_conn.reset ();
     return error;
 }
 
 Error
 AdbClient::SetPortForwarding (const uint16_t local_port, const uint16_t remote_port)
 {
     char message[48];
     snprintf (message, sizeof (message), "forward:tcp:%d;tcp:%d", local_port, remote_port);
AdbClient::DeletePortForwarding (const uint16_t local_port)
     const auto error = SendDeviceMessage (message);
     if (error.Fail ())
         return error;
 
     return ReadResponseStatus ();
 }
 
 Error
-AdbClient::SendMessage (const std::string &packet, const bool reconnect)
+AdbClient::SendMessage (const std::string &packet)
 {
     Error error;
-    if (reconnect)
+    if (!m_conn || !m_conn->IsConnected())
     {
         error = Connect ();
         if (error.Fail ())
             return error;
     }
 
     char length_buffer[5];
     snprintf (length_buffer, sizeof (length_buffer), "%04x", static_cast<int>(packet.size ()));
 
     ConnectionStatus status;
 
-    m_conn.Write (length_buffer, 4, status, &error);
+    m_conn->Write (length_buffer, 4, status, &error);
     if (error.Fail ())
         return error;
 
-    m_conn.Write (packet.c_str (), packet.size (), status, &error);
+    m_conn->Write (packet.c_str (), packet.size (), status, &error);
     return error;
 }
 
 Error
 AdbClient::SendDeviceMessage (const std::string &packet)
 {
     std::ostringstream msg;
     msg << "host-serial:" << m_device_id << ":" << packet;
AdbClient::ReadMessageStream (std::vector<char>& message, uint32_t timeout_ms)
     char buffer[1024];
     while (error.Success() && status == lldb::eConnectionStatusSuccess)
     {
         auto end = std::chrono::steady_clock::now();
         uint32_t elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
         if (elapsed_time >= timeout_ms)
             return Error("Timed out");
 
-        size_t n = m_conn.Read(buffer, sizeof(buffer), 1000 * (timeout_ms - elapsed_time), status, &error);
+        size_t n = m_conn->Read(buffer, sizeof(buffer), 1000 * (timeout_ms - elapsed_time), status, &error);
         if (n > 0)
             message.insert(message.end(), &buffer[0], &buffer[n]);
     }
     return error;
 }
 
 Error
 AdbClient::ReadResponseStatus()
AdbClient::SwitchDeviceTransport ()
     auto error = SendMessage (msg.str ());
     if (error.Fail ())
         return error;
 
     return ReadResponseStatus ();
 }
 
 Error
-AdbClient::PullFile (const FileSpec &remote_file, const FileSpec &local_file)
+AdbClient::StartSync ()
+{
+    auto error = SwitchDeviceTransport ();
+    if (error.Fail ())
+        return Error ("Failed to switch to device transport: %s", error.AsCString ());
+
+    error = Sync ();
+    if (error.Fail ())
+        return Error ("Sync failed: %s", error.AsCString ());
+
+    return error;
+}
+
+Error
+AdbClient::Sync ()
+{
+    auto error = SendMessage ("sync:");
+    if (error.Fail ())
+        return error;
+
+    return ReadResponseStatus ();
+}
+
+Error
+AdbClient::ReadAllBytes (void *buffer, size_t size)
+{
+    return ::ReadAllBytes (*m_conn, buffer, size);
+}
+
+Error
+AdbClient::Shell (const char* command, uint32_t timeout_ms, std::string* output)
 {
-    auto error = StartSync ();
-    if (error.Fail ())
+    StreamString adb_command;
+    adb_command.Printf("shell:%s", command);
+    auto error = SendMessage (adb_command.GetData());
+    if (error.Fail ())
+        return error;
+
+    error = ReadResponseStatus ();
+    if (error.Fail ())
+        return error;
+
+    std::vector<char> in_buffer;
+    error = ReadMessageStream (in_buffer, timeout_ms);
+    if (error.Fail())
         return error;
 
+    if (output)
+        output->assign(in_buffer.begin(), in_buffer.end());
+    return error;
+}
+
+std::unique_ptr<AdbClient::SyncService>
+AdbClient::GetSyncService (Error &error)
+{
+    std::unique_ptr<SyncService> sync_service;
+    error = StartSync ();
+    if (error.Success ())
+        sync_service.reset (new SyncService(std::move(m_conn)));
+
+    return sync_service;
+}
+
+Error
+AdbClient::SyncService::PullFile (const FileSpec &remote_file, const FileSpec &local_file)
+{
     const auto local_file_path = local_file.GetPath ();
     llvm::FileRemover local_file_remover (local_file_path.c_str ());
 
     std::ofstream dst (local_file_path, std::ios::out | std::ios::binary);
     if (!dst.is_open ())
         return Error ("Unable to open local file %s", local_file_path.c_str());
 
     const auto remote_file_path = remote_file.GetPath (false);
-    error = SendSyncRequest (kRECV, remote_file_path.length (), remote_file_path.c_str ());
+    auto error = SendSyncRequest (kRECV, remote_file_path.length (), remote_file_path.c_str ());
     if (error.Fail ())
         return error;
 
     std::vector<char> chunk;
     bool eof = false;
     while (!eof)
     {
         error = PullFileChunk (chunk, eof);
         if (error.Fail ())
             return error;
         if (!eof)
             dst.write (&chunk[0], chunk.size ());
     }
 
     local_file_remover.releaseFile ();
     return error;
 }
 
 Error
-AdbClient::PushFile (const FileSpec &local_file, const FileSpec &remote_file)
+AdbClient::SyncService::PushFile (const FileSpec &local_file, const FileSpec &remote_file)
 {
-    auto error = StartSync ();
-    if (error.Fail ())
-        return error;
-
     const auto local_file_path (local_file.GetPath ());
     std::ifstream src (local_file_path.c_str(), std::ios::in | std::ios::binary);
     if (!src.is_open ())
         return Error ("Unable to open local file %s", local_file_path.c_str());
 
     std::stringstream file_description;
     file_description << remote_file.GetPath(false).c_str() << "," << kDefaultMode;
     std::string file_description_str = file_description.str();
-    error = SendSyncRequest (kSEND, file_description_str.length(), file_description_str.c_str());
+    auto error = SendSyncRequest (kSEND, file_description_str.length(), file_description_str.c_str());
     if (error.Fail ())
         return error;
 
     char chunk[kMaxPushData];
     while (!src.eof() && !src.read(chunk, kMaxPushData).bad())
     {
         size_t chunk_size = src.gcount();
         error = SendSyncRequest(kDATA, chunk_size, chunk);
AdbClient::SyncService::PushFile (const FileSpec &local_file, const FileSpec &remote_file)
     // If there was an error reading the source file, finish the adb file
     // transfer first so that adb isn't expecting any more data.
     if (src.bad())
         return Error ("Failed read on %s", local_file_path.c_str());
     return error;
 }
 
 Error
-AdbClient::StartSync ()
+AdbClient::SyncService::Stat (const FileSpec &remote_file, uint32_t &mode, uint32_t &size, uint32_t &mtime)
 {
-    auto error = SwitchDeviceTransport ();
-    if (error.Fail ())
-        return Error ("Failed to switch to device transport: %s", error.AsCString ());
-
-    error = Sync ();
+    const std::string remote_file_path (remote_file.GetPath (false));
+    auto error = SendSyncRequest (kSTAT, remote_file_path.length (), remote_file_path.c_str ());
     if (error.Fail ())
-        return Error ("Sync failed: %s", error.AsCString ());
+        return Error ("Failed to send request: %s", error.AsCString ());
 
-    return error;
-}
+    static const size_t stat_len = strlen (kSTAT);
+    static const size_t response_len = stat_len + (sizeof (uint32_t) * 3);
 
-Error
-AdbClient::Sync ()
-{
-    auto error = SendMessage ("sync:", false);
+    std::vector<char> buffer (response_len);
+    error = ReadAllBytes (&buffer[0], buffer.size ());
     if (error.Fail ())
-        return error;
-
-    return ReadResponseStatus ();
-}
+        return Error ("Failed to read response: %s", error.AsCString ());
 
-Error
-AdbClient::PullFileChunk (std::vector<char> &buffer, bool &eof)
-{
-    buffer.clear ();
+    DataExtractor extractor (&buffer[0], buffer.size (), eByteOrderLittle, sizeof (void*));
+    offset_t offset = 0;
 
-    std::string response_id;
-    uint32_t data_len;
-    auto error = ReadSyncHeader (response_id, data_len);
-    if (error.Fail ())
-        return error;
+    const void* command = extractor.GetData (&offset, stat_len);
+    if (!command)
+        return Error ("Failed to get response command");
+    const char* command_str = static_cast<const char*> (command);
+    if (strncmp (command_str, kSTAT, stat_len))
+        return Error ("Got invalid stat command: %s", command_str);
 
-    if (response_id == kDATA)
-    {
-        buffer.resize (data_len, 0);
-        error = ReadAllBytes (&buffer[0], data_len);
-        if (error.Fail ())
-            buffer.clear ();
-    }
-    else if (response_id == kDONE)
-    {
-        eof = true;
-    }
-    else if (response_id == kFAIL)
-    {
-        std::string error_message (data_len, 0);
-        error = ReadAllBytes (&error_message[0], data_len);
-        if (error.Fail ())
-            return Error ("Failed to read pull error message: %s", error.AsCString ());
-        return Error ("Failed to pull file: %s", error_message.c_str ());
-    }
-    else
-        return Error ("Pull failed with unknown response: %s", response_id.c_str ());
+    mode = extractor.GetU32 (&offset);
+    size = extractor.GetU32 (&offset);
+    mtime = extractor.GetU32 (&offset);
+    return Error ();
+
+AdbClient::SyncService::SyncService(std::unique_ptr<Connection> &&conn):
+m_conn(std::move(conn))
 
-    return Error ();
-}
+AdbClient::SyncService::~SyncService () {}
 
 Error
-AdbClient::SendSyncRequest (const char *request_id, const uint32_t data_len, const void *data)
+AdbClient::SyncService::SendSyncRequest (const char *request_id, const uint32_t data_len, const void *data)
 {
     const DataBufferSP data_sp (new DataBufferHeap (kSyncPacketLen, 0));
     DataEncoder encoder (data_sp, eByteOrderLittle, sizeof (void*));
     auto offset = encoder.PutData (0, request_id, strlen(request_id));
     encoder.PutU32 (offset, data_len);
 
     Error error;
     ConnectionStatus status;
-    m_conn.Write (data_sp->GetBytes (), kSyncPacketLen, status, &error);
+    m_conn->Write (data_sp->GetBytes (), kSyncPacketLen, status, &error);
     if (error.Fail ())
         return error;
 
     if (data)
-        m_conn.Write (data, data_len, status, &error);
+        m_conn->Write (data, data_len, status, &error);
     return error;
 }
 
 Error
-AdbClient::ReadSyncHeader (std::string &response_id, uint32_t &data_len)
+AdbClient::SyncService::ReadSyncHeader (std::string &response_id, uint32_t &data_len)
 {
     char buffer[kSyncPacketLen];
 
     auto error = ReadAllBytes (buffer, kSyncPacketLen);
     if (error.Success ())
     {
         response_id.assign (&buffer[0], 4);
         DataExtractor extractor (&buffer[4], 4, eByteOrderLittle, sizeof (void*));
         offset_t offset = 0;
         data_len = extractor.GetU32 (&offset);
     }
 
     return error;
 }
 
 Error
-AdbClient::ReadAllBytes (void *buffer, size_t size)
+AdbClient::SyncService::PullFileChunk (std::vector<char> &buffer, bool &eof)
 {
-    using namespace std::chrono;
+    buffer.clear ();
 
-    Error error;
-    ConnectionStatus status;
-    char *read_buffer = static_cast<char*>(buffer);
+    std::string response_id;
+    uint32_t data_len;
+    auto error = ReadSyncHeader (response_id, data_len);
+    if (error.Fail ())
+        return error;
 
-    auto now = steady_clock::now();
-    const auto deadline = now + kReadTimeout;
-    size_t total_read_bytes = 0;
-    while (total_read_bytes < size && now < deadline)
+    if (response_id == kDATA)
     {
-        uint32_t timeout_usec = duration_cast<microseconds>(deadline - now).count();
-        auto read_bytes =
-            m_conn.Read(read_buffer + total_read_bytes, size - total_read_bytes, timeout_usec, status, &error);
+        buffer.resize (data_len, 0);
+        error = ReadAllBytes (&buffer[0], data_len);
         if (error.Fail ())
-            return error;
-        total_read_bytes += read_bytes;
-        if (status != eConnectionStatusSuccess)
-            break;
-        now = steady_clock::now();
+            buffer.clear ();
     }
-    if (total_read_bytes < size)
-        error = Error("Unable to read requested number of bytes. Connection status: %d.", status);
-    return error;
+    else if (response_id == kDONE)
+    {
+        eof = true;
     }
-
-Error
-AdbClient::Stat (const FileSpec &remote_file, uint32_t &mode, uint32_t &size, uint32_t &mtime)
+    else if (response_id == kFAIL)
     {
-    auto error = StartSync ();
-    if (error.Fail ())
-        return error;
-
-    const std::string remote_file_path (remote_file.GetPath (false));
-    error = SendSyncRequest (kSTAT, remote_file_path.length (), remote_file_path.c_str ());
-    if (error.Fail ())
-        return Error ("Failed to send request: %s", error.AsCString ());
-
-    static const size_t stat_len = strlen (kSTAT);
-    static const size_t response_len = stat_len + (sizeof (uint32_t) * 3);
-
-    std::vector<char> buffer (response_len);
-    error = ReadAllBytes (&buffer[0], buffer.size ());
+        std::string error_message (data_len, 0);
+        error = ReadAllBytes (&error_message[0], data_len);
         if (error.Fail ())
-        return Error ("Failed to read response: %s", error.AsCString ());
-
-    DataExtractor extractor (&buffer[0], buffer.size (), eByteOrderLittle, sizeof (void*));
-    offset_t offset = 0;
-
-    const void* command = extractor.GetData (&offset, stat_len);
-    if (!command)
-        return Error ("Failed to get response command");
-    const char* command_str = static_cast<const char*> (command);
-    if (strncmp (command_str, kSTAT, stat_len))
-        return Error ("Got invalid stat command: %s", command_str);
+            return Error ("Failed to read pull error message: %s", error.AsCString ());
+        return Error ("Failed to pull file: %s", error_message.c_str ());
+    }
+    else
+        return Error ("Pull failed with unknown response: %s", response_id.c_str ());
 
-    mode = extractor.GetU32 (&offset);
-    size = extractor.GetU32 (&offset);
-    mtime = extractor.GetU32 (&offset);
     return Error ();
 }
 
 Error
-AdbClient::Shell (const char* command, uint32_t timeout_ms, std::string* output)
+AdbClient::SyncService::ReadAllBytes (void *buffer, size_t size)
 {
-    auto error = SwitchDeviceTransport ();
-    if (error.Fail ())
-        return Error ("Failed to switch to device transport: %s", error.AsCString ());
-
-    StreamString adb_command;
-    adb_command.Printf("shell:%s", command);
-    error = SendMessage (adb_command.GetData(), false);
-    if (error.Fail ())
-        return error;
-
-    error = ReadResponseStatus ();
-    if (error.Fail ())
-        return error;
-
-    std::vector<char> in_buffer;
-    error = ReadMessageStream (in_buffer, timeout_ms);
-    if (error.Fail())
-        return error;
-
-    if (output)
-        output->assign(in_buffer.begin(), in_buffer.end());
-    return error;
+    return ::ReadAllBytes (*m_conn, buffer, size);
 }
+

source/Plugins/Platform/Android/PlatformAndroid.h

 //===-- PlatformAndroid.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_PlatformAndroid_h_
 #define liblldb_PlatformAndroid_h_
 
 // C Includes
 // C++ Includes
+#include <memory>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/Linux/PlatformLinux.h"
 
+#include "AdbClient.h"
+
 namespace lldb_private {
 namespace platform_android {
 
     class PlatformAndroid : public platform_linux::PlatformLinux
     {
     public:
         PlatformAndroid(bool is_host);
 
protected:
         Error
         DownloadSymbolFile (const lldb::ModuleSP& module_sp,
                             const FileSpec& dst_file_spec) override;
 
         const char*
         GetLibdlFunctionDeclarations() const override;
 
     private:
+        std::unique_ptr<AdbClient> m_adb;
+        std::unique_ptr<AdbClient::SyncService> m_adb_sync_svc;
         std::string m_device_id;
         uint32_t m_sdk_version;
 
         DISALLOW_COPY_AND_ASSIGN (PlatformAndroid);
     };
 
 } // namespace platofor_android
 } // namespace lldb_private
 
 #endif // liblldb_PlatformAndroid_h_

source/Plugins/Platform/Android/PlatformAndroid.cpp

PlatformAndroid::ConnectRemote(Args& args)
     if (!UriParser::Parse(url, scheme, host, port, path))
         return Error("Invalid URL: %s", url);
     if (host != "localhost")
         m_device_id = host;
 
     auto error = PlatformLinux::ConnectRemote(args);
     if (error.Success())
     {
-        AdbClient adb;
-        error = AdbClient::CreateByDeviceID(m_device_id, adb);
+        m_adb.reset(new AdbClient);
+        error = AdbClient::CreateByDeviceID(m_device_id, *m_adb);
         if (error.Fail())
             return error;
 
-        m_device_id = adb.GetDeviceID();
+        m_device_id = m_adb->GetDeviceID();
+        m_adb_sync_svc = m_adb->GetSyncService(error);
+        if (error.Fail())
+            return error;
+
+        error = m_adb->SwitchDeviceTransport();
     }
     return error;
 }
 
 Error
 PlatformAndroid::GetFile (const FileSpec& source,
                           const FileSpec& destination)
 {
     if (IsHost() || !m_remote_platform_sp)
         return PlatformLinux::GetFile(source, destination);
 
     FileSpec source_spec (source.GetPath (false), false, FileSpec::ePathSyntaxPosix);
     if (source_spec.IsRelative())
         source_spec = GetRemoteWorkingDirectory ().CopyByAppendingPathComponent (source_spec.GetCString (false));
 
-    AdbClient adb (m_device_id);
-    return adb.PullFile (source_spec, destination);
+    return m_adb_sync_svc->PullFile (source_spec, destination);
 }
 
 Error
 PlatformAndroid::PutFile (const FileSpec& source,
                           const FileSpec& destination,
                           uint32_t uid,
                           uint32_t gid)
 {
     if (IsHost() || !m_remote_platform_sp)
         return PlatformLinux::PutFile (source, destination, uid, gid);
 
     FileSpec destination_spec (destination.GetPath (false), false, FileSpec::ePathSyntaxPosix);
     if (destination_spec.IsRelative())
         destination_spec = GetRemoteWorkingDirectory ().CopyByAppendingPathComponent (destination_spec.GetCString (false));
 
-    AdbClient adb (m_device_id);
     // TODO: Set correct uid and gid on remote file.
-    return adb.PushFile(source, destination_spec);
+    return m_adb_sync_svc->PushFile(source, destination_spec);
 }
 
 const char *
 PlatformAndroid::GetCacheHostname ()
 {
     return m_device_id.c_str ();
 }
 

 {
     if (!IsConnected())
         return 0;
 
     if (m_sdk_version != 0)
         return m_sdk_version;
 
     std::string version_string;
-    AdbClient adb(m_device_id);
-    Error error = adb.Shell("getprop ro.build.version.sdk", 5000 /* ms */, &version_string);
+    Error error = m_adb->Shell("getprop ro.build.version.sdk", 5000 /* ms */, &version_string);
     version_string = llvm::StringRef(version_string).trim().str();
 
     if (error.Fail() || version_string.empty())
     {
         Log* log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM);
         if (log)
             log->Printf("Get SDK version failed. (error: %s, output: %s)",
                         error.AsCString(), version_string.c_str());
PlatformAndroid::DownloadSymbolFile (const lldb::ModuleSP& module_sp,
     // Symbolizer isn't available before SDK version 23
     if (GetSdkVersion() < 23)
         return Error("Symbol file generation only supported on SDK 23+");
 
     // If we already have symtab then we don't have to try and generate one
     if (module_sp->GetSectionList()->FindSectionByName(ConstString(".symtab")) != nullptr)
         return Error("Symtab already available in the module");
 
-    AdbClient adb(m_device_id);
-
     std::string tmpdir;
-    Error error = adb.Shell("mktemp --directory --tmpdir /data/local/tmp", 5000 /* ms */, &tmpdir);
+    Error error = m_adb->Shell("mktemp --directory --tmpdir /data/local/tmp", 5000 /* ms */, &tmpdir);
     if (error.Fail() || tmpdir.empty())
         return Error("Failed to generate temporary directory on the device (%s)", error.AsCString());
     tmpdir = llvm::StringRef(tmpdir).trim().str();
 
     // Create file remover for the temporary directory created on the device
     std::unique_ptr<std::string, std::function<void(std::string*)>> tmpdir_remover(
         &tmpdir,
-        [this, &adb](std::string* s) {
+        [this](std::string* s) {
             StreamString command;
             command.Printf("rm -rf %s", s->c_str());
-            Error error = adb.Shell(command.GetData(), 5000 /* ms */, nullptr);
+            Error error = m_adb->Shell(command.GetData(), 5000 /* ms */, nullptr);
 
             Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
             if (error.Fail())
                 log->Printf("Failed to remove temp directory: %s", error.AsCString());
         }
     );
 
     FileSpec symfile_platform_filespec(tmpdir.c_str(), false);
     symfile_platform_filespec.AppendPathComponent("symbolized.oat");
 
     // Execute oatdump on the remote device to generate a file with symtab
     StreamString command;
     command.Printf("oatdump --symbolize=%s --output=%s",
                    module_sp->GetPlatformFileSpec().GetCString(false),
                    symfile_platform_filespec.GetCString(false));
-    error = adb.Shell(command.GetData(), 60000 /* ms */, nullptr);
+    error = m_adb->Shell(command.GetData(), 60000 /* ms */, nullptr);
     if (error.Fail())
         return Error("Oatdump failed: %s", error.AsCString());
 
     // Download the symbolfile from the remote device
     return GetFile(symfile_platform_filespec, dst_file_spec);
 }
 
 bool

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 //===-- PlatformAndroidRemoteGDBServer.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Other libraries and framework includes
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Host/common/TCPSocket.h"
+#include "lldb/Host/ConnectionFileDescriptor.h"
+
 #include "PlatformAndroidRemoteGDBServer.h"
 #include "Utility/UriParser.h"
 
 #include <sstream>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace platform_android;