1 /* 2 * Copyright (c) 2024 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 #ifndef OHOS_HDI_DISPLAY_V1_2_DISPLAY_CMD_REQUESTER_H 17 #define OHOS_HDI_DISPLAY_V1_2_DISPLAY_CMD_REQUESTER_H 18 19 #include "v1_0/display_command/display_cmd_responser.h" 20 #include "v1_1/display_command/display_cmd_responser.h" 21 #include "v1_2/display_composer_type.h" 22 #include "v1_2/display_command/display_cmd_utils.h" 23 #include "hdf_trace.h" 24 25 #define DISPLAY_TRACE HdfTrace trace(__func__, "HDI:DISP:") 26 27 namespace OHOS { 28 namespace HDI { 29 namespace Display { 30 namespace Composer { 31 namespace V1_2 { 32 using namespace OHOS::HDI::Base; 33 34 typedef struct CommitInfo { 35 int32_t fence; 36 int32_t skipRet; 37 bool needFlush; 38 std::vector<uint32_t> compLayers; 39 std::vector<int32_t> compTypes; 40 std::vector<uint32_t> layers; 41 std::vector<int32_t> fences; 42 } CommitInfo; 43 44 template <typename Transfer, typename VdiImpl> 45 class DisplayCmdResponser : public V1_1::DisplayCmdResponser<Transfer, VdiImpl> { 46 public: Create(VdiImpl * impl,std::shared_ptr<DeviceCacheManager> cacheMgr)47 static std::unique_ptr<DisplayCmdResponser> Create(VdiImpl* impl, std::shared_ptr<DeviceCacheManager> cacheMgr) 48 { 49 DISPLAY_CHK_RETURN(impl == nullptr, nullptr, 50 HDF_LOGE("%{public}s: error, VdiImpl is nullptr", __func__)); 51 DISPLAY_CHK_RETURN(cacheMgr == nullptr, nullptr, 52 HDF_LOGE("%{public}s: error, VdiImpl is nullptr", __func__)); 53 return std::make_unique<DisplayCmdResponser>(impl, cacheMgr); 54 } 55 DisplayCmdResponser(VdiImpl * impl,std::shared_ptr<DeviceCacheManager> cacheMgr)56 DisplayCmdResponser(VdiImpl* impl, std::shared_ptr<DeviceCacheManager> cacheMgr) : BaseType1_1(impl, cacheMgr) {} 57 ~DisplayCmdResponser()58 virtual ~DisplayCmdResponser() {} 59 ProcessRequestCmd(CommandDataUnpacker & unpacker,int32_t cmd,const std::vector<HdifdInfo> & inFds,std::vector<HdifdInfo> & outFds)60 int32_t ProcessRequestCmd(CommandDataUnpacker& unpacker, int32_t cmd, 61 const std::vector<HdifdInfo>& inFds, std::vector<HdifdInfo>& outFds) 62 { 63 HDF_LOGD("%{public}s: HDI 1.2 PackSection, cmd-[%{public}d] = %{public}s", 64 __func__, cmd, CmdUtils::CommandToString(cmd)); 65 if (cmd == REQUEST_CMD_COMMIT_AND_GET_RELEASE_FENCE) { 66 OnCommitAndGetReleaseFence(unpacker, outFds); 67 } else if (cmd == REQUEST_CMD_SET_DISPLAY_CONSTRAINT) { 68 OnSetDisplayConstraint(unpacker); 69 } else if (cmd == REQUEST_CMD_SET_LAYER_PERFRAME_PARAM) { 70 OnSetLayerPerFrameParam(unpacker); 71 } else if (cmd == REQUEST_CMD_SET_DISPLAY_PERFRAME_PARAM) { 72 OnSetDisplayPerFrameParam(unpacker); 73 } else { 74 return V1_0::DisplayCmdResponser<Transfer, VdiImpl>::ProcessRequestCmd(unpacker, cmd, inFds, outFds); 75 } 76 return HDF_SUCCESS; 77 } 78 ReplyNotSkipInfo(uint32_t & devId,CommitInfo & commitInfo)79 void ReplyNotSkipInfo(uint32_t& devId, CommitInfo& commitInfo) 80 { 81 DISPLAY_CHECK(replyPacker_.WriteUint32(devId) == false, 82 HDF_LOGE("%{public}s, write devId error", __func__)); 83 84 DISPLAY_CHECK(replyPacker_.WriteBool(commitInfo.needFlush) == false, 85 HDF_LOGE("%{public}s, write needFlush error", __func__)); 86 87 // Write compLayers vector 88 uint32_t vectSize = static_cast<uint32_t>(commitInfo.compLayers.size()); 89 DISPLAY_CHECK(replyPacker_.WriteUint32(vectSize) == false, 90 HDF_LOGE("%{public}s, write compLayers.size error", __func__)); 91 92 for (uint32_t i = 0; i < vectSize; i++) { 93 DISPLAY_CHECK(replyPacker_.WriteUint32(commitInfo.compLayers[i]) == false, 94 HDF_LOGE("%{public}s, write compLayers error", __func__)); 95 } 96 // Write compTypes vector 97 vectSize = static_cast<uint32_t>(commitInfo.compTypes.size()); 98 DISPLAY_CHECK(replyPacker_.WriteUint32(vectSize) == false, 99 HDF_LOGE("%{public}s, write compTypes.size error", __func__)); 100 101 for (uint32_t i = 0; i < vectSize; i++) { 102 DISPLAY_CHECK(replyPacker_.WriteUint32(commitInfo.compTypes[i]) == false, 103 HDF_LOGE("%{public}s, write compTypes error", __func__)); 104 } 105 } 106 ReplyCommitAndGetReleaseFence(std::vector<HdifdInfo> & outFds,uint32_t & devId,CommitInfo & commitInfo)107 void ReplyCommitAndGetReleaseFence(std::vector<HdifdInfo>& outFds, uint32_t& devId, CommitInfo& commitInfo) 108 { 109 int32_t ret = HDF_SUCCESS; 110 uint32_t vectSize = 0; 111 112 HdifdParcelable fdParcel(commitInfo.fence); 113 DISPLAY_CHK_CONDITION(ret, HDF_SUCCESS, 114 CmdUtils::StartSection(REPLY_CMD_COMMIT_AND_GET_RELEASE_FENCE, replyPacker_), 115 HDF_LOGE("%{public}s, StartSection error", __func__)); 116 117 DISPLAY_CHK_CONDITION(ret, HDF_SUCCESS, CmdUtils::FileDescriptorPack(fdParcel.GetFd(), replyPacker_, outFds), 118 HDF_LOGE("%{public}s, FileDescriptorPack error", __func__)); 119 120 DISPLAY_CHECK(replyPacker_.WriteInt32(commitInfo.skipRet) == false, 121 HDF_LOGE("%{public}s, write skip validate return value error", __func__)); 122 if (commitInfo.skipRet != HDF_SUCCESS) { 123 ReplyNotSkipInfo(devId, commitInfo); 124 } else { 125 // Write layers vector 126 vectSize = static_cast<uint32_t>(commitInfo.layers.size()); 127 DISPLAY_CHECK(replyPacker_.WriteUint32(vectSize) == false, 128 HDF_LOGE("%{public}s, write layers.size error", __func__)); 129 130 for (uint32_t i = 0; i < vectSize; i++) { 131 DISPLAY_CHECK(replyPacker_.WriteUint32(commitInfo.layers[i]) == false, 132 HDF_LOGE("%{public}s, write layers error", __func__)); 133 } 134 135 // Write fences vector 136 vectSize = static_cast<uint32_t>(commitInfo.fences.size()); 137 DISPLAY_CHECK(replyPacker_.WriteUint32(vectSize) == false, 138 HDF_LOGE("%{public}s, write fences.size error", __func__)); 139 140 for (uint32_t i = 0; i < vectSize; i++) { 141 ret = CmdUtils::FileDescriptorPack(commitInfo.fences[i], replyPacker_, outFds, false); 142 DISPLAY_CHECK(ret != HDF_SUCCESS, HDF_LOGE("%{public}s, write fences error", __func__)); 143 } 144 } 145 146 DISPLAY_CHK_CONDITION(ret, HDF_SUCCESS, CmdUtils::EndSection(replyPacker_), 147 HDF_LOGE("%{public}s, EndSection error", __func__)); 148 149 replyCommandCnt_++; 150 151 #ifndef DISPLAY_COMMUNITY 152 fdParcel.Move(); 153 #endif // DISPLAY_COMMUNITY 154 155 if (ret != HDF_SUCCESS) { 156 errMaps_.emplace(REQUEST_CMD_COMMIT_AND_GET_RELEASE_FENCE, ret); 157 } 158 } 159 CommitInfoDump(void)160 void CommitInfoDump(void) 161 { 162 #ifdef DISPLAY_COMSPOER_DEBUG_DUMP 163 const std::string SWITCH_ON = "on"; 164 const uint32_t DUMP_CACHE_SWITCH_LEN = 4; 165 char dumpSwitch[DUMP_CACHE_SWITCH_LEN] = {0}; 166 GetParameter("hdi.composer.dumpcache", "off", dumpSwitch, DUMP_CACHE_SWITCH_LEN); 167 168 if (SWITCH_ON.compare(dumpSwitch) == 0) { 169 cacheMgr_->Dump(); 170 } 171 #endif 172 } 173 OnCommitAndGetReleaseFence(CommandDataUnpacker & unpacker,std::vector<HdifdInfo> & outFds)174 void OnCommitAndGetReleaseFence(CommandDataUnpacker& unpacker, std::vector<HdifdInfo>& outFds) 175 { 176 DISPLAY_TRACE; 177 uint32_t devId = 0; 178 bool isSupportSkipValidate = false; 179 bool isValidated = false; 180 int32_t ret = HDF_SUCCESS; 181 CommitInfo commitInfo; 182 commitInfo.fence = -1; 183 commitInfo.skipRet = HDF_FAILURE; 184 commitInfo.needFlush = false; 185 186 CommitInfoDump(); 187 if (!unpacker.ReadUint32(devId)) { 188 HDF_LOGE("%{public}s, read devId error", __func__); 189 goto REPLY; 190 } 191 if (!unpacker.ReadBool(isSupportSkipValidate)) { 192 HDF_LOGE("%{public}s, read isSupportSkipValidate error", __func__); 193 goto REPLY; 194 } 195 196 if (!unpacker.ReadBool(isValidated)) { 197 HDF_LOGE("%{public}s, read isValidated error", __func__); 198 goto REPLY; 199 } 200 if (isSupportSkipValidate || isValidated) { 201 HdfTrace traceVdi("Commit", "HDI:DISP:HARDWARE"); 202 commitInfo.skipRet = impl_->Commit(devId, commitInfo.fence); 203 } 204 205 if (commitInfo.skipRet != HDF_SUCCESS && isValidated == false) { 206 { 207 HdfTrace traceVdi("PrepareDisplayLayers", "HDI:DISP:HARDWARE"); 208 ret = impl_->PrepareDisplayLayers(devId, commitInfo.needFlush); 209 } 210 if (ret == HDF_SUCCESS) { 211 HdfTrace traceVdi("GetDisplayCompChange", "HDI:DISP:HARDWARE"); 212 ret = impl_->GetDisplayCompChange(devId, commitInfo.compLayers, commitInfo.compTypes); 213 } 214 } else { 215 HdfTrace traceVdi("GetDisplayReleaseFence", "HDI:DISP:HARDWARE"); 216 if (impl_->GetDisplayReleaseFence(devId, commitInfo.layers, commitInfo.fences) != HDF_SUCCESS) { 217 HDF_LOGE("%{public}s, GetDisplayReleaseFence failed with ret = %{public}d", __func__, ret); 218 } 219 } 220 HDF_LOGD("skipRet:%{public}d,fence:%{public}d,needFlush:%{public}d, ssv:%{public}d, iv:%{public}d", 221 commitInfo.skipRet, commitInfo.fence, commitInfo.needFlush, isSupportSkipValidate, isValidated); 222 REPLY: 223 ReplyCommitAndGetReleaseFence(outFds, devId, commitInfo); 224 } 225 CmdRequest(uint32_t inEleCnt,const std::vector<HdifdInfo> & inFds,uint32_t & outEleCnt,std::vector<HdifdInfo> & outFds)226 int32_t CmdRequest(uint32_t inEleCnt, const std::vector<HdifdInfo>& inFds, uint32_t& outEleCnt, 227 std::vector<HdifdInfo>& outFds) 228 { 229 std::shared_ptr<char> requestData(new char[inEleCnt * CmdUtils::ELEMENT_SIZE], std::default_delete<char[]>()); 230 int32_t ret = CmdRequestDataRead(requestData, inEleCnt); 231 232 CommandDataUnpacker unpacker; 233 unpacker.Init(requestData.get(), inEleCnt << CmdUtils::MOVE_SIZE); 234 #ifdef DEBUG_DISPLAY_CMD_RAW_DATA 235 unpacker.Dump(); 236 #endif // DEBUG_DISPLAY_CMD_RAW_DATA 237 238 int32_t unpackCmd = -1; 239 bool retBool = unpacker.PackBegin(unpackCmd); 240 DISPLAY_CHK_RETURN(retBool == false, HDF_FAILURE, 241 HDF_LOGE("%{public}s: error: Check RequestBegin failed", __func__)); 242 DISPLAY_CHK_RETURN(unpackCmd != CONTROL_CMD_REQUEST_BEGIN, HDF_FAILURE, 243 HDF_LOGI("error: unpacker PackBegin cmd not match, cmd(%{public}d)=%{public}s.", unpackCmd, 244 CmdUtils::CommandToString(unpackCmd))); 245 246 DISPLAY_CHK_RETURN(PeriodDataReset() == HDF_FAILURE, HDF_FAILURE, 247 HDF_LOGE("%{public}s: error: PeriodDataReset failed", __func__)); 248 while (ret == HDF_SUCCESS && unpacker.NextSection()) { 249 if (!unpacker.BeginSection(unpackCmd)) { 250 HDF_LOGE("error: PackSection failed, unpackCmd=%{public}s.", 251 CmdUtils::CommandToString(unpackCmd)); 252 ret = HDF_FAILURE; 253 break; 254 } 255 ret = ProcessRequestCmd(unpacker, unpackCmd, inFds, outFds); 256 } 257 258 DISPLAY_CHK_RETURN(ret != HDF_SUCCESS, ret, 259 HDF_LOGE("%{public}s: ProcessRequestCmd failed", __func__)); 260 /* pack request end commands */ 261 replyPacker_.PackEnd(CONTROL_CMD_REPLY_END); 262 263 #ifdef DEBUG_DISPLAY_CMD_RAW_DATA 264 /* just for debug */ 265 replyPacker_.Dump(); 266 HDF_LOGI("CmdReply command cnt=%{public}d", replyCommandCnt_); 267 #endif // DEBUG_DISPLAY_CMD_RAW_DATA 268 269 /* Write reply pack */ 270 outEleCnt = replyPacker_.ValidSize() >> CmdUtils::MOVE_SIZE; 271 ret = CmdRequestDataWrite(outEleCnt); 272 if (ret != HDF_SUCCESS) { 273 HDF_LOGE("Reply write failure, ret=%{public}d", ret); 274 outEleCnt = 0; 275 } 276 return ret; 277 } 278 OnSetDisplayConstraint(CommandDataUnpacker & unpacker)279 int32_t OnSetDisplayConstraint(CommandDataUnpacker& unpacker) 280 { 281 DISPLAY_TRACE; 282 uint32_t devId = 0; 283 uint64_t frameID = 0; 284 uint64_t ns = 0; 285 uint32_t type = 0; 286 287 int32_t ret = unpacker.ReadUint32(devId) ? HDF_SUCCESS : HDF_FAILURE; 288 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 289 290 ret = unpacker.ReadUint64(frameID) ? HDF_SUCCESS : HDF_FAILURE; 291 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 292 293 ret = unpacker.ReadUint64(ns) ? HDF_SUCCESS : HDF_FAILURE; 294 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 295 296 ret = unpacker.ReadUint32(type) ? HDF_SUCCESS : HDF_FAILURE; 297 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 298 299 if (impl_ != nullptr && impl_->SetDisplayConstraint != nullptr) { 300 ret = impl_->SetDisplayConstraint(devId, frameID, ns, type); 301 } 302 303 if (ret != HDF_SUCCESS && ret != DISPLAY_NOT_SUPPORT && ret != HDF_ERR_NOT_SUPPORT) { 304 HDF_LOGE("SetDisplayConstraint failed with ret = %{public}d", ret); 305 } 306 EXIT: 307 if (ret != HDF_SUCCESS) { 308 errMaps_.emplace(REQUEST_CMD_SET_DISPLAY_CONSTRAINT, ret); 309 } 310 return ret; 311 } 312 OnSetLayerPerFrameParam(CommandDataUnpacker & unpacker)313 int32_t OnSetLayerPerFrameParam(CommandDataUnpacker& unpacker) 314 { 315 DISPLAY_TRACE; 316 uint32_t devId = 0; 317 uint32_t layerId = 0; 318 std::string key; 319 std::vector<int8_t> value; 320 uint32_t vectSize = 0; 321 uint32_t vectStrSize = 0; 322 323 int32_t ret = unpacker.ReadUint32(devId) ? HDF_SUCCESS : HDF_FAILURE; 324 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 325 326 ret = unpacker.ReadUint32(layerId) ? HDF_SUCCESS : HDF_FAILURE; 327 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 328 329 ret = unpacker.ReadUint32(vectStrSize) ? HDF_SUCCESS : HDF_FAILURE; 330 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 331 332 for (uint32_t i = 0; i < vectStrSize; i++) { 333 int32_t tmpChar; 334 ret = unpacker.ReadInt32(tmpChar) ? HDF_SUCCESS : HDF_FAILURE; 335 if (ret != HDF_SUCCESS) { 336 break; 337 } 338 key.push_back(static_cast<char>(tmpChar)); 339 } 340 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 341 342 ret = unpacker.ReadUint32(vectSize) ? HDF_SUCCESS : HDF_FAILURE; 343 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 344 345 for (uint32_t i = 0; i < vectSize; i++) { 346 uint8_t tmpValue; 347 ret = unpacker.ReadUint8(tmpValue) ? HDF_SUCCESS : HDF_FAILURE; 348 if (ret != HDF_SUCCESS) { 349 break; 350 } 351 value.push_back(static_cast<int8_t>(tmpValue)); 352 } 353 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 354 355 HDF_LOGD("OnSetLayerPerFrameParam %{public}s, %{public}d, %{public}d", 356 key.c_str(), devId, layerId); 357 358 if (impl_ != nullptr && impl_->SetLayerPerFrameParameter != nullptr) { 359 ret = impl_->SetLayerPerFrameParameter(devId, layerId, key, value); 360 } 361 362 if (ret != HDF_SUCCESS && ret != DISPLAY_NOT_SUPPORT && ret != HDF_ERR_NOT_SUPPORT) { 363 HDF_LOGE("OnSetLayerPerFrameParam %{public}s, %{public}d, %{public}d, %{public}d", 364 key.c_str(), devId, layerId, ret); 365 } 366 UNPACKER_EXIT: 367 if (ret != HDF_SUCCESS) { 368 errMaps_.emplace(REQUEST_CMD_SET_LAYER_PERFRAME_PARAM, ret); 369 } 370 return ret; 371 } 372 OnSetDisplayPerFrameParam(CommandDataUnpacker & unpacker)373 int32_t OnSetDisplayPerFrameParam(CommandDataUnpacker& unpacker) 374 { 375 DISPLAY_TRACE; 376 uint32_t devId = 0; 377 std::string key; 378 std::vector<int8_t> value; 379 uint32_t vectSize = 0; 380 uint32_t vectStrSize = 0; 381 382 int32_t ret = unpacker.ReadUint32(devId) ? HDF_SUCCESS : HDF_FAILURE; 383 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 384 385 ret = unpacker.ReadUint32(vectStrSize) ? HDF_SUCCESS : HDF_FAILURE; 386 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 387 388 for (uint32_t i = 0; i < vectStrSize; i++) { 389 int32_t tmpChar; 390 ret = unpacker.ReadInt32(tmpChar) ? HDF_SUCCESS : HDF_FAILURE; 391 if (ret != HDF_SUCCESS) { 392 break; 393 } 394 key.push_back(static_cast<char>(tmpChar)); 395 } 396 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 397 398 ret = unpacker.ReadUint32(vectSize) ? HDF_SUCCESS : HDF_FAILURE; 399 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 400 401 for (uint32_t i = 0; i < vectSize; i++) { 402 uint8_t tmpValue; 403 ret = unpacker.ReadUint8(tmpValue) ? HDF_SUCCESS : HDF_FAILURE; 404 if (ret != HDF_SUCCESS) { 405 break; 406 } 407 value.push_back(static_cast<int8_t>(tmpValue)); 408 } 409 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 410 411 HDF_LOGD("OnSetDisplayPerFrameParam %{public}s, %{public}d", 412 key.c_str(), devId); 413 414 if (impl_ != nullptr && impl_->SetDisplayPerFrameParameter != nullptr) { 415 ret = impl_->SetDisplayPerFrameParameter(devId, key, value); 416 } 417 418 if (ret != HDF_SUCCESS && ret != DISPLAY_NOT_SUPPORT && ret != HDF_ERR_NOT_SUPPORT) { 419 HDF_LOGE("OnSetDisplayPerFrameParam %{public}s, %{public}d, %{public}d", 420 key.c_str(), devId, ret); 421 } 422 UNPACKER_EXIT: 423 if (ret != HDF_SUCCESS) { 424 errMaps_.emplace(REQUEST_CMD_SET_DISPLAY_PERFRAME_PARAM, ret); 425 } 426 return ret; 427 } 428 429 private: 430 using BaseType1_1 = V1_1::DisplayCmdResponser<Transfer, VdiImpl>; 431 using BaseType1_1::replyPacker_; 432 using BaseType1_1::cacheMgr_; 433 using BaseType1_1::impl_; 434 using BaseType1_1::replyCommandCnt_; 435 using BaseType1_1::errMaps_; 436 using BaseType1_1::request_; 437 using BaseType1_1::reply_; 438 using BaseType1_1::PeriodDataReset; 439 using BaseType1_1::OnPrepareDisplayLayers; 440 using BaseType1_1::OnSetDisplayClientBuffer; 441 using BaseType1_1::OnSetDisplayClientDamage; 442 using BaseType1_1::OnCommit; 443 using BaseType1_1::OnSetLayerAlpha; 444 using BaseType1_1::OnSetLayerRegion; 445 using BaseType1_1::OnSetLayerCrop; 446 using BaseType1_1::OnSetLayerZorder; 447 using BaseType1_1::OnSetLayerPreMulti; 448 using BaseType1_1::OnSetLayerTransformMode; 449 using BaseType1_1::OnSetLayerDirtyRegion; 450 using BaseType1_1::OnSetLayerVisibleRegion; 451 using BaseType1_1::OnSetLayerBuffer; 452 using BaseType1_1::OnSetLayerCompositionType; 453 using BaseType1_1::OnSetLayerBlendType; 454 using BaseType1_1::OnSetLayerMaskInfo; 455 using BaseType1_1::OnRequestEnd; 456 using BaseType1_1::OnSetLayerColor; 457 using BaseType1_1::CmdRequestDataRead; 458 using BaseType1_1::CmdRequestDataWrite; 459 using BaseType1_1::requestMutex_; 460 using BaseType1_1::replyMutex_; 461 }; 462 463 using HdiDisplayCmdResponser = DisplayCmdResponser<SharedMemQueue<int32_t>, DisplayComposerVdiAdapter>; 464 465 } // namespace V1_2 466 } // namespace Composer 467 } // namespace Display 468 } // namespace HDI 469 } // namespace OHOS 470 #endif // OHOS_HDI_DISPLAY_V1_2_DISPLAY_CMD_REQUESTER_H