| // Copyright (C) 2016 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #pragma once |
| |
| #include "android/base/Optional.h" |
| #include "android/base/StringView.h" |
| #include "android/base/async/Looper.h" |
| #include "android/base/system/System.h" |
| #include "android/base/threads/ParallelTask.h" |
| |
| #include <fstream> |
| #include <functional> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| namespace android { |
| namespace emulation { |
| |
| class AdbCommand; |
| using AdbCommandPtr = std::shared_ptr<AdbCommand>; |
| |
| // Encapsulates the result of running an ADB command. |
| struct AdbCommandResult { |
| // Exit code returned by ADB. |
| android::base::System::ProcessExitCode exit_code; |
| |
| // The command's output. |
| // NOTE: we're using unique_ptr here because there's a bug in g++ 4 due to |
| // which file streams are unmovable. |
| mutable std::unique_ptr<std::ifstream> output; |
| }; |
| using OptionalAdbCommandResult = android::base::Optional<AdbCommandResult>; |
| |
| // A utility interface used to automatically locate the ADB binary and |
| // asynchronously run ADB commands. |
| class AdbInterface { |
| public: |
| // Returns true is the ADB version is fresh enough. |
| virtual bool isAdbVersionCurrent() const = 0; |
| |
| // Setup a custom adb path. |
| virtual void setCustomAdbPath(const std::string& path) = 0; |
| |
| // Returns the automatically detected path to adb |
| virtual const std::string& detectedAdbPath() const = 0; |
| |
| // Setup the port this interface is connected to |
| virtual void setSerialNumberPort(int port) = 0; |
| |
| // Runs an adb command asynchronously. |
| // |args| - the arguments to pass to adb, i.e. "shell dumpsys battery" |
| // |result_callback| - the callback function that will be invoked on the |
| // calling |
| // thread after the command completes. |
| // |timeout_ms| - how long to wait for the command to complete, in |
| // milliseconds. |
| // |want_output| - if set to true, the argument passed to the callback will |
| // contain the |
| // output of the command. |
| virtual AdbCommandPtr runAdbCommand( |
| const std::vector<std::string>& args, |
| std::function<void(const OptionalAdbCommandResult&)> |
| result_callback, |
| base::System::Duration timeout_ms, |
| bool want_output = true) = 0; |
| |
| // Creates a new instance of the AdbInterface. |
| static std::unique_ptr<AdbInterface> create(android::base::Looper* looper); |
| }; |
| |
| class AdbInterfaceImpl; |
| class TestAdbInterface; |
| |
| // Representation of an asynchronously running ADB command. |
| // These shouldn't be created directly, use AdbInterface::runAdbCommand. |
| class AdbCommand : public std::enable_shared_from_this<AdbCommand> { |
| friend android::emulation::AdbInterfaceImpl; |
| friend android::emulation::TestAdbInterface; |
| |
| public: |
| using ResultCallback = std::function<void(const OptionalAdbCommandResult&)>; |
| |
| // Returns true if the command is currently in the process of execution. |
| bool inFlight() const { return static_cast<bool>(mTask); } |
| |
| // Cancels the running command (has no effect if the command isn't running). |
| void cancel() { mCancelled = true; } |
| |
| private: |
| AdbCommand(android::base::Looper* looper, |
| const std::string& adb_path, |
| const std::string& serial_string, |
| const std::vector<std::string>& command, |
| bool want_output, |
| base::System::Duration timeout, |
| ResultCallback callback); |
| void start(int checkTimeoutMs = 1000); |
| void taskFunction(OptionalAdbCommandResult* result); |
| void taskDoneFunction(const OptionalAdbCommandResult& result); |
| |
| android::base::Looper* mLooper; |
| std::unique_ptr<android::base::ParallelTask<OptionalAdbCommandResult>> |
| mTask; |
| ResultCallback mResultCallback; |
| bool mCancelled = false; |
| std::string mOutputFilePath; |
| std::vector<std::string> mCommand; |
| bool mWantOutput; |
| int mTimeout; |
| bool mFinished; |
| }; |
| } |
| } |