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 <iostream>
16 #include <functional>
17 #include <vector>
18 #include <thread>
19 #include <future>
20 #include <map>
21 #include <mutex>
22 #include <climits>
23 #include "parameters.h"
24 #include "include/sp_csv_util.h"
25 #include "include/sdk_data_recv.h"
26 #include "include/GpuCounter.h"
27 #include "include/lock_frequency.h"
28 #include "include/sp_thread_socket.h"
29 #include "include/sp_profiler_factory.h"
30 #include "include/sp_log.h"
31 #include "include/sp_task.h"
32 #include "include/profiler_fps.h"
33 #include "include/heartbeat.h"
34 #include "include/control_call_cmd.h"
35 #include "include/sp_profiler_factory.h"
36 #include "include/Network.h"
37 #include "include/startup_delay.h"
38 #include "include/Dubai.h"
39 #include "include/GetLog.h"
40 #include "include/RAM.h"
41 namespace OHOS {
42 namespace SmartPerf {
43 std::string g_pkgName = "";
44 bool g_preset = false;
45 std::string g_pkgAndPid = "";
MapToString(std::map<std::string,std::string> dataMap) const46 std::string SpThreadSocket::MapToString(std::map<std::string, std::string> dataMap) const
47 {
48 std::string result;
49 int i = 0;
50 std::string splitStr = "";
51 for (auto iter = dataMap.cbegin(); iter != dataMap.cend(); ++iter) {
52 printf("%s = %s\n", iter->first.c_str(), iter->second.c_str());
53 if (i > 0) {
54 splitStr = "$$";
55 }
56 result += splitStr + iter->first.c_str() + "||" + iter->second.c_str();
57 i++;
58 }
59 return result;
60 }
SplitMsg(const std::string & recvBuf) const61 std::string SpThreadSocket::SplitMsg(const std::string &recvBuf) const
62 {
63 if (recvBuf.empty()) {
64 LOGE("SplitMsg recvBuf is null");
65 return recvBuf;
66 }
67 size_t pos = recvBuf.find("::");
68 if (pos != std::string::npos) {
69 std::vector<std::string> sps;
70 SPUtils::StrSplit(recvBuf, "::", sps);
71 if (sps.size() > 1) {
72 return sps[1];
73 } else {
74 LOGE("SplitMsg sps size is zreo");
75 return recvBuf;
76 }
77 } else {
78 return recvBuf;
79 }
80 }
81
Process(ProtoType type)82 void SpThreadSocket::Process(ProtoType type)
83 {
84 std::cout << "Socket Process called!" << std::endl;
85 SpServerSocket spSocket;
86 spSocket.Init(type);
87 if (type == ProtoType::TCP) {
88 std::cout << "Socket TCP Init called!" << std::endl;
89 WLOGI("Socket TCP Init called!");
90 TypeTcp(spSocket);
91 }
92 if (type == ProtoType::UDP || type == ProtoType::UDPEX) {
93 SocketHeartbeat();
94 while (socketConnect == true) {
95 spSocket.Recvfrom();
96 HandleMsg(spSocket);
97 }
98 }
99 std::cout << "Socket Process finished!" << std::endl;
100 spSocket.Close();
101 }
CheckToken(std::string recvStr,SpServerSocket & spSocket,std::string recvStrNoToken) const102 SocketErrorType SpThreadSocket::CheckToken(std::string recvStr,
103 SpServerSocket &spSocket, std::string recvStrNoToken) const
104 {
105 if (recvStr.find_last_of(":") == std::string::npos) {
106 if (recvStr.find("SP_daemon -editor") != std::string::npos) {
107 LOGI("Received string contains 'SP_daemon -editor', token check passed.");
108 return SocketErrorType::OK;
109 } else {
110 LOGE("Token check failed: %s", recvStrNoToken.c_str());
111 return SocketErrorType::TOKEN_CHECK_FAILED;
112 }
113 }
114 std::string token = recvStr.substr(recvStr.find_last_of(":") + 1);
115 token = token.substr(0, token.find(' '));
116 std::string tcpToken = SPTask::GetInstance().GetTcpToken();
117 LOGD("Comparing token with TCP token...");
118 if (tcpToken == "" && token == "-SESSIONID") {
119 LOGI("Token is empty but received token is '-SESSIONID', token check passed.");
120 return SocketErrorType::OK;
121 }
122 if (token != tcpToken) {
123 LOGE("Token mismatch.");
124 return SocketErrorType::TOKEN_CHECK_FAILED;
125 }
126 LOGD("Token match");
127 return SocketErrorType::OK;
128 }
TypeTcp(SpServerSocket & spSocket)129 void SpThreadSocket::TypeTcp(SpServerSocket &spSocket)
130 {
131 SocketHeartbeat();
132 WLOGI("Socket TCP Init Finished, Wait Client Socket Connect...");
133 while (socketConnect == true) {
134 int procFd = spSocket.Accept();
135 std::cout << "Socket TCP procFd: " << procFd << std::endl;
136 while (procFd > 0) {
137 int reFd = spSocket.Recv();
138 if (reFd < 0) {
139 WLOGE("Error receiving data, reFd: %d", reFd);
140 break;
141 }
142 std::string recvStr = spSocket.RecvBuf();
143 std::string recvStrNoToken = recvStr.substr(0, recvStr.find("::"));
144 LOGD("TCP recv data:%s", recvStr.c_str());
145 WLOGD("Received data: %s", recvStrNoToken.c_str());
146 // 解析消息 分发处理
147 const SocketErrorType tokenStatus = CheckToken(recvStr, spSocket, recvStrNoToken);
148 WLOGD("Token check status: %d", tokenStatus);
149 DealMsg(recvStr, spSocket, tokenStatus);
150 }
151 }
152 }
153 // TCP
InitRecv(std::string recvStr,SpServerSocket & spSocket,SocketConnectType type) const154 void SpThreadSocket::InitRecv(std::string recvStr, SpServerSocket &spSocket, SocketConnectType type) const
155 {
156 std::string errorInfo;
157 std::string checkStr = recvStr.substr(std::string("init::").length());
158 if (!SPTask::GetInstance().CheckTcpParam(checkStr, errorInfo) &&
159 checkStr.find(SPTask::GetInstance().GetTcpToken()) == std::string::npos) {
160 WLOGE("Init error(%s)", errorInfo.c_str());
161 if (type == SocketConnectType::CMD_SOCKET) {
162 spSocket.Send("init::False,\"error\":" + errorInfo);
163 } else {
164 spSocket.Send(std::string("init::") + SocketErrorTypeToString(SocketErrorType::INIT_FAILED));
165 }
166 return;
167 }
168 if (recvStr.find("-lockfreq") != std::string::npos &&
169 SPTask::GetInstance().GetTcpToken() == "") {
170 WLOGE("'-lockfreq' must have a valid token.");
171 return;
172 }
173 ErrCode code = SPTask::GetInstance().InitTask(SplitMsg(recvStr));
174 if (type == SocketConnectType::CMD_SOCKET) {
175 spSocket.Send(std::string("init::") + ((code == ErrCode::OK) ? "True" : "False"));
176 WLOGI("Sent init::" + ((code == ErrCode::OK) ? "True" : "False"));
177 return;
178 }
179 if (code == ErrCode::OK) {
180 spSocket.Send("init::True");
181 WLOGI("Sent init::True response");
182 } else {
183 spSocket.Send(std::string("init::") + SocketErrorTypeToString(SocketErrorType::INIT_FAILED));
184 WLOGE("Sent init::%d for failure", SocketErrorType::INIT_FAILED);
185 }
186 }
StartRecv(SpServerSocket & spSocket)187 void SpThreadSocket::StartRecv(SpServerSocket &spSocket)
188 {
189 if (flagRunning) {
190 spSocket.Send("SP_daemon is running");
191 return;
192 }
193 auto lambdaTask = [](const std::string &data) {
194 std::cout << data << std::endl;
195 };
196 ErrCode code = SPTask::GetInstance().StartTask(lambdaTask);
197 SPTask::GetInstance().StartRecord();
198 if (code == ErrCode::OK) {
199 spSocket.Send("start::True");
200 flagRunning = true;
201 WLOGI("Sent start::True message to socket.");
202 } else if (code == ErrCode::FAILED) {
203 spSocket.Send("start::False");
204 WLOGE("Sent start::False message to socket.");
205 }
206 }
StartRecvRealtime(SpServerSocket & spSocket) const207 void SpThreadSocket::StartRecvRealtime(SpServerSocket &spSocket) const
208 {
209 auto lambdaTask = [&spSocket](const std::string &data) { spSocket.Send(data); };
210 ErrCode code = SPTask::GetInstance().StartTask(lambdaTask);
211 if (code == ErrCode::OK) {
212 spSocket.Send("start::True");
213 WLOGI("Sent start::True message to socket.");
214 } else if (code == ErrCode::FAILED) {
215 spSocket.Send(std::string("start::") + SocketErrorTypeToString(SocketErrorType::START_FAILED));
216 WLOGE("Sent start::" + SocketErrorTypeToString(SocketErrorType::START_FAILED) + " message to socket.");
217 }
218 }
StopRecvRealtime(SpServerSocket & spSocket)219 void SpThreadSocket::StopRecvRealtime(SpServerSocket &spSocket)
220 {
221 ErrCode code = SPTask::GetInstance().StopTask();
222 if (code == ErrCode::OK) {
223 spSocket.Send("stop::True");
224 WLOGI("Sent stop::True message to socket.");
225 flagRunning = false;
226 spSocket.Close();
227 } else if (code == ErrCode::FAILED) {
228 spSocket.Send(std::string("stop::") + SocketErrorTypeToString(SocketErrorType::STOP_FAILED));
229 WLOGE("Sent stop::" + SocketErrorTypeToString(SocketErrorType::STOP_FAILED) + " message to socket.");
230 }
231 }
StartRecvRecord(SpServerSocket & spSocket) const232 void SpThreadSocket::StartRecvRecord(SpServerSocket &spSocket) const
233 {
234 ErrCode code = SPTask::GetInstance().StartRecord();
235 if (code == ErrCode::OK) {
236 spSocket.Send("startRecord::True");
237 WLOGI("Sent startRecord::True message to socket.");
238 } else {
239 spSocket.Send(std::string("startRecord::") + SocketErrorTypeToString(SocketErrorType::START_RECORD_FAILED));
240 WLOGE("Sent startRecord::" + SocketErrorTypeToString(SocketErrorType::START_RECORD_FAILED) +
241 " message to socket.");
242 }
243 }
StopRecvRecord(SpServerSocket & spSocket) const244 void SpThreadSocket::StopRecvRecord(SpServerSocket &spSocket) const
245 {
246 ErrCode code = SPTask::GetInstance().StopRecord();
247 if (code == ErrCode::OK) {
248 spSocket.Send("stopRecord::True");
249 WLOGI("Sent stopRecord::True message to socket.");
250 } else {
251 spSocket.Send(std::string("stopRecord::") + SocketErrorTypeToString(SocketErrorType::STOP_RECORD_FAILED));
252 WLOGE("Sent stopRecord::" + SocketErrorTypeToString(SocketErrorType::STOP_RECORD_FAILED) +
253 " message to socket.");
254 }
255 }
SendTokenFailedMessage(SpServerSocket & socket,std::string & message) const256 void SpThreadSocket::SendTokenFailedMessage(SpServerSocket &socket, std::string &message) const
257 {
258 if (message.find("init:::") != std::string::npos ||
259 message.find("start:::") != std::string::npos) {
260 WLOGI("Skipping token check failure for init::: or start::: command.");
261 return;
262 }
263 const std::vector<std::string> messageType = {
264 "init::",
265 "start::",
266 "stop::",
267 "startRecord::",
268 "stopRecord::",
269 };
270 for (auto it : messageType) {
271 if (message.find(it) != std::string::npos) {
272 WLOGE("Sending token check failed message for command: %s", it.c_str());
273 socket.Send(it + SocketErrorTypeToString(SocketErrorType::TOKEN_CHECK_FAILED));
274 return;
275 }
276 }
277 WLOGW("No matching command found for token check failure in message: %s", message.c_str());
278 }
DealMsg(std::string recvStr,SpServerSocket & spSocket,SocketErrorType tokenStatus)279 void SpThreadSocket::DealMsg(std::string recvStr, SpServerSocket &spSocket, SocketErrorType tokenStatus)
280 {
281 SocketHeartbeat();
282 if (tokenStatus == SocketErrorType::TOKEN_CHECK_FAILED) {
283 SendTokenFailedMessage(spSocket, recvStr);
284 return;
285 }
286 if (recvStr.find("init:::") != std::string::npos) {
287 WLOGI("Processing 'init:::' command.");
288 InitRecv(recvStr, spSocket, SocketConnectType::CMD_SOCKET);
289 } else if (recvStr.find("start:::") != std::string::npos) {
290 WLOGI("Processing 'start:::' command.");
291 StartRecv(spSocket);
292 } else if (recvStr.find("init::") != std::string::npos) {
293 WLOGI("Processing 'init::' command.");
294 InitRecv(recvStr, spSocket, SocketConnectType::EDITOR_SOCKET);
295 } else if (recvStr.find("start::") != std::string::npos) {
296 WLOGI("Processing 'start::' command.");
297 StartRecvRealtime(spSocket);
298 } else if (recvStr.find("stop::") != std::string::npos) {
299 WLOGI("Processing 'stop::' command.");
300 StopRecvRealtime(spSocket);
301 } else if (recvStr.find("startRecord::") != std::string::npos) {
302 WLOGI("Processing 'startRecord::' command.");
303 StartRecvRecord(spSocket);
304 } else if (recvStr.find("stopRecord::") != std::string::npos) {
305 WLOGI("Processing 'stopRecord::' command.");
306 StopRecvRecord(spSocket);
307 } else if (recvStr.find("SP_daemon -editor") != std::string::npos) {
308 EditorRecv(recvStr, spSocket);
309 } else {
310 WLOGW("Received unknown command: %s", recvStr.c_str());
311 }
312 }
EditorRecv(std::string recvStr,const SpServerSocket & spSocket) const313 void SpThreadSocket::EditorRecv(std::string recvStr, const SpServerSocket &spSocket) const
314 {
315 std::vector<std::string> vec;
316 size_t size = recvStr.size();
317 size_t j = 0;
318 for (size_t i = 0; i < size; i++) {
319 if (recvStr[i] == ' ') {
320 vec.push_back(recvStr.substr(j, i - j));
321 j = i + 1;
322 }
323 }
324 vec.push_back(recvStr.substr(j, size - j));
325 const int type = 2;
326 if (vec[type] == "findAppPage") {
327 BackDesktop();
328 }
329 OHOS::SmartPerf::ControlCallCmd controlCallCmd;
330 std::string result = controlCallCmd.GetResult(vec);
331 spSocket.Send(result);
332 }
BackDesktop() const333 void SpThreadSocket::BackDesktop() const
334 {
335 std::string cmdResult;
336 std::string uinput = CMD_COMMAND_MAP.at(CmdCommand::UINPUT_BACK);
337 SPUtils::LoadCmd(uinput, cmdResult);
338 }
339 // UDP
HandleMsg(SpServerSocket & spSocket) const340 void SpThreadSocket::HandleMsg(SpServerSocket &spSocket) const
341 {
342 std::string retCode = "";
343 auto iterator = MESSAGE_MAP.begin();
344 while (iterator != MESSAGE_MAP.end()) {
345 std::string recvBuf = spSocket.RecvBuf();
346 if (recvBuf.size() != 0) {
347 Heartbeat &heartbeat = Heartbeat::GetInstance();
348 heartbeat.UpdatestartTime();
349 }
350 if (!SPUtils::IsSubString(recvBuf, iterator->second)) {
351 ++iterator;
352 continue;
353 }
354 LOGD("UDP recv : %s", recvBuf.c_str());
355 SpProfiler *profiler = SpProfilerFactory::GetProfilerItem(iterator->first);
356 if (profiler == nullptr) {
357 HandleNullMsg(spSocket, profiler, retCode, recvBuf, iterator);
358 } else {
359 std::map<std::string, std::string> data;
360 if (iterator->first == MessageType::CATCH_NETWORK_TRAFFIC) {
361 Network::GetInstance().IsFindHap();
362 profiler->ItemData(); // record the collection point for the first time,no need to return
363 data["network_traffic"] = "true";
364 } else if (iterator->first == MessageType::GET_NETWORK_TRAFFIC) {
365 Network::GetInstance().IsStopFindHap();
366 data = profiler->ItemData();
367 data["network_traffic"] = "true";
368 } else if (iterator->first == MessageType::GET_LOG) {
369 data = GetLogProcess(profiler, recvBuf);
370 } else {
371 GetProcessIdByPkgName(iterator);
372 data = profiler->ItemData();
373 }
374 HandleUDPMsg(spSocket, data, retCode, iterator);
375 }
376 LOGD("sendData key(%d) content(%s)", iterator->first, retCode.c_str());
377 break;
378 }
379 }
380
HandleUDPMsg(SpServerSocket & spSocket,std::map<std::string,std::string> data,std::string retCode,std::unordered_map<MessageType,std::string>::const_iterator iterator) const381 void SpThreadSocket::HandleUDPMsg(SpServerSocket &spSocket, std::map<std::string, std::string> data,
382 std::string retCode, std::unordered_map<MessageType, std::string>::const_iterator iterator) const
383 {
384 std::cout << "iterator->first: " << static_cast<int>(iterator->first) << std::endl;
385 if (iterator->first == MessageType::GET_CUR_FPS) {
386 ProfilerFPS::isLowCurFps = true;
387 std::string resultfps = "vfps||";
388 for (auto iter = data.cbegin(); iter != data.cend(); ++iter) {
389 if (iter->first != "fpsJitters") {
390 std::string temp = iter->second + "@@";
391 resultfps += std::string(temp.c_str());
392 }
393 }
394 spSocket.Sendto(resultfps);
395 LOGD("UDP send Cur_resultfps = %s", resultfps.c_str());
396 } else if (iterator->first == MessageType::GET_CPU_FREQ_LOAD) {
397 FetchCpuStats(spSocket, data);
398 } else if (iterator->first == MessageType::GET_LOG) {
399 if (GetLog::GetInstance().GetLogFileSocketPort() == -1) {
400 return;
401 }
402 int logSocket = -1;
403 int connectCount = 0;
404 const int maxTryCount = 2;
405
406 while (logSocket < 0) {
407 WLOGI("Connect file log socket, try times: %d", connectCount + 1);
408 if (connectCount > maxTryCount) {
409 WLOGE("Connect file log socket failed");
410 return;
411 }
412 connectCount++;
413 logSocket = GetLog::GetInstance().LogFileSocketConnect();
414 }
415
416 int ret = GetLog::GetInstance().SendLogFile();
417 if (ret < 0) {
418 return;
419 }
420 } else {
421 retCode = MapToString(data);
422 spSocket.Sendto(retCode);
423 LOGD("UDP send retCode = %s", retCode.c_str());
424 }
425 }
SocketHeartbeat() const426 void SpThreadSocket::SocketHeartbeat() const
427 {
428 Heartbeat &heartbeat = Heartbeat::GetInstance();
429 heartbeat.UpdatestartTime();
430 }
FetchCpuStats(SpServerSocket & spSocket,std::map<std::string,std::string> data) const431 void SpThreadSocket::FetchCpuStats(SpServerSocket &spSocket, std::map<std::string, std::string> data) const
432 {
433 std::string resultCpuFrequency = "";
434 std::string resultCpuUsage = "";
435 std::string resultCpu = "";
436 int cpuFrequencyNum = 0;
437 int cpuUsageNum = 0;
438 int cpuFlag = 1;
439 while (cpuFlag) {
440 resultCpuFrequency = "cpu" + std::to_string(cpuFrequencyNum) + "Frequency";
441 resultCpuUsage = "cpu" + std::to_string(cpuUsageNum) + "Usage";
442 auto iterCpuFrequency = data.find(resultCpuFrequency);
443 auto iterCpuUsage = data.find(resultCpuUsage);
444 if (iterCpuFrequency != data.end()) {
445 resultCpuFrequency += "||" + iterCpuFrequency->second;
446 resultCpu += "$$" + resultCpuFrequency;
447 cpuFrequencyNum++;
448 } else {
449 cpuFlag = 0;
450 }
451 if (iterCpuUsage != data.end()) {
452 resultCpuUsage += "||" + iterCpuUsage->second;
453 resultCpu += "$$" + resultCpuUsage;
454 cpuUsageNum++;
455 } else {
456 cpuFlag = 0;
457 }
458 }
459 spSocket.Sendto(resultCpu);
460 LOGD("UDP send resultCpu = %s", resultCpu.c_str());
461 }
HandleNullMsg(SpServerSocket & spSocket,SpProfiler * profiler,std::string retCode,std::string recvBuf,std::unordered_map<MessageType,std::string>::const_iterator iterator) const462 void SpThreadSocket::HandleNullMsg(SpServerSocket &spSocket, SpProfiler *profiler, std::string retCode,
463 std::string recvBuf, std::unordered_map<MessageType, std::string>::const_iterator iterator) const
464 {
465 if (iterator->first == MessageType::SET_PKG_NAME) {
466 if (recvBuf.find("smartperf") != std::string::npos) {
467 retCode = SplitMsg(recvBuf);
468 if (retCode.find("smartperf") != std::string::npos) {
469 Dubai::dubaiPkgName = retCode;
470 LOGD("UDP send dubaiPkgName: (%s)", Dubai::dubaiPkgName.c_str());
471 }
472 } else {
473 retCode = SplitMsg(recvBuf);
474 if (recvBuf.find("$") != std::string::npos) {
475 g_pkgAndPid = SplitMsg(recvBuf);
476 g_pkgName = SpGetPkg(g_pkgAndPid);
477 } else {
478 g_pkgName = SplitMsg(recvBuf);
479 }
480 LOGD("UDP recv g_pkgName (%s)", g_pkgName.c_str());
481 }
482 spSocket.Sendto(retCode);
483 LOGD("UDP send PkgName = %s", retCode.c_str());
484 } else if (profiler == nullptr && (iterator->first == MessageType::GET_APP_TYPE)) {
485 retCode = SplitMsg(recvBuf);
486 std::thread rStart([this, retCode]() { this->ResetValue(retCode); });
487 rStart.detach();
488 } else if (profiler == nullptr && (iterator->first == MessageType::GET_DAEMON_VERSION)) {
489 retCode = "Version: " + SPUtils::GetVersion();
490 spSocket.Sendto(retCode);
491 } else if (profiler == nullptr && (iterator->first == MessageType::SET_GAME_VIEW)) {
492 retCode = SplitMsg(recvBuf);
493 SpProfilerFactory::SetProfilerGameLayer(retCode);
494 } else if (iterator->first == MessageType::CATCH_TRACE_CONFIG ||
495 iterator->first == MessageType::CATCH_TRACE_CMD) {
496 SpProfilerFactory::SetByTrace(SplitMsg(recvBuf));
497 } else if (iterator->first == MessageType::GET_CPU_NUM) {
498 retCode = SPUtils::GetCpuNum();
499 spSocket.Sendto(retCode);
500 LOGD("UDP send cpuNum = %s", retCode.c_str());
501 } else if (iterator->first == MessageType::BACK_TO_DESKTOP) {
502 BackDesktop();
503 } else {
504 HandleNullAddMsg(spSocket, profiler, retCode, recvBuf, iterator);
505 }
506 }
507
GetProcessIdByPkgName(std::unordered_map<MessageType,std::string>::const_iterator iterator) const508 void SpThreadSocket::GetProcessIdByPkgName(std::unordered_map<MessageType, std::string>::const_iterator iterator) const
509 {
510 if (iterator->first == MessageType::GET_FPS_AND_JITTERS || iterator->first == MessageType::GET_CUR_FPS ||
511 iterator->first == MessageType::GET_RAM_INFO) {
512 if (!SpProfilerFactory::editorFlag) {
513 LOGD("SpProfilerFactory::g_pkgName(%s)", g_pkgName.c_str());
514 std::string processId = "";
515 std::string processIds = "";
516 g_preset = IsPreset(g_pkgAndPid);
517 if (g_preset) {
518 processId = SpGetPid(g_pkgAndPid);
519 } else {
520 OHOS::SmartPerf::StartUpDelay sp;
521 processId = sp.GetPidByPkg(g_pkgName, &processIds);
522 }
523 SpProfilerFactory::SetProfilerPidByPkg(processId, processIds);
524 SpProfilerFactory::SetProfilerPkg(g_pkgName);
525 }
526 }
527 }
528
ResetValue(std::string retCode) const529 void SpThreadSocket::ResetValue(std::string retCode) const
530 {
531 ProfilerFPS &pfps = ProfilerFPS::GetInstance();
532 pfps.isGameApp = SPUtils::GetIsGameApp(retCode);
533 pfps.firstDump = true;
534 RAM &ram = RAM::GetInstance();
535 ram.SetHapFirstFlag();
536 }
HandleNullAddMsg(SpServerSocket & spSocket,SpProfiler * profiler,std::string retCode,std::string recvBuf,std::unordered_map<MessageType,std::string>::const_iterator iterator) const537 void SpThreadSocket::HandleNullAddMsg(SpServerSocket &spSocket, SpProfiler *profiler, std::string retCode,
538 std::string recvBuf, std::unordered_map<MessageType, std::string>::const_iterator iterator) const
539 {
540 Dubai &db = Dubai::GetInstance();
541 if (iterator->first == MessageType::START_DUBAI_DB) {
542 std::thread dStart([&db]() { db.CallBeginAndFinish(); });
543 dStart.detach();
544 } else if (iterator->first == MessageType::SET_DUBAI_DB) {
545 db.CallBeginAndFinish();
546 db.isDumpDubaiFinish = true;
547 ProfilerFPS::isLowCurFps = false;
548 retCode = db.CallMoveDubaiDbFinished();
549 LOGD("UDP send GetDubaiDb Message: (%s)", retCode.c_str());
550 spSocket.Sendto(retCode);
551 LOGD("UDP send DuBai get finish");
552 } else if (iterator->first == MessageType::CHECK_UDP_STATUS) {
553 retCode = "UDP status is normal";
554 spSocket.Sendto(retCode);
555 LOGD("UDP status is normal");
556 } else {
557 retCode = iterator->second;
558 spSocket.Sendto(retCode);
559 LOGD("UDP sendData: (%s)", retCode.c_str());
560 }
561 }
562
SocketErrorTypeToString(SocketErrorType errorType) const563 std::string SpThreadSocket::SocketErrorTypeToString(SocketErrorType errorType) const
564 {
565 switch (errorType) {
566 case SocketErrorType::OK:
567 return "OK";
568 case SocketErrorType::TOKEN_CHECK_FAILED:
569 return "TOKEN_CHECK_FAILED";
570 case SocketErrorType::INIT_FAILED:
571 return "INIT_FAILED";
572 case SocketErrorType::START_FAILED:
573 return "START_FAILED";
574 case SocketErrorType::STOP_FAILED:
575 return "STOP_FAILED";
576 case SocketErrorType::START_RECORD_FAILED:
577 return "START_RECORD_FAILED";
578 case SocketErrorType::STOP_RECORD_FAILED:
579 return "STOP_RECORD_FAILED";
580 default:
581 return "UNKNOWN";
582 }
583 }
GetLogProcess(SpProfiler * profilerItem,std::string buffer) const584 std::map<std::string, std::string> SpThreadSocket::GetLogProcess(SpProfiler *profilerItem, std::string buffer) const
585 {
586 if (buffer.find("::") != std::string::npos) {
587 int port = SPUtilesTye::StringToSometype<int>(buffer.substr(buffer.find("::") + 2));
588 WLOGI("Get File log UDP message received, port is %d", port);
589 // Init log file socket and file process
590 GetLog::GetInstance().SetLogFileSocket(-1);
591 GetLog::GetInstance().SetLogFileSocketPort(port);
592 return profilerItem->ItemData();
593 } else {
594 WLOGE("Get File log UDP message received, but port is not found");
595 GetLog::GetInstance().SetLogFileSocketPort(-1);
596 }
597
598 return std::map<std::string, std::string>();
599 }
SpGetPkg(const std::string & spMsg) const600 std::string SpThreadSocket::SpGetPkg(const std::string &spMsg) const
601 {
602 if (spMsg.empty()) {
603 LOGE("spMsg is null");
604 return spMsg;
605 }
606 size_t pos = spMsg.find("$");
607 if (pos != std::string::npos) {
608 std::vector<std::string> sps;
609 SPUtils::StrSplit(spMsg, "$", sps);
610 if (sps.size() > 1) {
611 return sps[0];
612 } else {
613 LOGE("SpGetPkg sps size is zreo");
614 return spMsg;
615 }
616 } else {
617 return spMsg;
618 }
619 }
620
SpGetPid(const std::string & spMsg) const621 std::string SpThreadSocket::SpGetPid(const std::string &spMsg) const
622 {
623 if (spMsg.empty()) {
624 LOGE("spMsg is null");
625 return spMsg;
626 }
627 size_t pos = spMsg.find("$");
628 if (pos != std::string::npos) {
629 std::vector<std::string> sps;
630 SPUtils::StrSplit(spMsg, "$", sps);
631 if (sps.size() > 1) {
632 return sps[1];
633 } else {
634 LOGE("SpGetPid sps size is zreo");
635 return "";
636 }
637 } else {
638 return "";
639 }
640 }
641
IsPreset(const std::string & spMsg) const642 bool SpThreadSocket::IsPreset(const std::string &spMsg) const
643 {
644 if (spMsg.find("$") != std::string::npos) {
645 return true;
646 } else {
647 return false;
648 }
649 }
650 }
651 }