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 std::shared_ptr<DSchedCollab> dCollab = dCollab_.lock();
66 if (dCollab == nullptr || currentState_ == nullptr) {
67 HILOGE("excute failed, collab or currentState is null");
68 return INVALID_PARAMETERS_ERR;
69 }
70
71 auto state = currentState_;
72 int32_t ret = state->Execute(dCollab, event);
73 if (ret != ERR_OK) {
74 HILOGE("currentState: %{public}s, excute event: %{public}s failed, ret %{public}d",
75 STATEDATA[state->GetStateType()].c_str(), EVENTDATA[event->GetInnerEventId()].c_str(), ret);
76 }
77 return ret;
78 }
79
UpdateState(CollabStateType stateType)80 void DSchedCollabStateMachine::UpdateState(CollabStateType stateType)
81 {
82 HILOGI("called");
83 if (stateType != SOURCE_GET_PEER_VERSION_STATE && stateType != SINK_GET_VERSION_STATE
84 && currentState_ != nullptr) {
85 HILOGI("update state from %{public}s to %{public}s",
86 STATEDATA[currentState_->GetStateType()].c_str(), STATEDATA[stateType].c_str());
87 } else {
88 HILOGI("update state: %{public}s", STATEDATA[stateType].c_str());
89 }
90 currentState_ = CreateState(stateType);
91 HILOGI("end");
92 return;
93 }
94
CreateState(CollabStateType stateType)95 std::shared_ptr<DSchedCollabState> DSchedCollabStateMachine::CreateState(CollabStateType stateType)
96 {
97 std::shared_ptr<DSchedCollabState> state = nullptr;
98 auto stateMachine = std::shared_ptr<DSchedCollabStateMachine>(shared_from_this());
99 switch (stateType) {
100 case SOURCE_GET_PEER_VERSION_STATE: {
101 state = std::make_shared<CollabSrcGetPeerVersionState>(stateMachine);
102 break;
103 }
104 case SOURCE_START_STATE: {
105 state = std::make_shared<CollabSrcStartState>(stateMachine);
106 break;
107 }
108 case SOURCE_WAIT_RESULT_STATE: {
109 state = std::make_shared<CollabSrcWaitResultState>(stateMachine);
110 break;
111 }
112 case SOURCE_WAIT_END_STATE: {
113 state = std::make_shared<CollabSrcWaitEndState>(stateMachine);
114 break;
115 }
116 case SINK_GET_VERSION_STATE: {
117 state = std::make_shared<CollabSinkGetVersionState>(stateMachine);
118 break;
119 }
120 case SINK_START_STATE: {
121 state = std::make_shared<CollabSinkStartState>(stateMachine);
122 break;
123 }
124 case SINK_CONNECT_STATE: {
125 state = std::make_shared<CollabSinkConnectState>(stateMachine);
126 break;
127 }
128 case SINK_WAIT_END_STATE: {
129 state = std::make_shared<CollabSinkWaitEndState>(stateMachine);
130 break;
131 }
132 default:
133 HILOGE("DSchedCollabStateMachine create state failed, stateType: %{public}s", STATEDATA[stateType].c_str());
134 break;
135 }
136 return state;
137 }
138
GetStateType()139 CollabStateType DSchedCollabStateMachine::GetStateType()
140 {
141 if (currentState_ == nullptr) {
142 return SOURCE_START_STATE;
143 }
144 return currentState_->GetStateType();
145 }
146 } // namespace DistributedSchedule
147 } // namespace OHOS
148