1/*
2 * Copyright (C) 2021 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#include "unistd.h"
16#include <thread>
17#include <cstdio>
18#include <cstring>
19#include <map>
20#include <sstream>
21#include <iomanip>
22#include <future>
23#include "include/control_call_cmd.h"
24#include "include/startup_delay.h"
25#include "include/sp_utils.h"
26#include "include/parse_click_complete_trace.h"
27#include "include/parse_click_response_trace.h"
28#include "include/parse_radar.h"
29#include "include/parse_slide_fps_trace.h"
30#include "include/sp_log.h"
31#include "include/stalling_rate_trace.h"
32#include "common.h"
33
34namespace OHOS {
35namespace SmartPerf {
36std::string ControlCallCmd::GetResult(std::vector<std::string> v)
37{
38    IsohTest(v);
39    if (v[typeName] == "responseTime") {
40        time = SmartPerf::ControlCallCmd::ResponseTime();
41    } else if (v[typeName] == "completeTime") {
42        time = SmartPerf::ControlCallCmd::CompleteTime();
43    } else if (v[typeName] == "fpsohtest") {
44        std::string ohTestFps = CMD_COMMAND_MAP.at(CmdCommand::OHTESTFPS);
45        SPUtils::LoadCmd(ohTestFps, result);
46    } else if (v[typeName] == "frameLoss") {
47        result = SmartPerf::ControlCallCmd::GetFrame();
48    } else if (v[typeName] == "appStartTime") {
49        result = ControlCallCmd::GetAppStartTime();
50    } else if (v[typeName] == "slideList") {
51        result = ControlCallCmd::SlideList();
52    } else if (v[typeName] == "timeDelay") {
53        result = ControlCallCmd::TimeDelay();
54    }
55    if (time == noNameType) {
56        std::cout << "Startup error, unknown application or application not responding" << std::endl;
57    } else {
58        if (time != 0) {
59            stream << time;
60            result = "time:" + stream.str() + "ms";
61        }
62        std::cout << result << std::endl;
63    }
64    return result;
65}
66std::string ControlCallCmd::TimeDelay()
67{
68    OHOS::SmartPerf::ParseClickResponseTrace pcrt;
69    OHOS::SmartPerf::StartUpDelay sd;
70    std::string cmdResult;
71    OHOS::SmartPerf::ParseRadar radar;
72    OHOS::SmartPerf::StallingRateTrace srt;
73    std::string rmTrace = CMD_COMMAND_MAP.at(CmdCommand::RM_FILE) + std::string("sp_trace_") + "delay" + ".ftrace";
74    SPUtils::LoadCmd(rmTrace, cmdResult);
75    std::string traceName = std::string("/data/local/tmp/") + std::string("sp_trace_") + "delay" + ".ftrace";
76    std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
77    std::thread thGetHisysId = std::thread([&sd]() { sd.GetHisysIdAndKill(); });
78    std::promise<std::string> promResponse;
79    std::promise<std::string> promComplete;
80    std::promise<std::string> promRadarFrame;
81    std::promise<std::string> promResponseMoved = std::move(promResponse);
82    std::promise<std::string> promCompleteMoved = std::move(promComplete);
83    std::promise<std::string> promRadarFrameMoved = std::move(promRadarFrame);
84    std::future<std::string> futureResponse = promResponseMoved.get_future();
85    std::thread([promiseResponse = std::move(promResponseMoved)]() mutable {
86        promiseResponse.set_value(SPUtils::GetRadarResponse());
87    }).detach();
88    std::future<std::string> futureComplete = promCompleteMoved.get_future();
89    std::thread([promiseComplete = std::move(promCompleteMoved)]() mutable {
90        promiseComplete.set_value(SPUtils::GetRadarComplete());
91    }).detach();
92    std::future<std::string> futureRadarFrame = promRadarFrameMoved.get_future();
93    std::thread([promiseRadarFrame = std::move(promRadarFrameMoved)]() mutable {
94        promiseRadarFrame.set_value(SPUtils::GetRadarFrame());
95    }).detach();
96    std::string responseStr = futureResponse.get();
97    std::string completeStr = futureComplete.get();
98    std::string radarFrameStr = futureRadarFrame.get();
99    thGetTrace.join();
100    thGetHisysId.join();
101    double strResponseTime = radar.ParseRadarResponse(responseStr);
102    stream << strResponseTime;
103    double strCompleteTime = radar.ParseRadarComplete(completeStr);
104    std::ostringstream streamComplete;
105    streamComplete << strCompleteTime;
106    std::string maxFrame = radar.ParseRadarMaxFrame(radarFrameStr);
107    std::string resultTime = "ResponseTime:" + stream.str() + "ms\n" + "CompleteTime:" + streamComplete.str() + "ms\n";
108    double rateResult = srt.StallingRateResult(traceName);
109    std::ostringstream ss;
110    ss << std::fixed << std::setprecision(two) << rateResult;
111    std::string ssResult = ss.str();
112    std::string hitchTimeRate = "HitchTimeRate:" + ssResult + "ms/s \n";
113    resultTime = resultTime + hitchTimeRate + maxFrame;
114    return resultTime;
115}
116std::string ControlCallCmd::SlideList()
117{
118    OHOS::SmartPerf::ParseClickResponseTrace pcrt;
119    OHOS::SmartPerf::StartUpDelay sd;
120    OHOS::SmartPerf::ParseSlideFpsTrace slideFpsTrace;
121    std::string cmdResult;
122    OHOS::SmartPerf::ParseRadar radar;
123    OHOS::SmartPerf::StallingRateTrace srt;
124    std::string resultStream = "";
125    std::string rmTrace = CMD_COMMAND_MAP.at(CmdCommand::RM_FILE) + std::string("sp_trace_") + "fps" + ".ftrace";
126    SPUtils::LoadCmd(rmTrace, cmdResult);
127    std::string traceName = std::string("/data/local/tmp/") + std::string("sp_trace_") + "fps" + ".ftrace";
128    if (isOhTest) {
129        std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
130        thGetTrace.join();
131        time = pcrt.ParseResponseTrace(traceName);
132    } else {
133        std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
134        std::thread thGetHisysId = std::thread([&sd]() { sd.GetHisysIdAndKill(); });
135        std::promise<std::string> promResponse;
136        std::promise<std::string> promRadarFrame;
137        std::promise<std::string> promResponseMoved = std::move(promResponse);
138        std::promise<std::string> promRadarFrameMoved = std::move(promRadarFrame);
139        std::future<std::string> futureResponse = promResponseMoved.get_future();
140        std::thread([promiseResponse = std::move(promResponseMoved)]() mutable {
141            promiseResponse.set_value(SPUtils::GetRadarResponse());
142        }).detach();
143        std::future<std::string> futureRadarFrame = promRadarFrameMoved.get_future();
144        std::thread([promiseRadarFrame = std::move(promRadarFrameMoved)]() mutable {
145            promiseRadarFrame.set_value(SPUtils::GetRadarFrame());
146        }).detach();
147        std::string responseStr = futureResponse.get();
148        std::string radarFrameStr = futureRadarFrame.get();
149        thGetTrace.join();
150        thGetHisysId.join();
151        double responseTime = radar.ParseRadarResponse(responseStr);
152        stream << responseTime;
153        std::string maxFrame = radar.ParseRadarMaxFrame(radarFrameStr);
154        std::string responseSlide = "ResponseTime:" + stream.str() + "ms\n";
155        double sFps = slideFpsTrace.ParseSlideFpsTraceNoh(traceName);
156        std::ostringstream streamFps;
157        streamFps << sFps;
158        double stallingRateResult = srt.StallingRateResult(traceName);
159        std::ostringstream ss;
160        ss << std::fixed << std::setprecision(two) << stallingRateResult;
161        std::string ssResult = ss.str();
162        std::string hitchTimeRate = "HitchTimeRate:" + ssResult + "ms/s \n";
163        resultStream = "FPS:" + streamFps.str() + "fps\n" + responseSlide + hitchTimeRate + maxFrame;
164    }
165    return resultStream;
166}
167std::string ControlCallCmd::GetFrame()
168{
169    OHOS::SmartPerf::StartUpDelay sd;
170    std::string cmdResult;
171    OHOS::SmartPerf::ParseRadar radar;
172    std::string rmTrace = CMD_COMMAND_MAP.at(CmdCommand::RM_FILE) + std::string("sp_trace_") + "frame" + ".ftrace";
173    SPUtils::LoadCmd(rmTrace, cmdResult);
174    std::string traceName = std::string("/data/local/tmp/") + std::string("sp_trace_") + "frame" + ".ftrace";
175    std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
176    std::thread thGetHisysId = std::thread([&sd]() { sd.GetHisysIdAndKill(); });
177    std::string str = SPUtils::GetRadarFrame();
178    thGetTrace.join();
179    thGetHisysId.join();
180    std::string reslut = radar.ParseRadarFrame(str);
181    return result;
182}
183double ControlCallCmd::ResponseTime()
184{
185    OHOS::SmartPerf::ParseClickResponseTrace pcrt;
186    OHOS::SmartPerf::StartUpDelay sd;
187    std::string cmdResult;
188    OHOS::SmartPerf::ParseRadar radar;
189    std::string rmTrace = CMD_COMMAND_MAP.at(CmdCommand::RM_FILE) + "*" + ".ftrace";
190    SPUtils::LoadCmd(rmTrace, cmdResult);
191    std::string traceName = std::string("/data/local/tmp/") + std::string("sp_trace_") + "response" + ".ftrace";
192    if (isOhTest) {
193        std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
194        thGetTrace.join();
195        time = pcrt.ParseResponseTrace(traceName);
196    } else {
197        std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
198        std::thread thGetHisysId = std::thread([&sd]() { sd.GetHisysId(); });
199        std::string str = SPUtils::GetRadarResponse();
200        thGetTrace.join();
201        thGetHisysId.join();
202        time = radar.ParseRadarResponse(str);
203    }
204    return time;
205}
206double ControlCallCmd::CompleteTime()
207{
208    OHOS::SmartPerf::StartUpDelay sd;
209    OHOS::SmartPerf::ParseClickCompleteTrace pcct;
210    std::string cmdResult;
211    OHOS::SmartPerf::ParseRadar radar;
212    std::string rmTrace = CMD_COMMAND_MAP.at(CmdCommand::RM_FILE) + "*" + ".ftrace";
213    SPUtils::LoadCmd(rmTrace, cmdResult);
214    std::string traceName = std::string("/data/local/tmp/") + std::string("sp_trace_") + "complete" + ".ftrace";
215    if (isOhTest) {
216        std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
217        thGetTrace.join();
218        time = pcct.ParseCompleteTrace(traceName);
219    } else {
220        std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
221        std::thread thGetHisysId = std::thread([&sd]() { sd.GetHisysId(); });
222        std::string str = SPUtils::GetRadarComplete();
223        thGetTrace.join();
224        thGetHisysId.join();
225        time = radar.ParseRadarComplete(str);
226    }
227    return time;
228}
229std::string ControlCallCmd::GetAppStartTime() const
230{
231    OHOS::SmartPerf::StartUpDelay sd;
232    std::string cmdResult;
233    OHOS::SmartPerf::ParseRadar radar;
234    OHOS::SmartPerf::StallingRateTrace srt;
235    std::string rmTrace = CMD_COMMAND_MAP.at(CmdCommand::RM_FILE) + std::string("sp_trace_") + "start" + ".ftrace";
236    SPUtils::LoadCmd(rmTrace, cmdResult);
237    std::string traceName = std::string("/data/local/tmp/") + std::string("sp_trace_") + "start" + ".ftrace";
238    std::thread thGetTrace = std::thread([&sd, traceName]() { sd.GetTrace(traceName); });
239    std::thread thGetHisysId = std::thread([&sd]() { sd.GetHisysIdAndKill(); });
240
241    std::promise<std::string> promRadar;
242    std::promise<std::string> promRadarFrame;
243    std::promise<std::string> promRadarMoved = std::move(promRadar);
244    std::promise<std::string> promRadarFrameMoved = std::move(promRadarFrame);
245    std::future<std::string> futureRadar = promRadarMoved.get_future();
246    std::thread([promiseRadar = std::move(promRadarMoved)]() mutable {
247        promiseRadar.set_value(SPUtils::GetRadar());
248    }).detach();
249    std::future<std::string> futureRadarFrame = promRadarFrameMoved.get_future();
250    std::thread([promiseRadarFrame = std::move(promRadarFrameMoved)]() mutable {
251        promiseRadarFrame.set_value(SPUtils::GetRadarFrame());
252    }).detach();
253    std::string radarStr = futureRadar.get();
254    std::string radarFrameStr = futureRadarFrame.get();
255    thGetTrace.join();
256    thGetHisysId.join();
257    std::string resultStream = radar.ParseRadarAppStrart(radarStr);
258    std::string resultStream2 = radar.ParseRadarMaxFrame(radarFrameStr);
259    double stallingRateResult2 = srt.StallingRateResult(traceName);
260    std::ostringstream ss;
261    int two = 2;
262    ss << std::fixed << std::setprecision(two) << stallingRateResult2;
263    std::string ssResult = ss.str();
264    std::string hitchTimeRate = "HitchTimeRate:" + ssResult + "ms/s \n";
265    resultStream = resultStream + hitchTimeRate + resultStream2;
266    return resultStream;
267}
268void ControlCallCmd::IsohTest(std::vector<std::string> v)
269{
270    if (v[ohType] == "ohtest") {
271        isOhTest = true;
272    }
273}
274}
275}
276