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 
16 #include "dcamera_source_config_stream_state.h"
17 
18 #include "dcamera_source_dev.h"
19 #include "dcamera_source_state_machine.h"
20 #include "distributed_camera_errno.h"
21 #include "distributed_hardware_log.h"
22 
23 namespace OHOS {
24 namespace DistributedHardware {
DCameraSourceConfigStreamState(std::shared_ptr<DCameraSourceStateMachine> & stateMachine)25 DCameraSourceConfigStreamState::DCameraSourceConfigStreamState(std::shared_ptr<DCameraSourceStateMachine>& stateMachine)
26     : stateMachine_(stateMachine)
27 {
28     memberFuncMap_[DCAMERA_EVENT_REGIST] = &DCameraSourceConfigStreamState::DoRegisterTask;
29     memberFuncMap_[DCAMERA_EVENT_UNREGIST] = &DCameraSourceConfigStreamState::DoUnregisterTask;
30     memberFuncMap_[DCAMERA_EVENT_OPEN] = &DCameraSourceConfigStreamState::DoOpenTask;
31     memberFuncMap_[DCAMERA_EVENT_CLOSE] = &DCameraSourceConfigStreamState::DoCloseTask;
32     memberFuncMap_[DCAMERA_EVENT_CONFIG_STREAMS] = &DCameraSourceConfigStreamState::DoConfigStreamsTask;
33     memberFuncMap_[DCAMERA_EVENT_RELEASE_STREAMS] = &DCameraSourceConfigStreamState::DoReleaseStreamsTask;
34     memberFuncMap_[DCAMERA_EVENT_START_CAPTURE] = &DCameraSourceConfigStreamState::DoStartCaptureTask;
35     memberFuncMap_[DCAMERA_EVENT_STOP_CAPTURE] = &DCameraSourceConfigStreamState::DoStopCaptureTask;
36     memberFuncMap_[DCAMERA_EVENT_UPDATE_SETTINGS] = &DCameraSourceConfigStreamState::DoUpdateSettingsTask;
37     memberFuncMap_[DCAMERA_EVENT_NOFIFY] = &DCameraSourceConfigStreamState::DoEventNofityTask;
38 }
39 
Execute(std::shared_ptr<DCameraSourceDev> & camDev,DCAMERA_EVENT eventType,DCameraSourceEvent & event)40 int32_t DCameraSourceConfigStreamState::Execute(std::shared_ptr<DCameraSourceDev>& camDev, DCAMERA_EVENT eventType,
41     DCameraSourceEvent& event)
42 {
43     DHLOGI("DCameraSourceConfigStreamState execute %{public}d", eventType);
44     int32_t ret = DCAMERA_NOT_FOUND;
45     switch (eventType) {
46         case DCAMERA_EVENT_REGIST:
47             ret = DoRegisterTask(camDev, event);
48             break;
49         case DCAMERA_EVENT_UNREGIST:
50             ret = DoUnregisterTask(camDev, event);
51             break;
52         case DCAMERA_EVENT_OPEN:
53             ret = DoOpenTask(camDev, event);
54             break;
55         case DCAMERA_EVENT_CLOSE:
56             ret = DoCloseTask(camDev, event);
57             break;
58         case DCAMERA_EVENT_CONFIG_STREAMS:
59             ret = DoConfigStreamsTask(camDev, event);
60             break;
61         case DCAMERA_EVENT_RELEASE_STREAMS:
62             ret = DoReleaseStreamsTask(camDev, event);
63             break;
64         case DCAMERA_EVENT_START_CAPTURE:
65             ret = DoStartCaptureTask(camDev, event);
66             break;
67         case DCAMERA_EVENT_STOP_CAPTURE:
68             ret = DoStopCaptureTask(camDev, event);
69             break;
70         case DCAMERA_EVENT_UPDATE_SETTINGS:
71             ret = DoUpdateSettingsTask(camDev, event);
72             break;
73         case DCAMERA_EVENT_NOFIFY:
74             ret = DoEventNofityTask(camDev, event);
75             break;
76         default:
77             DHLOGE("DCameraSourceConfigStreamState execute %{public}d in wrong state", eventType);
78             return DCAMERA_WRONG_STATE;
79     }
80     if (ret != DCAMERA_OK) {
81         DHLOGE("DCameraSourceConfigStreamState execute %{public}d failed, ret: %{public}d", eventType, ret);
82     }
83     return ret;
84 }
85 
GetStateType()86 DCameraStateType DCameraSourceConfigStreamState::GetStateType()
87 {
88     return DCAMERA_STATE_CONFIG_STREAM;
89 }
90 
DoRegisterTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)91 int32_t DCameraSourceConfigStreamState::DoRegisterTask(std::shared_ptr<DCameraSourceDev>& camDev,
92     DCameraSourceEvent& event)
93 {
94     DHLOGI("DCameraSourceConfigStreamState DoRegisterTask Idempotent");
95     return DCAMERA_OK;
96 }
97 
DoUnregisterTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)98 int32_t DCameraSourceConfigStreamState::DoUnregisterTask(std::shared_ptr<DCameraSourceDev>& camDev,
99     DCameraSourceEvent& event)
100 {
101     std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
102     camEvent->eventType_ = DCAMERA_MESSAGE;
103     camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
104     int32_t ret = camDev->CameraEventNotify(camEvent);
105     if (ret != DCAMERA_OK) {
106         DHLOGE("CameraEventNotify failed: %{public}d", ret);
107         return ret;
108     }
109 
110     ret = camDev->CloseCamera();
111     if (ret != DCAMERA_OK) {
112         DHLOGE("CloseCamera failed, ret: %{public}d", ret);
113         return ret;
114     }
115 
116     ret = camDev->ReleaseAllStreams();
117     if (ret != DCAMERA_OK) {
118         DHLOGE("ReleaseAllStreams failed, ret: %{public}d", ret);
119         return ret;
120     }
121 
122     std::shared_ptr<DCameraRegistParam> param;
123     ret = event.GetDCameraRegistParam(param);
124     if (ret != DCAMERA_OK) {
125         return ret;
126     }
127     ret = camDev->UnRegister(param);
128     if (ret != DCAMERA_OK) {
129         DHLOGE("UnRegister failed: %{public}d", ret);
130         return ret;
131     }
132     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
133     if (stateMachine == nullptr) {
134         DHLOGE("can not get stateMachine");
135         return DCAMERA_BAD_VALUE;
136     }
137     stateMachine->UpdateState(DCAMERA_STATE_INIT);
138     return DCAMERA_OK;
139 }
140 
DoOpenTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)141 int32_t DCameraSourceConfigStreamState::DoOpenTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
142 {
143     DHLOGI("DCameraSourceConfigStreamState DoOpenTask Idempotent");
144     return DCAMERA_OK;
145 }
146 
DoCloseTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)147 int32_t DCameraSourceConfigStreamState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev,
148     DCameraSourceEvent& event)
149 {
150     int32_t ret = camDev->CloseCamera();
151     if (ret != DCAMERA_OK) {
152         DHLOGE("CloseCamera failed, ret: %{public}d", ret);
153         return ret;
154     }
155 
156     ret = camDev->ReleaseAllStreams();
157     if (ret != DCAMERA_OK) {
158         DHLOGE("ReleaseAllStreams failed, ret: %{public}d", ret);
159         return ret;
160     }
161     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
162     if (stateMachine == nullptr) {
163         DHLOGE("can not get stateMachine");
164         return DCAMERA_BAD_VALUE;
165     }
166     stateMachine->UpdateState(DCAMERA_STATE_REGIST);
167     return DCAMERA_OK;
168 }
169 
DoConfigStreamsTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)170 int32_t DCameraSourceConfigStreamState::DoConfigStreamsTask(std::shared_ptr<DCameraSourceDev>& camDev,
171     DCameraSourceEvent& event)
172 {
173     std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
174     int32_t ret = event.GetStreamInfos(streamInfos);
175     if (ret != DCAMERA_OK) {
176         return ret;
177     }
178 
179     ret = camDev->ConfigStreams(streamInfos);
180     if (ret != DCAMERA_OK) {
181         DHLOGE("ConfigStreams failed, ret: %{public}d", ret);
182         return ret;
183     }
184 
185     if (streamInfos.empty()) {
186         std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
187         if (stateMachine == nullptr) {
188             DHLOGE("can not get stateMachine");
189             return DCAMERA_BAD_VALUE;
190         }
191         stateMachine->UpdateState(DCAMERA_STATE_OPENED);
192     }
193     return DCAMERA_OK;
194 }
195 
DoReleaseStreamsTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)196 int32_t DCameraSourceConfigStreamState::DoReleaseStreamsTask(std::shared_ptr<DCameraSourceDev>& camDev,
197     DCameraSourceEvent& event)
198 {
199     std::vector<int> streamIds;
200     int32_t ret = event.GetStreamIds(streamIds);
201     if (ret != DCAMERA_OK) {
202         return ret;
203     }
204 
205     bool isAllRelease = false;
206     ret = camDev->ReleaseStreams(streamIds, isAllRelease);
207     if (ret != DCAMERA_OK) {
208         DHLOGE("ReleaseStreams failed, ret: %{public}d", ret);
209         return ret;
210     }
211 
212     if (isAllRelease) {
213         std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
214         if (stateMachine == nullptr) {
215             DHLOGE("can not get stateMachine");
216             return DCAMERA_BAD_VALUE;
217         }
218         stateMachine->UpdateState(DCAMERA_STATE_OPENED);
219     }
220     return DCAMERA_OK;
221 }
222 
DoStartCaptureTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)223 int32_t DCameraSourceConfigStreamState::DoStartCaptureTask(std::shared_ptr<DCameraSourceDev>& camDev,
224     DCameraSourceEvent& event)
225 {
226     std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
227     int32_t ret = event.GetCaptureInfos(captureInfos);
228     if (ret != DCAMERA_OK) {
229         return ret;
230     }
231 
232     ret = camDev->StartCapture(captureInfos);
233     if (ret != DCAMERA_OK) {
234         DHLOGE("StartCapture failed, ret: %{public}d", ret);
235         return ret;
236     }
237     std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
238     if (stateMachine == nullptr) {
239         DHLOGE("can not get stateMachine");
240         return DCAMERA_BAD_VALUE;
241     }
242     stateMachine->UpdateState(DCAMERA_STATE_CAPTURE);
243     return DCAMERA_OK;
244 }
245 
DoStopCaptureTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)246 int32_t DCameraSourceConfigStreamState::DoStopCaptureTask(std::shared_ptr<DCameraSourceDev>& camDev,
247     DCameraSourceEvent& event)
248 {
249     DHLOGI("DCameraSourceConfigStreamState DoStopCaptureTask Idempotent");
250     return DCAMERA_OK;
251 }
252 
DoUpdateSettingsTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)253 int32_t DCameraSourceConfigStreamState::DoUpdateSettingsTask(std::shared_ptr<DCameraSourceDev>& camDev,
254     DCameraSourceEvent& event)
255 {
256     std::vector<std::shared_ptr<DCameraSettings>> settings;
257     int32_t ret = event.GetCameraSettings(settings);
258     if (ret != DCAMERA_OK) {
259         return ret;
260     }
261 
262     ret = camDev->UpdateSettings(settings);
263     if (ret != DCAMERA_OK) {
264         DHLOGE("UpdateSettings failed, ret: %{public}d", ret);
265         return ret;
266     }
267     return DCAMERA_OK;
268 }
269 
DoEventNofityTask(std::shared_ptr<DCameraSourceDev> & camDev,DCameraSourceEvent & event)270 int32_t DCameraSourceConfigStreamState::DoEventNofityTask(std::shared_ptr<DCameraSourceDev>& camDev,
271     DCameraSourceEvent& event)
272 {
273     std::shared_ptr<DCameraEvent> camEvent;
274     int32_t ret = event.GetCameraEvent(camEvent);
275     if (ret != DCAMERA_OK) {
276         return ret;
277     }
278 
279     ret = camDev->CameraEventNotify(camEvent);
280     if (ret != DCAMERA_OK) {
281         DHLOGE("CameraEventNotify failed, ret: %{public}d", ret);
282         return ret;
283     }
284     return DCAMERA_OK;
285 }
286 } // namespace DistributedHardware
287 } // namespace OHOS
288