1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <csignal>
17 #include <dlfcn.h>
18 #include <file_ex.h>
19 #include <mutex>
20 #include <securec.h>
21 #include <set>
22 #include <string_view>
23 #include "common_utilities_hpp.h"
24 #include "frontend_api_handler.h"
25 #include "ui_action.h"
26 #include "ui_driver.h"
27 #include "ui_record.h"
28 #include "screen_copy.h"
29 #include "extension_c_api.h"
30 #include "extension_executor.h"
31 
32 namespace OHOS::uitest {
33     using namespace std;
34     static constexpr auto ERR_BAD_ARG = ErrCode::ERR_INVALID_INPUT;
35     static constexpr size_t LOG_BUF_SIZE = 512;
36     static constexpr LogType type = LogType::LOG_APP;
37     static string_view g_version = "";
38     static string g_lastErrorMessage = "";
39     static int32_t g_lastErrorCode = 0;
40     static mutex g_callThroughLock;
41     static mutex g_captureLock;
42     static mutex g_recordRunningLock;
43     static set<string> g_runningCaptures;
44 
45 #define EXTENSION_API_CHECK(cond, errorMessage, errorCode) \
46 do { \
47     if (!(cond)) { \
48         g_lastErrorMessage = (errorMessage); \
49         g_lastErrorCode = static_cast<int32_t>(errorCode); \
50         LOG_E("EXTENSION_API_CHECK failed: %{public}s", g_lastErrorMessage.c_str()); \
51         return RETCODE_FAIL; \
52     } \
53 } while (0)
54 
WriteToBuffer(ReceiveBuffer &buffer, string_view data)55     static RetCode WriteToBuffer(ReceiveBuffer &buffer, string_view data)
56     {
57         EXTENSION_API_CHECK(buffer.data != nullptr, "Illegal buffer pointer", ERR_BAD_ARG);
58         EXTENSION_API_CHECK(buffer.size != nullptr, "Illegal outLen pointer", ERR_BAD_ARG);
59         EXTENSION_API_CHECK(buffer.capacity > data.length(), "Char buffer capacity is not enough", ERR_BAD_ARG);
60         memcpy_s(buffer.data, buffer.capacity, data.data(), data.length());
61         *(buffer.size) = data.length();
62         buffer.data[*(buffer.size)] = 0;
63         return RETCODE_SUCCESS;
64     }
65 
GetUiTestVersion(ReceiveBuffer buffer)66     static RetCode GetUiTestVersion(ReceiveBuffer buffer)
67     {
68         return WriteToBuffer(buffer, g_version);
69     }
70 
PrintLog(int32_t level, Text label, Text format, va_list ap)71     static RetCode PrintLog(int32_t level, Text label, Text format, va_list ap)
72     {
73         EXTENSION_API_CHECK(level >= LogRank::DEBUG && level <= LogRank::ERROR, "Illegal log level", ERR_BAD_ARG);
74         EXTENSION_API_CHECK(label.data != nullptr && format.data != nullptr, "Illegal log tag/format", ERR_BAD_ARG);
75         char buf[LOG_BUF_SIZE];
76         EXTENSION_API_CHECK(vsprintf_s(buf, sizeof(buf), format.data, ap) >= 0, format.data, ERR_BAD_ARG);
77         if (level == LogRank::DEBUG) {
78             HILOG_DEBUG(type, "%{public}s", buf);
79         } else if (level == LogRank::INFO) {
80             HILOG_INFO(type, "%{public}s", buf);
81         } else if (level == LogRank::WARN) {
82             HILOG_WARN(type, "%{public}s", buf);
83         } else if (level == LogRank::ERROR) {
84             HILOG_ERROR(type, "%{public}s", buf);
85         }
86         return RETCODE_SUCCESS;
87     }
88 
GetAndClearLastError(int32_t *codeOut, ReceiveBuffer msgOut)89     static RetCode GetAndClearLastError(int32_t *codeOut, ReceiveBuffer msgOut)
90     {
91         if (codeOut == nullptr) {
92             LOG_E("Code receiver is nullptr, cannot write error");
93             return RETCODE_FAIL;
94         }
95         *codeOut = g_lastErrorCode;
96         auto ret = WriteToBuffer(msgOut, g_lastErrorMessage);
97         // clear error
98         g_lastErrorCode = ErrCode::NO_ERROR;
99         g_lastErrorMessage = "";
100         return ret;
101     }
102 
103 // input-errors of call-through api should also be passed through
104 #define CALL_THROUGH_CHECK(cond, message, code, asFatalError, fatalPtr) \
105 do { \
106     if (!(cond)) { \
107         LOG_E("Check condition (%{public}s) failed: %{public}s", #cond, string(message).c_str()); \
108         json errorJson; \
109         errorJson["code"] = (code); \
110         errorJson["message"] = (message); \
111         json replyJson; \
112         replyJson["exception"] = move(errorJson); \
113         WriteToBuffer(out, replyJson.dump()); \
114         if ((asFatalError) && (fatalPtr) != nullptr) { \
115             *(fatalPtr) = true; \
116         } \
117         return RETCODE_FAIL; \
118     } \
119 } while (0)
120 
CallThroughMessage(Text in, ReceiveBuffer out, bool *fatalError)121     static RetCode CallThroughMessage(Text in, ReceiveBuffer out, bool *fatalError)
122     {
123         auto ptr = fatalError;
124         CALL_THROUGH_CHECK(g_callThroughLock.try_lock(), "Disallow concurrent use", ERR_API_USAGE, false, ptr);
125         unique_lock<mutex> guard(g_callThroughLock, std::adopt_lock);
126         using namespace nlohmann;
127         using VT = nlohmann::detail::value_t;
128         static auto server = FrontendApiServer::Get();
129         CALL_THROUGH_CHECK(in.data != nullptr, "Null message", ERR_BAD_ARG, true, ptr);
130         CALL_THROUGH_CHECK(out.data != nullptr, "Null output buffer", ERR_BAD_ARG, true, ptr);
131         CALL_THROUGH_CHECK(out.size != nullptr, "Null output size pointer", ERR_BAD_ARG, true, ptr);
132         CALL_THROUGH_CHECK(fatalError != nullptr, "Null fatalError output pointer", ERR_BAD_ARG, true, ptr);
133         *fatalError = false;
134         auto message = json::parse(in.data, nullptr, false);
135         CALL_THROUGH_CHECK(!message.is_discarded(), "Illegal messsage, parse json failed", ERR_BAD_ARG, true, ptr);
136         auto hasProps = message.contains("api") && message.contains("this") && message.contains("args");
137         CALL_THROUGH_CHECK(hasProps, "Illegal messsage, api/this/args property missing", ERR_BAD_ARG, true, ptr);
138         auto api = message["api"];
139         auto caller = message["this"];
140         auto params = message["args"];
141         auto nullThis = caller.type() == VT::null;
142         CALL_THROUGH_CHECK(api.type() == VT::string, "Illegal api value type", ERR_BAD_ARG, true, ptr);
143         CALL_THROUGH_CHECK(caller.type() == VT::string || nullThis, "Illegal thisRef type", ERR_BAD_ARG, true, ptr);
144         CALL_THROUGH_CHECK(params.type() == VT::array, "Illegal api args type", ERR_BAD_ARG, true, ptr);
145         auto call = ApiCallInfo {
146             .apiId_ = api.get<string>(),
147             .callerObjRef_ = nullThis ? "" : caller.get<string>(),
148             .paramList_ = move(params)
149         };
150         auto reply = ApiReplyInfo();
151         server.Call(call, reply);
152         const auto errCode = reply.exception_.code_;
153         const auto isFatalErr = errCode == ErrCode::INTERNAL_ERROR || errCode == ErrCode::ERR_INTERNAL;
154         CALL_THROUGH_CHECK(errCode == ErrCode::NO_ERROR, reply.exception_.message_.c_str(), errCode, isFatalErr, ptr);
155         json result;
156         result["result"] = move(reply.resultValue_);
157         return WriteToBuffer(out, result.dump());
158     }
159 
SetCallbackMessageHandler(DataCallback handler)160     static RetCode SetCallbackMessageHandler(DataCallback handler)
161     {
162         EXTENSION_API_CHECK(handler != nullptr, "Null callback handler!", ERR_BAD_ARG);
163         FrontendApiServer::Get().SetCallbackHandler([handler](const ApiCallInfo& in, ApiReplyInfo& out) {
164             nlohmann::json msgJson;
165             msgJson["api"] = in.apiId_;
166             msgJson["this"] = in.callerObjRef_;
167             msgJson["args"] = in.paramList_;
168             auto msg = msgJson.dump();
169             handler(Text {msg.data(), msg.length()});
170         });
171         return RETCODE_SUCCESS;
172     }
173 
AtomicTouch(int32_t stage, int32_t px, int32_t py)174     static RetCode AtomicTouch(int32_t stage, int32_t px, int32_t py)
175     {
176         static auto driver = UiDriver();
177         EXTENSION_API_CHECK(stage >= ActionStage::DOWN && stage <= ActionStage::UP, "Illegal stage", ERR_BAD_ARG);
178         auto touch = GenericAtomicAction(static_cast<ActionStage>(stage), Point(px, py));
179         auto err = ApiCallErr(NO_ERROR);
180         UiOpArgs uiOpArgs;
181         driver.PerformTouch(touch, uiOpArgs, err);
182         EXTENSION_API_CHECK(err.code_ == NO_ERROR, err.message_, err.code_);
183         return RETCODE_SUCCESS;
184     }
185 
StopCapture(Text name)186     static RetCode StopCapture(Text name)
187     {
188         EXTENSION_API_CHECK(name.data != nullptr, "Illegal name/callback", ERR_BAD_ARG);
189         unique_lock<mutex> guard(g_captureLock);
190         if (g_runningCaptures.find(name.data) == g_runningCaptures.end()) {
191             return RETCODE_SUCCESS;
192         }
193         if (strcmp(name.data, "copyScreen") == 0) {
194             StopScreenCopy();
195         } else if (strcmp(name.data, "recordUiAction") == 0) {
196             UiDriverRecordStop();
197             g_recordRunningLock.lock(); // this cause waiting for recordThread exit
198             g_recordRunningLock.unlock();
199         } else if (strcmp(name.data, "dumpLayout") != 0) {
200             EXTENSION_API_CHECK(false, string("Illegal capture type: ") + name.data, ERR_BAD_ARG);
201         }
202         g_runningCaptures.erase(name.data);
203         return RETCODE_SUCCESS;
204     }
205 
StartCapture(Text name, DataCallback callback, Text optJson)206     static RetCode StartCapture(Text name, DataCallback callback, Text optJson)
207     {
208         static auto driver = UiDriver();
209         EXTENSION_API_CHECK(name.data != nullptr && callback != nullptr, "Illegal name/callback", ERR_BAD_ARG);
210         nlohmann::json options = nullptr;
211         if (optJson.data != nullptr) {
212             options = nlohmann::json::parse(optJson.data, nullptr, false);
213             EXTENSION_API_CHECK(!options.is_discarded(), "Illegal optJson format", ERR_BAD_ARG);
214         }
215         unique_lock<mutex> guard(g_captureLock);
216         const auto running = g_runningCaptures.find(name.data) != g_runningCaptures.end();
217         EXTENSION_API_CHECK(!running, string("Capture already running: ") + name.data, -1);
218         g_runningCaptures.insert(name.data);
219         guard.unlock();
220         if (strcmp(name.data, "dumpLayout") == 0) {
221             nlohmann::json tree;
222             ApiCallErr err(NO_ERROR);
223             driver.DumpUiHierarchy(tree, false, false, err);
224             g_runningCaptures.erase("dumpLayout"); // dumpLayout is sync&once
225             EXTENSION_API_CHECK(err.code_ == NO_ERROR, err.message_, err.code_);
226             auto layout = tree.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace);
227             callback(Text{layout.c_str(), layout.length()});
228         } else if (strcmp(name.data, "copyScreen") == 0) {
229             float scale = 1.0f;
230             if (options.type() == nlohmann::detail::value_t::object && options.contains("scale")) {
231                 nlohmann::json val = options["scale"];
232                 EXTENSION_API_CHECK(val.type() == detail::value_t::number_float, "Illegal scale value", ERR_BAD_ARG);
233                 scale = val.get<float>();
234             }
235             StartScreenCopy(scale, [callback](uint8_t *data, size_t len) {
236                 callback(Text{reinterpret_cast<const char *>(data), len});
237                 free(data);
238             });
239         } else if (strcmp(name.data, "recordUiAction") == 0) {
240             UiDriverRecordStop();
241             g_recordRunningLock.lock(); // wait for running thread terminates
242             g_recordRunningLock.unlock();
243             auto recordThread = thread([callback]() {
244                 g_recordRunningLock.lock();
245                 UiDriverRecordStart([callback](nlohmann::json record) {
246                     auto data = record.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace);
247                     callback(Text{data.c_str(), data.length()});
248                     }, "");
249                 g_recordRunningLock.unlock();
250             });
251             recordThread.detach();
252         } else {
253             EXTENSION_API_CHECK(false, string("Illegal capture type: ") + name.data, ERR_BAD_ARG);
254         }
255         return RETCODE_SUCCESS;
256     }
257 
InitLowLevelFunctions(LowLevelFunctions *out)258     static RetCode InitLowLevelFunctions(LowLevelFunctions *out)
259     {
260         EXTENSION_API_CHECK(out != nullptr, "Null LowLevelFunctions recveive pointer", ERR_BAD_ARG);
261         out->callThroughMessage = CallThroughMessage;
262         out->setCallbackMessageHandler = SetCallbackMessageHandler;
263         out->atomicTouch = AtomicTouch;
264         out->startCapture = StartCapture;
265         out->stopCapture = StopCapture;
266         return RETCODE_SUCCESS;
267     }
268 
ExecuteExtension(string_view version, int32_t argc, char *argv[])269     bool ExecuteExtension(string_view version, int32_t argc, char *argv[])
270     {
271         int32_t used_argc = 0;
272         const char *name = "agent.so";
273         if (argc > 1 && string_view(argv[0]) == "--extension-name") {
274             name = argv[1];
275             used_argc = TWO; // argv0,1 is consumed, donot pass down
276         }
277         string extensionPath = string("/data/local/tmp/") + name;
278         g_version = version;
279         if (!OHOS::FileExists(extensionPath.data())) {
280             LOG_E("Client nativeCode not exist");
281             return false;
282         }
283         auto handle = dlopen(extensionPath.data(), RTLD_LAZY);
284         if (handle == nullptr) {
285             LOG_E("Dlopen %{public}s failed: %{public}s", extensionPath.data(), dlerror());
286             return false;
287         }
288         auto symInit = dlsym(handle, UITEST_EXTENSION_CALLBACK_ONINIT);
289         if (symInit == nullptr) {
290             LOG_E("Dlsym failed:" UITEST_EXTENSION_CALLBACK_ONINIT);
291             dlclose(handle);
292             return false;
293         }
294         auto symRun = dlsym(handle, UITEST_EXTENSION_CALLBACK_ONRUN);
295         if (symRun == nullptr) {
296             LOG_E("Dlsym failed: " UITEST_EXTENSION_CALLBACK_ONRUN);
297             dlclose(handle);
298             return false;
299         }
300         auto initFunction = reinterpret_cast<UiTestExtensionOnInitCallback>(symInit);
301         auto runFunction = reinterpret_cast<UiTestExtensionOnRunCallback>(symRun);
302         auto port = UiTestPort {
303             .getUiTestVersion = GetUiTestVersion,
304             .printLog = PrintLog,
305             .getAndClearLastError = GetAndClearLastError,
306             .initLowLevelFunctions = InitLowLevelFunctions,
307         };
308         if (initFunction(port, argc - used_argc, argv + used_argc) != RETCODE_SUCCESS) {
309             LOG_I("Initialize UiTest extension failed");
310             dlclose(handle);
311             return false;
312         }
313         auto ret = runFunction() == RETCODE_SUCCESS;
314         dlclose(handle);
315         return ret;
316     }
317 } // namespace OHOS::uitest
318