1 /*
2 * Copyright (c) 2025 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 "trace_telemetry_state.h"
16
17 #include <hitrace_option/hitrace_option.h>
18
19 #include "hiview_logger.h"
20
21 namespace OHOS::HiviewDFX {
22 namespace {
23 DEFINE_LOG_TAG("TraceStateMachine");
24 }
25
RegisterTelemetryCallback(std::shared_ptr<TelemetryCallback> stateCallback)26 bool TelemetryState::RegisterTelemetryCallback(std::shared_ptr<TelemetryCallback> stateCallback)
27 {
28 if (stateCallback == nullptr) {
29 return false;
30 }
31 stateCallback_ = stateCallback;
32 stateCallback_->OnTelemetryStart();
33 if (policy_ == TelemetryPolicy::DEFAULT) {
34 stateCallback_->OnTelemetryTraceOn();
35 }
36 return true;
37 }
38
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)39 TraceRet TelemetryState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
40 {
41 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
42 HIVIEW_LOGE(":%{public}s, CloseTrace result:%{public}d", GetTag().c_str(), closeRet);
43 return TraceRet(closeRet);
44 }
45 return TraceBaseState::OpenTrace(scenario, tagGroups);
46 }
47
OpenTrace(TraceScenario scenario,const std::string & args)48 TraceRet TelemetryState::OpenTrace(TraceScenario scenario, const std::string &args)
49 {
50 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
51 HIVIEW_LOGE(":%{public}s, CloseTrace result:%{public}d", GetTag().c_str(), closeRet);
52 return TraceRet(closeRet);
53 }
54 return TraceBaseState::OpenTrace(scenario, args);
55 }
56
DumpTraceWithFilter(uint32_t maxDuration,uint64_t happenTime,TraceRetInfo & info)57 TraceRet TelemetryState::DumpTraceWithFilter(uint32_t maxDuration, uint64_t happenTime, TraceRetInfo &info)
58 {
59 if (policy_ != TelemetryPolicy::DEFAULT) {
60 if (innerStateMachine_ != nullptr && !innerStateMachine_->IsTraceOn()) {
61 HIVIEW_LOGW(":%{public}s, IsTraceOn false", GetTag().c_str());
62 return TraceRet(TraceStateCode::FAIL);
63 }
64 }
65 info = Hitrace::DumpTrace(maxDuration, happenTime);
66 HIVIEW_LOGI(":%{public}s, result:%{public}d", GetTag().c_str(), info.errorCode);
67 return TraceRet(info.errorCode);
68 }
69
CloseTrace(TraceScenario scenario)70 TraceRet TelemetryState::CloseTrace(TraceScenario scenario)
71 {
72 if (scenario != TraceScenario::TRACE_TELEMETRY) {
73 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
74 return TraceRet(TraceStateCode::FAIL);
75 }
76 return TraceBaseState::CloseTrace(scenario);
77 }
78
PowerTelemetryOn()79 TraceRet TelemetryState::PowerTelemetryOn()
80 {
81 if (policy_ != TelemetryPolicy::POWER || innerStateMachine_ == nullptr) {
82 HIVIEW_LOGW(":%{public}s, policy:%{public}d is error", GetTag().c_str(), static_cast<int>(policy_));
83 return TraceRet(TraceStateCode::POLICY_ERROR);
84 }
85 if (innerStateMachine_->IsTraceOn()) {
86 HIVIEW_LOGW(":%{public}s, already power on", GetTag().c_str());
87 return {};
88 }
89 return innerStateMachine_->TraceOn();
90 }
91
PowerTelemetryOff()92 TraceRet TelemetryState::PowerTelemetryOff()
93 {
94 if (policy_ != TelemetryPolicy::POWER || innerStateMachine_ == nullptr) {
95 HIVIEW_LOGW(":%{public}s, policy:%{public}d is error", GetTag().c_str(), static_cast<int>(policy_));
96 return TraceRet(TraceStateCode::POLICY_ERROR);
97 }
98 if (!innerStateMachine_->IsTraceOn()) {
99 HIVIEW_LOGW(":%{public}s, already power off", GetTag().c_str());
100 return {};
101 }
102 return innerStateMachine_->TraceOff();
103 }
104
TraceTelemetryOn()105 TraceRet TelemetryState::TraceTelemetryOn()
106 {
107 if (policy_ != TelemetryPolicy::MANUAL || innerStateMachine_ == nullptr) {
108 HIVIEW_LOGW(":%{public}s, policy:%{public}d is error", GetTag().c_str(), static_cast<int>(policy_));
109 return TraceRet(TraceStateCode::POLICY_ERROR);
110 }
111 return innerStateMachine_->TraceOn();
112 }
113
TraceTelemetryOff()114 TraceRet TelemetryState::TraceTelemetryOff()
115 {
116 if (policy_ != TelemetryPolicy::MANUAL || innerStateMachine_ == nullptr) {
117 HIVIEW_LOGW(":%{public}s, policy:%{public}d is error", GetTag().c_str(), static_cast<int>(policy_));
118 return TraceRet(TraceStateCode::POLICY_ERROR);
119 }
120 return innerStateMachine_->TraceOff();
121 }
122
PostTelemetryOn(uint64_t time)123 TraceRet TelemetryState::PostTelemetryOn(uint64_t time)
124 {
125 if (policy_ != TelemetryPolicy::MANUAL || innerStateMachine_ == nullptr) {
126 HIVIEW_LOGW(":%{public}s, policy:%{public}d is error", GetTag().c_str(), static_cast<int>(policy_));
127 return TraceRet(TraceStateCode::POLICY_ERROR);
128 }
129 return innerStateMachine_->PostOn(time);
130 }
131
PostTelemetryTimeOut()132 TraceRet TelemetryState::PostTelemetryTimeOut()
133 {
134 if (policy_ != TelemetryPolicy::MANUAL || innerStateMachine_ == nullptr) {
135 HIVIEW_LOGW(":%{public}s, policy:%{public}d is error", GetTag().c_str(), static_cast<int>(policy_));
136 return TraceRet(TraceStateCode::POLICY_ERROR);
137 }
138 return innerStateMachine_->TimeOut();
139 }
140
InitTelemetryStatus(bool isStatusOn)141 void TelemetryState::InitTelemetryStatus(bool isStatusOn)
142 {
143 HIVIEW_LOGI(":%{public}s, isStatusOn:%{public}d", GetTag().c_str(), isStatusOn);
144 innerStateMachine_ = std::make_shared<TeleMetryStateMachine>();
145 auto initState = std::make_shared<InitState>(innerStateMachine_);
146 innerStateMachine_->SetInitState(initState);
147 auto traceOnState = std::make_shared<TraceOnState>(innerStateMachine_);
148 innerStateMachine_->SetTraceOnState(traceOnState);
149 if (stateCallback_ != nullptr) {
150 innerStateMachine_->RegisterTelemetryCallback(stateCallback_);
151 }
152 if (!isStatusOn) {
153 if (auto ret = innerStateMachine_->TransToInitState(); !ret.IsSuccess()) {
154 HIVIEW_LOGE("int trace off fail");
155 }
156 return;
157 }
158 if (auto ret = innerStateMachine_->TransToTraceOnState(0, 0); ret.IsSuccess() && stateCallback_ != nullptr) {
159 stateCallback_->OnTelemetryTraceOn();
160 }
161 }
162 }