1 /*
2 * Copyright (c) 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 "light_interface_impl.h"
17 #include <hdf_base.h>
18 #include <hdf_log.h>
19 #include "light_if.h"
20
21 #define HDF_LOG_TAG uhdf_light
22
23 namespace OHOS {
24 namespace HDI {
25 namespace Light {
26 namespace V1_0 {
LightInterfaceImplGetInstance(void)27 extern "C" ILightInterface *LightInterfaceImplGetInstance(void)
28 {
29 return new (std::nothrow) LightInterfaceImpl();
30 }
31
GetLightInfo(std::vector<HdfLightInfo> & info)32 int32_t LightInterfaceImpl::GetLightInfo(std::vector<HdfLightInfo>& info)
33 {
34 HDF_LOGI("%{public}s: Enter the GetLightInfo function.", __func__);
35 const struct LightInterface *lightInterface = NewLightInterfaceInstance();
36 if (lightInterface == nullptr || lightInterface->GetLightInfo == nullptr) {
37 HDF_LOGE("%{public}s: get light Module instance failed", __func__);
38 return HDF_FAILURE;
39 }
40
41 struct LightInfo *lightInfo = nullptr;
42 uint32_t count = 0;
43 int32_t ret = lightInterface->GetLightInfo(&lightInfo, &count);
44 if (ret != HDF_SUCCESS) {
45 HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
46 return ret;
47 }
48
49 while (count--) {
50 HdfLightInfo hdfLightInfo;
51 hdfLightInfo.lightId = lightInfo->lightId;
52 hdfLightInfo.lightType = lightInfo->lightType;
53 hdfLightInfo.lightName = lightInfo->lightName;
54 hdfLightInfo.lightNumber = lightInfo->lightNumber;
55 info.push_back(hdfLightInfo);
56 lightInfo++;
57 }
58 return HDF_SUCCESS;
59 }
60
TurnOnLight(int32_t lightId,const HdfLightEffect & effect)61 int32_t LightInterfaceImpl::TurnOnLight(int32_t lightId, const HdfLightEffect& effect)
62 {
63 HDF_LOGI("%{public}s: Enter the TurnOnLight function, lightId is %{public}d", __func__, lightId);
64 const struct LightInterface *lightInterface = NewLightInterfaceInstance();
65 if (lightInterface == nullptr || lightInterface->TurnOnLight == nullptr) {
66 HDF_LOGE("%{public}s: get light Module instance failed", __func__);
67 return HDF_FAILURE;
68 }
69
70 LightEffect lightEffect;
71 lightEffect.lightColor.colorValue.rgbColor.b = effect.lightColor.colorValue.rgbColor.b;
72 lightEffect.lightColor.colorValue.rgbColor.g = effect.lightColor.colorValue.rgbColor.g;
73 lightEffect.lightColor.colorValue.rgbColor.r = effect.lightColor.colorValue.rgbColor.r;
74 lightEffect.lightColor.colorValue.wrgbColor.b = effect.lightColor.colorValue.wrgbColor.b;
75 lightEffect.lightColor.colorValue.wrgbColor.g = effect.lightColor.colorValue.wrgbColor.g;
76 lightEffect.lightColor.colorValue.wrgbColor.r = effect.lightColor.colorValue.wrgbColor.r;
77 lightEffect.lightColor.colorValue.wrgbColor.w = effect.lightColor.colorValue.wrgbColor.w;
78 lightEffect.flashEffect.flashMode = effect.flashEffect.flashMode;
79 lightEffect.flashEffect.onTime = effect.flashEffect.onTime;
80 lightEffect.flashEffect.offTime = effect.flashEffect.offTime;
81 int32_t ret = lightInterface->TurnOnLight(lightId, &lightEffect);
82 if (ret != HDF_SUCCESS) {
83 HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
84 }
85
86 return ret;
87 }
88
TurnOnMultiLights(int32_t lightId,const std::vector<HdfLightColor> & colors)89 int32_t LightInterfaceImpl::TurnOnMultiLights(int32_t lightId, const std::vector<HdfLightColor>& colors)
90 {
91 HDF_LOGI("%{public}s: Enter the TurnOnMultiLights function, lightId is %{public}d", __func__, lightId);
92 const struct LightInterface *lightInterface = NewLightInterfaceInstance();
93 if (lightInterface == nullptr || lightInterface->TurnOnMultiLights == nullptr) {
94 HDF_LOGE("%{public}s: get light module instance failed", __func__);
95 return HDF_FAILURE;
96 }
97
98 uint32_t num = colors.size();
99 LightColor lightColor[num];
100 int32_t i = 0;
101 for (auto iter : colors) {
102 lightColor[i].colorValue.rgbColor.b = iter.colorValue.rgbColor.b;
103 lightColor[i].colorValue.rgbColor.g = iter.colorValue.rgbColor.g;
104 lightColor[i].colorValue.rgbColor.r = iter.colorValue.rgbColor.r;
105 lightColor[i].colorValue.wrgbColor.b = iter.colorValue.wrgbColor.b;
106 lightColor[i].colorValue.wrgbColor.g = iter.colorValue.wrgbColor.g;
107 lightColor[i].colorValue.wrgbColor.r = iter.colorValue.wrgbColor.r;
108 lightColor[i++].colorValue.wrgbColor.w = iter.colorValue.wrgbColor.w;
109 }
110
111 int32_t ret = lightInterface->TurnOnMultiLights(lightId, lightColor, num);
112 if (ret != HDF_SUCCESS) {
113 HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
114 }
115
116 return ret;
117 }
118
TurnOffLight(int32_t lightId)119 int32_t LightInterfaceImpl::TurnOffLight(int32_t lightId)
120 {
121 HDF_LOGI("%{public}s: Enter the TurnOffLight function, lightId is %{public}d", __func__, lightId);
122 const struct LightInterface *lightInterface = NewLightInterfaceInstance();
123 if (lightInterface == nullptr || lightInterface->TurnOffLight == nullptr) {
124 HDF_LOGE("%{public}s: get light Module instance failed", __func__);
125 return HDF_FAILURE;
126 }
127 int32_t ret = lightInterface->TurnOffLight(lightId);
128 if (ret != HDF_SUCCESS) {
129 HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
130 }
131
132 return ret;
133 }
134 } // V1_0
135 } // Light
136 } // HDI
137 } // OHOS
138