1 /*
2 * Copyright (c) 2021-2022 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_sink_handler.h"
17
18 #include <chrono>
19 #include <new>
20 #include <string>
21
22 #include "anonymous_string.h"
23 #include "dcamera_hisysevent_adapter.h"
24 #include "dcamera_sink_handler_ipc.h"
25 #include "dcamera_sink_load_callback.h"
26 #include "distributed_camera_constants.h"
27 #include "distributed_camera_errno.h"
28 #include "distributed_hardware_log.h"
29 #include "if_system_ability_manager.h"
30 #include "iservice_registry.h"
31 #include "idistributed_camera_sink.h"
32 #include "isystem_ability_load_callback.h"
33 #include "refbase.h"
34
35 namespace OHOS {
36 namespace DistributedHardware {
37 IMPLEMENT_SINGLE_INSTANCE(DCameraSinkHandler);
38
~DCameraSinkHandler()39 DCameraSinkHandler::~DCameraSinkHandler()
40 {
41 DHLOGI("~DCameraSinkHandler");
42 }
43
InitSink(const std::string & params)44 int32_t DCameraSinkHandler::InitSink(const std::string& params)
45 {
46 DHLOGI("DCameraSinkHandler::InitSink");
47 {
48 std::lock_guard<std::mutex> autoLock(producerMutex_);
49 if (state_ == DCAMERA_SA_STATE_START) {
50 return DCAMERA_OK;
51 }
52 }
53
54 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
55 if (sm == nullptr) {
56 DHLOGE("GetSourceLocalCamSrv GetSystemAbilityManager failed");
57 return DCAMERA_INIT_ERR;
58 }
59 ReportSaEvent(INIT_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "init sink sa event.");
60 sptr<DCameraSinkLoadCallback> loadCallback = new DCameraSinkLoadCallback(params);
61 int32_t ret = sm->LoadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, loadCallback);
62 if (ret != DCAMERA_OK) {
63 DHLOGE("systemAbilityId: %d load filed, result code: %d.", DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, ret);
64 return DCAMERA_INIT_ERR;
65 }
66 {
67 uint32_t interval = 1;
68 std::unique_lock<std::mutex> lock(producerMutex_);
69 producerCon_.wait_for(lock, std::chrono::minutes(interval), [this] {
70 return (this->state_ == DCAMERA_SA_STATE_START);
71 });
72 if (state_ == DCAMERA_SA_STATE_STOP) {
73 DHLOGE("SinkSA Start failed!");
74 return DCAMERA_INIT_ERR;
75 }
76 }
77 DHLOGI("DCameraSinkHandler InitSink end, result: %d", ret);
78 return DCAMERA_OK;
79 }
80
FinishStartSA(const std::string & params)81 void DCameraSinkHandler::FinishStartSA(const std::string& params)
82 {
83 DCameraSinkHandlerIpc::GetInstance().Init();
84 sptr<IDistributedCameraSink> dCameraSinkSrv = DCameraSinkHandlerIpc::GetInstance().GetSinkLocalCamSrv();
85 if (dCameraSinkSrv == nullptr) {
86 DHLOGE("DCameraSinkHandler::InitSink get Service failed");
87 return;
88 }
89 dCameraSinkSrv->InitSink(params);
90 std::unique_lock<std::mutex> lock(producerMutex_);
91 state_ = DCAMERA_SA_STATE_START;
92 producerCon_.notify_one();
93 }
94
FinishStartSAFailed(int32_t systemAbilityId)95 void DCameraSinkHandler::FinishStartSAFailed(int32_t systemAbilityId)
96 {
97 DHLOGI("SinkSA Start failed, systemAbilityId: %d.", systemAbilityId);
98 std::unique_lock<std::mutex> lock(producerMutex_);
99 state_ = DCAMERA_SA_STATE_STOP;
100 producerCon_.notify_one();
101 }
102
ReleaseSink()103 int32_t DCameraSinkHandler::ReleaseSink()
104 {
105 DHLOGI("DCameraSinkHandler::ReleaseSink");
106 sptr<IDistributedCameraSink> dCameraSinkSrv = DCameraSinkHandlerIpc::GetInstance().GetSinkLocalCamSrv();
107 if (dCameraSinkSrv == nullptr) {
108 DHLOGE("DCameraSinkHandler::ReleaseSink get Service failed");
109 return DCAMERA_BAD_VALUE;
110 }
111
112 ReportSaEvent(RELEASE_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "release sink sa event.");
113 int32_t ret = dCameraSinkSrv->ReleaseSink();
114 if (ret != DCAMERA_OK) {
115 DHLOGE("DCameraSinkHandler::ReleaseSink sink service release failed, ret: %d", ret);
116 return ret;
117 }
118
119 DCameraSinkHandlerIpc::GetInstance().UnInit();
120 std::unique_lock<std::mutex> lock(producerMutex_);
121 state_ = DCAMERA_SA_STATE_STOP;
122 DHLOGI("DCameraSinkHandler::ReleaseSink success");
123 return DCAMERA_OK;
124 }
125
SubscribeLocalHardware(const std::string & dhId,const std::string & parameters)126 int32_t DCameraSinkHandler::SubscribeLocalHardware(const std::string& dhId, const std::string& parameters)
127 {
128 DHLOGI("DCameraSinkHandler::SubscribeLocalHardware dhId: %s", GetAnonyString(dhId).c_str());
129 sptr<IDistributedCameraSink> dCameraSinkSrv = DCameraSinkHandlerIpc::GetInstance().GetSinkLocalCamSrv();
130 if (dCameraSinkSrv == nullptr) {
131 DHLOGE("DCameraSinkHandler::SubscribeLocalHardware get Service failed");
132 return DCAMERA_BAD_VALUE;
133 }
134 return dCameraSinkSrv->SubscribeLocalHardware(dhId, parameters);
135 }
136
UnsubscribeLocalHardware(const std::string & dhId)137 int32_t DCameraSinkHandler::UnsubscribeLocalHardware(const std::string& dhId)
138 {
139 DHLOGI("DCameraSinkHandler::UnsubscribeLocalHardware dhId: %s", GetAnonyString(dhId).c_str());
140 sptr<IDistributedCameraSink> dCameraSinkSrv = DCameraSinkHandlerIpc::GetInstance().GetSinkLocalCamSrv();
141 if (dCameraSinkSrv == nullptr) {
142 DHLOGE("DCameraSinkHandler::UnsubscribeLocalHardware get Service failed");
143 return DCAMERA_BAD_VALUE;
144 }
145 return dCameraSinkSrv->UnsubscribeLocalHardware(dhId);
146 }
147
GetSinkHardwareHandler()148 IDistributedHardwareSink *GetSinkHardwareHandler()
149 {
150 DHLOGI("DCameraSinkHandler::GetSinkHardwareHandler");
151 return &DCameraSinkHandler::GetInstance();
152 }
153 } // namespace DistributedHardware
154 } // namespace OHOS