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, cacheMgr 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 123 if (commitInfo.skipRet != HDF_SUCCESS) { 124 ReplyNotSkipInfo(devId, commitInfo); 125 } else { 126 // Write layers vector 127 vectSize = static_cast<uint32_t>(commitInfo.layers.size()); 128 DISPLAY_CHECK(replyPacker_.WriteUint32(vectSize) == false, 129 HDF_LOGE("%{public}s, write layers.size error", __func__)); 130 131 for (uint32_t i = 0; i < vectSize; i++) { 132 DISPLAY_CHECK(replyPacker_.WriteUint32(commitInfo.layers[i]) == false, 133 HDF_LOGE("%{public}s, write layers error", __func__)); 134 } 135 136 // Write fences vector 137 vectSize = static_cast<uint32_t>(commitInfo.fences.size()); 138 DISPLAY_CHECK(replyPacker_.WriteUint32(vectSize) == false, 139 HDF_LOGE("%{public}s, write fences.size error", __func__)); 140 141 for (uint32_t i = 0; i < vectSize; i++) { 142 ret = CmdUtils::FileDescriptorPack(commitInfo.fences[i], replyPacker_, outFds, false); 143 DISPLAY_CHECK(ret != HDF_SUCCESS, HDF_LOGE("%{public}s, write fences error", __func__)); 144 } 145 } 146 147 DISPLAY_CHK_CONDITION(ret, HDF_SUCCESS, CmdUtils::EndSection(replyPacker_), 148 HDF_LOGE("%{public}s, EndSection error", __func__)); 149 150 replyCommandCnt_++; 151 152 #ifndef DISPLAY_COMMUNITY 153 fdParcel.Move(); 154 #endif // DISPLAY_COMMUNITY 155 156 if (ret != HDF_SUCCESS) { 157 errMaps_.emplace(REQUEST_CMD_COMMIT_AND_GET_RELEASE_FENCE, ret); 158 } 159 } 160 CommitInfoDump(void)161 void CommitInfoDump(void) 162 { 163 #ifdef DISPLAY_COMSPOER_DEBUG_DUMP 164 const std::string SWITCH_ON = "on"; 165 const uint32_t DUMP_CACHE_SWITCH_LEN = 4; 166 char dumpSwitch[DUMP_CACHE_SWITCH_LEN] = {0}; 167 GetParameter("hdi.composer.dumpcache", "off", dumpSwitch, DUMP_CACHE_SWITCH_LEN); 168 169 if (SWITCH_ON.compare(dumpSwitch) == 0) { 170 cacheMgr_->Dump(); 171 } 172 #endif 173 } 174 OnCommitAndGetReleaseFence(CommandDataUnpacker & unpacker,std::vector<HdifdInfo> & outFds)175 void OnCommitAndGetReleaseFence(CommandDataUnpacker& unpacker, std::vector<HdifdInfo>& outFds) 176 { 177 DISPLAY_TRACE; 178 uint32_t devId = 0; 179 bool isSupportSkipValidate = false; 180 bool isValidated = false; 181 int32_t ret = HDF_SUCCESS; 182 CommitInfo commitInfo; 183 commitInfo.fence = -1; 184 commitInfo.skipRet = HDF_FAILURE; 185 commitInfo.needFlush = false; 186 187 CommitInfoDump(); 188 if (!unpacker.ReadUint32(devId)) { 189 HDF_LOGE("%{public}s, read devId error", __func__); 190 goto REPLY; 191 } 192 if (!unpacker.ReadBool(isSupportSkipValidate)) { 193 HDF_LOGE("%{public}s, read isSupportSkipValidate error", __func__); 194 goto REPLY; 195 } 196 197 if (!unpacker.ReadBool(isValidated)) { 198 HDF_LOGE("%{public}s, read isValidated error", __func__); 199 goto REPLY; 200 } 201 if (isSupportSkipValidate || isValidated) { 202 HdfTrace traceVdi("Commit", "HDI:DISP:HARDWARE"); 203 commitInfo.skipRet = impl_->Commit(devId, commitInfo.fence); 204 } 205 206 if (commitInfo.skipRet != HDF_SUCCESS && isValidated == false) { 207 { 208 HdfTrace traceVdi("PrepareDisplayLayers", "HDI:DISP:HARDWARE"); 209 ret = impl_->PrepareDisplayLayers(devId, commitInfo.needFlush); 210 } 211 if (ret == HDF_SUCCESS) { 212 HdfTrace traceVdi("GetDisplayCompChange", "HDI:DISP:HARDWARE"); 213 ret = impl_->GetDisplayCompChange(devId, commitInfo.compLayers, commitInfo.compTypes); 214 } 215 } else { 216 HdfTrace traceVdi("GetDisplayReleaseFence", "HDI:DISP:HARDWARE"); 217 if (impl_->GetDisplayReleaseFence(devId, commitInfo.layers, commitInfo.fences) != HDF_SUCCESS) { 218 HDF_LOGE("%{public}s, GetDisplayReleaseFence failed with ret = %{public}d", __func__, ret); 219 } 220 } 221 HDF_LOGD("skipRet:%{public}d,fence:%{public}d,needFlush:%{public}d, ssv:%{public}d, iv:%{public}d", 222 commitInfo.skipRet, commitInfo.fence, commitInfo.needFlush, isSupportSkipValidate, isValidated); 223 REPLY: 224 ReplyCommitAndGetReleaseFence(outFds, devId, commitInfo); 225 } 226 CmdRequest(uint32_t inEleCnt,const std::vector<HdifdInfo> & inFds,uint32_t & outEleCnt,std::vector<HdifdInfo> & outFds)227 int32_t CmdRequest(uint32_t inEleCnt, const std::vector<HdifdInfo>& inFds, 228 uint32_t& outEleCnt, std::vector<HdifdInfo>& outFds) 229 { 230 std::shared_ptr<char> requestData(new char[inEleCnt * CmdUtils::ELEMENT_SIZE], std::default_delete<char[]>()); 231 int32_t ret = HDF_SUCCESS; 232 { 233 std::lock_guard<std::mutex> lock(requestMutex_); 234 ret = request_->Read(reinterpret_cast<int32_t*>(requestData.get()), inEleCnt, 235 CmdUtils::TRANSFER_WAIT_TIME); 236 } 237 CommandDataUnpacker unpacker; 238 unpacker.Init(requestData.get(), inEleCnt << CmdUtils::MOVE_SIZE); 239 #ifdef DEBUG_DISPLAY_CMD_RAW_DATA 240 unpacker.Dump(); 241 #endif // DEBUG_DISPLAY_CMD_RAW_DATA 242 243 int32_t unpackCmd = -1; 244 bool retBool = unpacker.PackBegin(unpackCmd); 245 DISPLAY_CHK_RETURN(retBool == false, HDF_FAILURE, 246 HDF_LOGE("%{public}s: error: Check RequestBegin failed", __func__)); 247 DISPLAY_CHK_RETURN(unpackCmd != CONTROL_CMD_REQUEST_BEGIN, HDF_FAILURE, 248 HDF_LOGI("error: unpacker PackBegin cmd not match, cmd(%{public}d)=%{public}s.", unpackCmd, 249 CmdUtils::CommandToString(unpackCmd))); 250 251 DISPLAY_CHK_RETURN(PeriodDataReset() == HDF_FAILURE, HDF_FAILURE, 252 HDF_LOGE("%{public}s: error: PeriodDataReset failed", __func__)); 253 while (ret == HDF_SUCCESS && unpacker.NextSection()) { 254 DISPLAY_CHK_RETURN(unpacker.BeginSection(unpackCmd) == false, HDF_FAILURE, 255 HDF_LOGE("error: PackSection failed, unpackCmd=%{public}s.", 256 CmdUtils::CommandToString(unpackCmd))); 257 ret = ProcessRequestCmd(unpacker, unpackCmd, inFds, outFds); 258 } 259 260 DISPLAY_CHK_RETURN(ret != HDF_SUCCESS, ret, 261 HDF_LOGE("%{public}s: ProcessRequestCmd failed", __func__)); 262 /* pack request end commands */ 263 replyPacker_.PackEnd(CONTROL_CMD_REPLY_END); 264 265 #ifdef DEBUG_DISPLAY_CMD_RAW_DATA 266 /* just for debug */ 267 replyPacker_.Dump(); 268 HDF_LOGI("CmdReply command cnt=%{public}d", replyCommandCnt_); 269 #endif // DEBUG_DISPLAY_CMD_RAW_DATA 270 271 /* Write reply pack */ 272 outEleCnt = replyPacker_.ValidSize() >> CmdUtils::MOVE_SIZE; 273 ret = CmdRequestDataWrite(outEleCnt); 274 if (ret != HDF_SUCCESS) { 275 HDF_LOGE("Reply write failure, ret=%{public}d", ret); 276 outEleCnt = 0; 277 } 278 return ret; 279 } 280 OnSetDisplayConstraint(CommandDataUnpacker & unpacker)281 int32_t OnSetDisplayConstraint(CommandDataUnpacker& unpacker) 282 { 283 DISPLAY_TRACE; 284 uint32_t devId = 0; 285 uint64_t frameID = 0; 286 uint64_t ns = 0; 287 uint32_t type = 0; 288 289 int32_t ret = unpacker.ReadUint32(devId) ? HDF_SUCCESS : HDF_FAILURE; 290 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 291 292 ret = unpacker.ReadUint64(frameID) ? HDF_SUCCESS : HDF_FAILURE; 293 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 294 295 ret = unpacker.ReadUint64(ns) ? HDF_SUCCESS : HDF_FAILURE; 296 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 297 298 ret = unpacker.ReadUint32(type) ? HDF_SUCCESS : HDF_FAILURE; 299 DISPLAY_CHECK(ret != HDF_SUCCESS, goto EXIT); 300 301 if (impl_ != nullptr && impl_->SetDisplayConstraint != nullptr) { 302 ret = impl_->SetDisplayConstraint(devId, frameID, ns, type); 303 } 304 305 if (ret != HDF_SUCCESS && ret != DISPLAY_NOT_SUPPORT && ret != HDF_ERR_NOT_SUPPORT) { 306 HDF_LOGE("SetDisplayConstraint failed with ret = %{public}d", ret); 307 } 308 EXIT: 309 if (ret != HDF_SUCCESS) { 310 errMaps_.emplace(REQUEST_CMD_SET_DISPLAY_CONSTRAINT, ret); 311 } 312 return ret; 313 } 314 OnSetLayerPerFrameParam(CommandDataUnpacker & unpacker)315 int32_t OnSetLayerPerFrameParam(CommandDataUnpacker& unpacker) 316 { 317 DISPLAY_TRACE; 318 uint32_t devId = 0; 319 uint32_t layerId = 0; 320 std::string key; 321 std::vector<int8_t> value; 322 uint32_t vectSize = 0; 323 uint32_t vectStrSize = 0; 324 325 int32_t ret = unpacker.ReadUint32(devId) ? HDF_SUCCESS : HDF_FAILURE; 326 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 327 328 ret = unpacker.ReadUint32(layerId) ? HDF_SUCCESS : HDF_FAILURE; 329 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 330 331 ret = unpacker.ReadUint32(vectStrSize) ? HDF_SUCCESS : HDF_FAILURE; 332 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 333 334 for (uint32_t i = 0; i < vectStrSize; i++) { 335 int32_t tmpChar; 336 ret = unpacker.ReadInt32(tmpChar) ? HDF_SUCCESS : HDF_FAILURE; 337 if (ret != HDF_SUCCESS) { 338 break; 339 } 340 key.push_back(static_cast<char>(tmpChar)); 341 } 342 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 343 344 ret = unpacker.ReadUint32(vectSize) ? HDF_SUCCESS : HDF_FAILURE; 345 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 346 347 for (uint32_t i = 0; i < vectSize; i++) { 348 uint8_t tmpValue; 349 ret = unpacker.ReadUint8(tmpValue) ? HDF_SUCCESS : HDF_FAILURE; 350 if (ret != HDF_SUCCESS) { 351 break; 352 } 353 value.push_back(static_cast<int8_t>(tmpValue)); 354 } 355 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 356 357 HDF_LOGD("OnSetLayerPerFrameParam %{public}s, %{public}d, %{public}d", 358 key.c_str(), devId, layerId); 359 360 if (impl_ != nullptr && impl_->SetLayerPerFrameParameter != nullptr) { 361 ret = impl_->SetLayerPerFrameParameter(devId, layerId, key, value); 362 } 363 364 if (ret != HDF_SUCCESS && ret != DISPLAY_NOT_SUPPORT && ret != HDF_ERR_NOT_SUPPORT) { 365 HDF_LOGE("OnSetLayerPerFrameParam %{public}s, %{public}d, %{public}d, %{public}d", 366 key.c_str(), devId, layerId, ret); 367 } 368 UNPACKER_EXIT: 369 if (ret != HDF_SUCCESS) { 370 errMaps_.emplace(REQUEST_CMD_SET_LAYER_PERFRAME_PARAM, ret); 371 } 372 return ret; 373 } 374 OnSetDisplayPerFrameParam(CommandDataUnpacker & unpacker)375 int32_t OnSetDisplayPerFrameParam(CommandDataUnpacker& unpacker) 376 { 377 DISPLAY_TRACE; 378 uint32_t devId = 0; 379 std::string key; 380 std::vector<int8_t> value; 381 uint32_t vectSize = 0; 382 uint32_t vectStrSize = 0; 383 384 int32_t ret = unpacker.ReadUint32(devId) ? HDF_SUCCESS : HDF_FAILURE; 385 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 386 387 ret = unpacker.ReadUint32(vectStrSize) ? HDF_SUCCESS : HDF_FAILURE; 388 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 389 390 for (uint32_t i = 0; i < vectStrSize; i++) { 391 int32_t tmpChar; 392 ret = unpacker.ReadInt32(tmpChar) ? HDF_SUCCESS : HDF_FAILURE; 393 if (ret != HDF_SUCCESS) { 394 break; 395 } 396 key.push_back(static_cast<char>(tmpChar)); 397 } 398 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 399 400 ret = unpacker.ReadUint32(vectSize) ? HDF_SUCCESS : HDF_FAILURE; 401 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 402 403 for (uint32_t i = 0; i < vectSize; i++) { 404 uint8_t tmpValue; 405 ret = unpacker.ReadUint8(tmpValue) ? HDF_SUCCESS : HDF_FAILURE; 406 if (ret != HDF_SUCCESS) { 407 break; 408 } 409 value.push_back(static_cast<int8_t>(tmpValue)); 410 } 411 DISPLAY_CHECK(ret != HDF_SUCCESS, goto UNPACKER_EXIT); 412 413 HDF_LOGD("OnSetDisplayPerFrameParam %{public}s, %{public}d", 414 key.c_str(), devId); 415 416 if (impl_ != nullptr && impl_->SetDisplayPerFrameParameter != nullptr) { 417 ret = impl_->SetDisplayPerFrameParameter(devId, key, value); 418 } 419 420 if (ret != HDF_SUCCESS && ret != DISPLAY_NOT_SUPPORT && ret != HDF_ERR_NOT_SUPPORT) { 421 HDF_LOGE("OnSetDisplayPerFrameParam %{public}s, %{public}d, %{public}d", 422 key.c_str(), devId, ret); 423 } 424 UNPACKER_EXIT: 425 if (ret != HDF_SUCCESS) { 426 errMaps_.emplace(REQUEST_CMD_SET_DISPLAY_PERFRAME_PARAM, ret); 427 } 428 return ret; 429 } 430 431 private: 432 using BaseType1_1 = V1_1::DisplayCmdResponser<Transfer, VdiImpl>; 433 using BaseType1_1::replyPacker_; 434 using BaseType1_1::cacheMgr_; 435 using BaseType1_1::impl_; 436 using BaseType1_1::replyCommandCnt_; 437 using BaseType1_1::errMaps_; 438 using BaseType1_1::request_; 439 using BaseType1_1::reply_; 440 using BaseType1_1::PeriodDataReset; 441 using BaseType1_1::OnPrepareDisplayLayers; 442 using BaseType1_1::OnSetDisplayClientBuffer; 443 using BaseType1_1::OnSetDisplayClientDamage; 444 using BaseType1_1::OnCommit; 445 using BaseType1_1::OnSetLayerAlpha; 446 using BaseType1_1::OnSetLayerRegion; 447 using BaseType1_1::OnSetLayerCrop; 448 using BaseType1_1::OnSetLayerZorder; 449 using BaseType1_1::OnSetLayerPreMulti; 450 using BaseType1_1::OnSetLayerTransformMode; 451 using BaseType1_1::OnSetLayerDirtyRegion; 452 using BaseType1_1::OnSetLayerVisibleRegion; 453 using BaseType1_1::OnSetLayerBuffer; 454 using BaseType1_1::OnSetLayerCompositionType; 455 using BaseType1_1::OnSetLayerBlendType; 456 using BaseType1_1::OnSetLayerMaskInfo; 457 using BaseType1_1::OnRequestEnd; 458 using BaseType1_1::OnSetLayerColor; 459 using BaseType1_1::CmdRequestDataRead; 460 using BaseType1_1::CmdRequestDataWrite; 461 using BaseType1_1::requestMutex_; 462 using BaseType1_1::replyMutex_; 463 }; 464 465 using HdiDisplayCmdResponser = DisplayCmdResponser<SharedMemQueue<int32_t>, DisplayComposerVdiAdapter>; 466 467 } // namespace V1_2 468 } // namespace Composer 469 } // namespace Display 470 } // namespace HDI 471 } // namespace OHOS 472 #endif // OHOS_HDI_DISPLAY_V1_2_DISPLAY_CMD_REQUESTER_H