1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <functional> 20 #include <optional> 21 #include <string> 22 23 #include "adb.h" 24 #include "adb_unique_fd.h" 25 #include "sysdeps.h" 26 #include "transport.h" 27 28 // Explicitly check the adb server version. 29 // All of the commands below do this implicitly. 30 // Only the first invocation of this function will check the server version. 31 bool adb_check_server_version(std::string* _Nonnull error); 32 33 // Connect to adb, connect to the named service, and return a valid fd for 34 // interacting with that service upon success or a negative number on failure. 35 int adb_connect(std::string_view service, std::string* _Nonnull error); 36 37 // Same as above, except returning the TransportId for the service that we've connected to. 38 // force_switch_device forces the function to attempt to select a device, even if the service 39 // string appears to be a host: service (for use with host services that are device specific, like 40 // forward). 41 int adb_connect(TransportId* _Nullable id, std::string_view service, std::string* _Nonnull error, 42 bool force_switch_device = false); 43 44 // Kill the currently running adb server, if it exists. 45 bool adb_kill_server(); 46 47 // Connect to adb, connect to the named service, returns true if the connection 48 // succeeded AND the service returned OKAY. Outputs any returned error otherwise. 49 bool adb_command(const std::string& service); 50 51 // Connects to the named adb service and fills 'result' with the response. 52 // Returns true on success; returns false and fills 'error' on failure. 53 bool adb_query(const std::string& service, std::string* _Nonnull result, 54 std::string* _Nonnull error); 55 56 // Set the preferred transport to connect to. 57 void adb_set_transport(TransportType type, const char* _Nullable serial, TransportId transport_id); 58 void adb_get_transport(TransportType* _Nullable type, const char* _Nullable* _Nullable serial, 59 TransportId* _Nullable transport_id); 60 61 // Set the socket specification for the adb server. 62 // This function can only be called once, and the argument must live to the end of the process. 63 void adb_set_socket_spec(const char* _Nonnull socket_spec); 64 65 // Send commands to the current emulator instance. Will fail if there is not 66 // exactly one emulator connected (or if you use -s <serial> with a <serial> 67 // that does not designate an emulator). 68 int adb_send_emulator_command(int argc, const char* _Nonnull* _Nonnull argv, 69 const char* _Nullable serial); 70 71 // Reads a standard adb status response (OKAY|FAIL) and returns true in the 72 // event of OKAY, false in the event of FAIL or protocol error. 73 bool adb_status(borrowed_fd fd, std::string* _Nonnull error); 74 75 // Create a host command corresponding to selected transport type/serial. 76 std::string format_host_command(const char* _Nonnull command); 77 78 // Get the feature set of the current preferred transport. 79 const std::optional<FeatureSet>& adb_get_feature_set(std::string* _Nullable error); 80 81 #if defined(__linux__) 82 // Get the path of a file containing the path to the server executable, if the socket spec set via 83 // adb_set_socket_spec is a local one. 84 std::optional<std::string> adb_get_server_executable_path(); 85 #endif 86 87 // Globally acccesible argv/envp, for the purpose of re-execing adb. 88 extern const char* _Nullable * _Nullable __adb_argv; 89 extern const char* _Nullable * _Nullable __adb_envp; 90 91 // ADB Secure DNS service interface. Used to query what ADB Secure DNS services have been 92 // resolved, and to run some kind of callback for each one. 93 using adb_secure_foreach_service_callback = 94 std::function<void(const char* _Nonnull service_name, const char* _Nonnull reg_type, 95 const char* _Nonnull ip_address, uint16_t port)>; 96 97 // Queries pairing/connect services that have been discovered and resolved. 98 // If |host_name| is not null, run |cb| only for services 99 // matching |host_name|. Otherwise, run for all services. 100 void adb_secure_foreach_pairing_service(const char* _Nullable service_name, 101 adb_secure_foreach_service_callback cb); 102 void adb_secure_foreach_connect_service(const char* _Nullable service_name, 103 adb_secure_foreach_service_callback cb); 104 // Tries to connect to a |service_name| if found. Returns true if found and 105 // connected, false otherwise. 106 bool adb_secure_connect_by_service_name(const char* _Nonnull service_name); 107