1 /*
2 * Copyright (c) 2024-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
16 #include "dsched_collab_state_machine.h"
17
18 #include "dsched_collab.h"
19 #include "dtbschedmgr_log.h"
20 #include "sink_state/dsched_collab_sink_get_version_state.h"
21 #include "sink_state/dsched_collab_sink_start_state.h"
22 #include "sink_state/dsched_collab_sink_connect_state.h"
23 #include "sink_state/dsched_collab_sink_wait_end_state.h"
24 #include "source_state/dsched_collab_source_get_peer_version_state.h"
25 #include "source_state/dsched_collab_source_start_state.h"
26 #include "source_state/dsched_collab_source_wait_result_state.h"
27 #include "source_state/dsched_collab_source_wait_end_state.h"
28
29 namespace OHOS {
30 namespace DistributedSchedule {
31 namespace {
32 const std::string TAG = "DSchedCollabStateMachine";
33 std::map<int32_t, std::string> STATEDATA = {
34 {SOURCE_GET_PEER_VERSION_STATE, "SOURCE_GET_PEER_VERSION_STATE"},
35 {SOURCE_START_STATE, "SOURCE_START_STATE"},
36 {SOURCE_WAIT_RESULT_STATE, "SOURCE_WAIT_RESULT_STATE"},
37 {SOURCE_WAIT_END_STATE, "SOURCE_WAIT_END_STATE"},
38 {SINK_GET_VERSION_STATE, "SINK_GET_VERSION_STATE"},
39 {SINK_START_STATE, "SINK_START_STATE"},
40 {SINK_CONNECT_STATE, "SINK_CONNECT_STATE"},
41 {SINK_WAIT_END_STATE, "SINK_WAIT_END_STATE"},
42 };
43 std::map<int32_t, std::string> EVENTDATA = {
44 {SOURCE_GET_PEER_VERSION_EVENT, "SOURCE_GET_PEER_VERSION_EVENT"},
45 {SOURCE_START_EVENT, "SOURCE_START_EVENT"},
46 {NOTIFY_RESULT_EVENT, "NOTIFY_RESULT_EVENT"},
47 {GET_SINK_VERSION_EVENT, "GET_SINK_VERSION_EVENT"},
48 {START_ABILITY_EVENT, "START_ABILITY_EVENT"},
49 {NOTIFY_PREPARE_RESULT_EVENT, "NOTIFY_PREPARE_RESULT_EVENT"},
50 {ERR_END_EVENT, "ERR_END_EVENT"},
51 {END_EVENT, "END_EVENT"},
52 };
53 }
DSchedCollabStateMachine(std::shared_ptr<DSchedCollab> dCollab)54 DSchedCollabStateMachine::DSchedCollabStateMachine(std::shared_ptr<DSchedCollab> dCollab)
55 : dCollab_(dCollab)
56 {
57 }
58
~DSchedCollabStateMachine()59 DSchedCollabStateMachine::~DSchedCollabStateMachine()
60 {
61 }
62
Execute(const AppExecFwk::InnerEvent::Pointer & event)63 int32_t DSchedCollabStateMachine::Execute(const AppExecFwk::InnerEvent::Pointer &event)
64 {
65 HILOGI("called");
66 std::shared_ptr<DSchedCollab> dCollab = dCollab_.lock();
67 if (dCollab == nullptr || currentState_ == nullptr) {
68 HILOGE("excute failed, collab or currentState is null");
69 return INVALID_PARAMETERS_ERR;
70 }
71
72 auto state = currentState_;
73 int32_t ret = state->Execute(dCollab, event);
74 if (ret != ERR_OK) {
75 HILOGE("currentState: %{public}s, excute event: %{public}s failed, ret %{public}d",
76 STATEDATA[state->GetStateType()].c_str(), EVENTDATA[event->GetInnerEventId()].c_str(), ret);
77 }
78 HILOGI("end");
79 return ret;
80 }
81
UpdateState(CollabStateType stateType)82 void DSchedCollabStateMachine::UpdateState(CollabStateType stateType)
83 {
84 HILOGI("called");
85 if (stateType != SOURCE_GET_PEER_VERSION_STATE && stateType != SINK_GET_VERSION_STATE
86 && currentState_ != nullptr) {
87 HILOGI("update state from %{public}s to %{public}s",
88 STATEDATA[currentState_->GetStateType()].c_str(), STATEDATA[stateType].c_str());
89 } else {
90 HILOGI("update state: %{public}s", STATEDATA[stateType].c_str());
91 }
92 currentState_ = CreateState(stateType);
93 HILOGI("end");
94 return;
95 }
96
CreateState(CollabStateType stateType)97 std::shared_ptr<DSchedCollabState> DSchedCollabStateMachine::CreateState(CollabStateType stateType)
98 {
99 std::shared_ptr<DSchedCollabState> state = nullptr;
100 auto stateMachine = std::shared_ptr<DSchedCollabStateMachine>(shared_from_this());
101 switch (stateType) {
102 case SOURCE_GET_PEER_VERSION_STATE: {
103 state = std::make_shared<CollabSrcGetPeerVersionState>(stateMachine);
104 break;
105 }
106 case SOURCE_START_STATE: {
107 state = std::make_shared<CollabSrcStartState>(stateMachine);
108 break;
109 }
110 case SOURCE_WAIT_RESULT_STATE: {
111 state = std::make_shared<CollabSrcWaitResultState>(stateMachine);
112 break;
113 }
114 case SOURCE_WAIT_END_STATE: {
115 state = std::make_shared<CollabSrcWaitEndState>(stateMachine);
116 break;
117 }
118 case SINK_GET_VERSION_STATE: {
119 state = std::make_shared<CollabSinkGetVersionState>(stateMachine);
120 break;
121 }
122 case SINK_START_STATE: {
123 state = std::make_shared<CollabSinkStartState>(stateMachine);
124 break;
125 }
126 case SINK_CONNECT_STATE: {
127 state = std::make_shared<CollabSinkConnectState>(stateMachine);
128 break;
129 }
130 case SINK_WAIT_END_STATE: {
131 state = std::make_shared<CollabSinkWaitEndState>(stateMachine);
132 break;
133 }
134 default:
135 HILOGE("DSchedCollabStateMachine create state failed, stateType: %{public}s", STATEDATA[stateType].c_str());
136 break;
137 }
138 return state;
139 }
140
GetStateType()141 CollabStateType DSchedCollabStateMachine::GetStateType()
142 {
143 if (currentState_ == nullptr) {
144 return SOURCE_START_STATE;
145 }
146 return currentState_->GetStateType();
147 }
148 } // namespace DistributedSchedule
149 } // namespace OHOS
150