1 #include <android-base/properties.h> 2 #include <base/logging.h> 3 #include <gtest/gtest.h> 4 #include <log/log.h> 5 #include <poll.h> 6 7 #include <android/hardware_buffer.h> 8 9 #include <algorithm> 10 #include <array> 11 #include <set> 12 #include <thread> 13 #include <vector> 14 15 #include <dvr/dvr_configuration_data.h> 16 #include <dvr/dvr_deleter.h> 17 #include <dvr/dvr_display_manager.h> 18 #include <dvr/dvr_surface.h> 19 20 #include <pdx/status.h> 21 22 using android::pdx::ErrorStatus; 23 using android::pdx::Status; 24 25 namespace android { 26 namespace dvr { 27 28 namespace { 29 MakeAttribute(DvrSurfaceAttributeKey key,nullptr_t)30 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, nullptr_t) { 31 DvrSurfaceAttribute attribute; 32 attribute.key = key; 33 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_NONE; 34 return attribute; 35 } 36 MakeAttribute(DvrSurfaceAttributeKey key,int32_t value)37 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, int32_t value) { 38 DvrSurfaceAttribute attribute; 39 attribute.key = key; 40 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32; 41 attribute.value.int32_value = value; 42 return attribute; 43 } 44 MakeAttribute(DvrSurfaceAttributeKey key,int64_t value)45 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, int64_t value) { 46 DvrSurfaceAttribute attribute; 47 attribute.key = key; 48 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT64; 49 attribute.value.int64_value = value; 50 return attribute; 51 } 52 MakeAttribute(DvrSurfaceAttributeKey key,bool value)53 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, bool value) { 54 DvrSurfaceAttribute attribute; 55 attribute.key = key; 56 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL; 57 attribute.value.bool_value = value; 58 return attribute; 59 } 60 MakeAttribute(DvrSurfaceAttributeKey key,float value)61 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, float value) { 62 DvrSurfaceAttribute attribute; 63 attribute.key = key; 64 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT; 65 attribute.value.float_value = value; 66 return attribute; 67 } 68 MakeAttribute(DvrSurfaceAttributeKey key,const std::array<float,2> & value)69 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, 70 const std::array<float, 2>& value) { 71 DvrSurfaceAttribute attribute; 72 attribute.key = key; 73 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT2; 74 std::copy(value.begin(), value.end(), attribute.value.float2_value); 75 return attribute; 76 } 77 MakeAttribute(DvrSurfaceAttributeKey key,const std::array<float,3> & value)78 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, 79 const std::array<float, 3>& value) { 80 DvrSurfaceAttribute attribute; 81 attribute.key = key; 82 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT3; 83 std::copy(value.begin(), value.end(), attribute.value.float3_value); 84 return attribute; 85 } 86 MakeAttribute(DvrSurfaceAttributeKey key,const std::array<float,4> & value)87 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, 88 const std::array<float, 4>& value) { 89 DvrSurfaceAttribute attribute; 90 attribute.key = key; 91 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT4; 92 std::copy(value.begin(), value.end(), attribute.value.float4_value); 93 return attribute; 94 } 95 MakeAttribute(DvrSurfaceAttributeKey key,const std::array<float,8> & value)96 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, 97 const std::array<float, 8>& value) { 98 DvrSurfaceAttribute attribute; 99 attribute.key = key; 100 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT8; 101 std::copy(value.begin(), value.end(), attribute.value.float8_value); 102 return attribute; 103 } 104 MakeAttribute(DvrSurfaceAttributeKey key,const std::array<float,16> & value)105 DvrSurfaceAttribute MakeAttribute(DvrSurfaceAttributeKey key, 106 const std::array<float, 16>& value) { 107 DvrSurfaceAttribute attribute; 108 attribute.key = key; 109 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT16; 110 std::copy(value.begin(), value.end(), attribute.value.float16_value); 111 return attribute; 112 } 113 CreateApplicationSurface(bool visible=false,int32_t z_order=0)114 Status<UniqueDvrSurface> CreateApplicationSurface(bool visible = false, 115 int32_t z_order = 0) { 116 DvrSurface* surface = nullptr; 117 DvrSurfaceAttribute attributes[] = { 118 MakeAttribute(DVR_SURFACE_ATTRIBUTE_Z_ORDER, z_order), 119 MakeAttribute(DVR_SURFACE_ATTRIBUTE_VISIBLE, visible)}; 120 121 const int ret = dvrSurfaceCreate( 122 attributes, std::extent<decltype(attributes)>::value, &surface); 123 if (ret < 0) 124 return ErrorStatus(-ret); 125 else 126 return {UniqueDvrSurface(surface)}; 127 } 128 CreateSurfaceQueue(const UniqueDvrSurface & surface,uint32_t width,uint32_t height,uint32_t format,uint32_t layer_count,uint64_t usage,size_t capacity,size_t metadata_size)129 Status<UniqueDvrWriteBufferQueue> CreateSurfaceQueue( 130 const UniqueDvrSurface& surface, uint32_t width, uint32_t height, 131 uint32_t format, uint32_t layer_count, uint64_t usage, size_t capacity, 132 size_t metadata_size) { 133 DvrWriteBufferQueue* queue; 134 const int ret = dvrSurfaceCreateWriteBufferQueue( 135 surface.get(), width, height, format, layer_count, usage, capacity, 136 metadata_size, &queue); 137 if (ret < 0) 138 return ErrorStatus(-ret); 139 else 140 return {UniqueDvrWriteBufferQueue(queue)}; 141 } 142 143 class TestDisplayManager { 144 public: TestDisplayManager(UniqueDvrDisplayManager display_manager,UniqueDvrSurfaceState surface_state)145 TestDisplayManager(UniqueDvrDisplayManager display_manager, 146 UniqueDvrSurfaceState surface_state) 147 : display_manager_(std::move(display_manager)), 148 surface_state_(std::move(surface_state)) { 149 const int fd = dvrDisplayManagerGetEventFd(display_manager_.get()); 150 LOG_IF(INFO, fd < 0) << "Failed to get event fd: " << strerror(-fd); 151 display_manager_event_fd_ = fd; 152 } 153 GetReadBufferQueue(int surface_id,int queue_id)154 Status<UniqueDvrReadBufferQueue> GetReadBufferQueue(int surface_id, 155 int queue_id) { 156 DvrReadBufferQueue* queue; 157 const int ret = dvrDisplayManagerGetReadBufferQueue( 158 display_manager_.get(), surface_id, queue_id, &queue); 159 if (ret < 0) 160 return ErrorStatus(-ret); 161 else 162 return {UniqueDvrReadBufferQueue(queue)}; 163 } 164 UpdateSurfaceState()165 Status<void> UpdateSurfaceState() { 166 const int ret = dvrDisplayManagerGetSurfaceState(display_manager_.get(), 167 surface_state_.get()); 168 if (ret < 0) 169 return ErrorStatus(-ret); 170 else 171 return {}; 172 } 173 174 enum : int { kTimeoutMs = 10000 }; // 10s 175 WaitForUpdate(int timeout_ms=kTimeoutMs)176 Status<void> WaitForUpdate(int timeout_ms = kTimeoutMs) { 177 if (display_manager_event_fd_ < 0) 178 return ErrorStatus(-display_manager_event_fd_); 179 180 pollfd pfd = {display_manager_event_fd_, POLLIN, 0}; 181 const int count = poll(&pfd, 1, timeout_ms); 182 if (count < 0) 183 return ErrorStatus(errno); 184 else if (count == 0) 185 return ErrorStatus(ETIMEDOUT); 186 187 int events; 188 const int ret = dvrDisplayManagerTranslateEpollEventMask( 189 display_manager_.get(), pfd.revents, &events); 190 if (ret < 0) 191 return ErrorStatus(-ret); 192 else if (events & POLLIN) 193 return UpdateSurfaceState(); 194 else 195 return ErrorStatus(EPROTO); 196 } 197 GetSurfaceCount()198 Status<size_t> GetSurfaceCount() { 199 size_t count = 0; 200 const int ret = 201 dvrSurfaceStateGetSurfaceCount(surface_state_.get(), &count); 202 if (ret < 0) 203 return ErrorStatus(-ret); 204 else 205 return {count}; 206 } 207 GetUpdateFlags(size_t surface_index)208 Status<DvrSurfaceUpdateFlags> GetUpdateFlags(size_t surface_index) { 209 DvrSurfaceUpdateFlags update_flags; 210 const int ret = dvrSurfaceStateGetUpdateFlags(surface_state_.get(), 211 surface_index, &update_flags); 212 if (ret < 0) 213 return ErrorStatus(-ret); 214 else 215 return {update_flags}; 216 } 217 GetSurfaceId(size_t surface_index)218 Status<int> GetSurfaceId(size_t surface_index) { 219 int surface_id; 220 const int ret = dvrSurfaceStateGetSurfaceId(surface_state_.get(), 221 surface_index, &surface_id); 222 if (ret < 0) 223 return ErrorStatus(-ret); 224 else 225 return {surface_id}; 226 } 227 GetProcessId(size_t surface_index)228 Status<int> GetProcessId(size_t surface_index) { 229 int process_id; 230 const int ret = dvrSurfaceStateGetProcessId(surface_state_.get(), 231 surface_index, &process_id); 232 if (ret < 0) 233 return ErrorStatus(-ret); 234 else 235 return {process_id}; 236 } 237 GetAttributes(size_t surface_index)238 Status<std::vector<DvrSurfaceAttribute>> GetAttributes(size_t surface_index) { 239 std::vector<DvrSurfaceAttribute> attributes; 240 size_t count = 0; 241 const int ret = dvrSurfaceStateGetAttributeCount(surface_state_.get(), 242 surface_index, &count); 243 if (ret < 0) 244 return ErrorStatus(-ret); 245 246 attributes.resize(count); 247 const ssize_t return_count = dvrSurfaceStateGetAttributes( 248 surface_state_.get(), surface_index, attributes.data(), count); 249 if (return_count < 0) 250 return ErrorStatus(-return_count); 251 252 attributes.resize(return_count); 253 return {std::move(attributes)}; 254 } 255 GetQueueIds(size_t surface_index)256 Status<std::vector<int>> GetQueueIds(size_t surface_index) { 257 std::vector<int> queue_ids; 258 size_t count = 0; 259 const int ret = dvrSurfaceStateGetQueueCount(surface_state_.get(), 260 surface_index, &count); 261 if (ret < 0) 262 return ErrorStatus(-ret); 263 264 if (count > 0) { 265 queue_ids.resize(count); 266 const ssize_t return_count = dvrSurfaceStateGetQueueIds( 267 surface_state_.get(), surface_index, queue_ids.data(), count); 268 if (return_count < 0) 269 return ErrorStatus(-return_count); 270 271 queue_ids.resize(return_count); 272 } 273 274 return {std::move(queue_ids)}; 275 } 276 GetConfigData(int config_type)277 Status<std::vector<uint8_t>> GetConfigData(int config_type) { 278 uint8_t* data = nullptr; 279 size_t data_size = 0; 280 int error = dvrConfigurationDataGet(config_type, &data, &data_size); 281 if (error < 0) { 282 return ErrorStatus(-error); 283 } 284 285 if (!data || data_size == 0) { 286 return ErrorStatus(EINVAL); 287 } 288 std::vector<uint8_t> data_result(data, data + data_size); 289 dvrConfigurationDataDestroy(data); 290 std::string s(data, data + data_size); 291 return {std::move(data_result)}; 292 } 293 294 private: 295 UniqueDvrDisplayManager display_manager_; 296 UniqueDvrSurfaceState surface_state_; 297 298 // Owned by object in display_manager_, do not explicitly close. 299 int display_manager_event_fd_; 300 301 TestDisplayManager(const TestDisplayManager&) = delete; 302 void operator=(const TestDisplayManager&) = delete; 303 }; 304 305 class DvrDisplayManagerTest : public ::testing::Test { 306 protected: SetUp()307 void SetUp() override { 308 int ret; 309 DvrDisplayManager* display_manager; 310 DvrSurfaceState* surface_state; 311 312 ret = dvrDisplayManagerCreate(&display_manager); 313 ASSERT_EQ(0, ret) << "Failed to create display manager client"; 314 ASSERT_NE(nullptr, display_manager); 315 316 ret = dvrSurfaceStateCreate(&surface_state); 317 ASSERT_EQ(0, ret) << "Failed to create surface state object"; 318 ASSERT_NE(nullptr, surface_state); 319 320 manager_.reset( 321 new TestDisplayManager(UniqueDvrDisplayManager(display_manager), 322 UniqueDvrSurfaceState(surface_state))); 323 } TearDown()324 void TearDown() override {} 325 326 std::unique_ptr<TestDisplayManager> manager_; 327 }; 328 329 // TODO(eieio): Consider moving these somewhere more central because they are 330 // broadly useful. 331 332 template <typename T> StatusOk(const char * status_expression,const Status<T> & status)333 testing::AssertionResult StatusOk(const char* status_expression, 334 const Status<T>& status) { 335 if (!status.ok()) { 336 return testing::AssertionFailure() 337 << "(" << status_expression 338 << ") expected to indicate success but actually contains error (" 339 << status.error() << ")"; 340 } else { 341 return testing::AssertionSuccess(); 342 } 343 } 344 345 template <typename T> StatusError(const char * status_expression,const Status<T> & status)346 testing::AssertionResult StatusError(const char* status_expression, 347 const Status<T>& status) { 348 if (status.ok()) { 349 return testing::AssertionFailure() 350 << "(" << status_expression 351 << ") expected to indicate error but instead indicates success."; 352 } else { 353 return testing::AssertionSuccess(); 354 } 355 } 356 357 template <typename T> StatusHasError(const char * status_expression,const char *,const Status<T> & status,int error_code)358 testing::AssertionResult StatusHasError(const char* status_expression, 359 const char* /*error_code_expression*/, 360 const Status<T>& status, 361 int error_code) { 362 if (status.ok()) { 363 return StatusError(status_expression, status); 364 } else if (status.error() != error_code) { 365 return testing::AssertionFailure() 366 << "(" << status_expression << ") expected to indicate error (" 367 << error_code << ") but actually indicates error (" << status.error() 368 << ")"; 369 } else { 370 return testing::AssertionSuccess(); 371 } 372 } 373 374 template <typename T, typename U> StatusHasValue(const char * status_expression,const char *,const Status<T> & status,const U & value)375 testing::AssertionResult StatusHasValue(const char* status_expression, 376 const char* /*value_expression*/, 377 const Status<T>& status, 378 const U& value) { 379 if (!status.ok()) { 380 return StatusOk(status_expression, status); 381 } else if (status.get() != value) { 382 return testing::AssertionFailure() 383 << "(" << status_expression << ") expected to contain value (" 384 << testing::PrintToString(value) << ") but actually contains value (" 385 << testing::PrintToString(status.get()) << ")"; 386 } else { 387 return testing::AssertionSuccess(); 388 } 389 } 390 391 template <typename T, typename Op> StatusPred(const char * status_expression,const char * pred_expression,const Status<T> & status,Op pred)392 testing::AssertionResult StatusPred(const char* status_expression, 393 const char* pred_expression, 394 const Status<T>& status, Op pred) { 395 if (!status.ok()) { 396 return StatusOk(status_expression, status); 397 } else if (!pred(status.get())) { 398 return testing::AssertionFailure() 399 << status_expression << " value (" 400 << testing::PrintToString(status.get()) 401 << ") failed to pass predicate " << pred_expression; 402 } else { 403 return testing::AssertionSuccess(); 404 } 405 } 406 407 #define ASSERT_STATUS_OK(status) ASSERT_PRED_FORMAT1(StatusOk, status) 408 #define ASSERT_STATUS_ERROR(status) ASSERT_PRED_FORMAT1(StatusError, status) 409 410 #define ASSERT_STATUS_ERROR_VALUE(value, status) \ 411 ASSERT_PRED_FORMAT2(StatusHasError, status, value) 412 413 #define ASSERT_STATUS_EQ(value, status) \ 414 ASSERT_PRED_FORMAT2(StatusHasValue, status, value) 415 416 #define EXPECT_STATUS_OK(status) EXPECT_PRED_FORMAT1(StatusOk, status) 417 #define EXPECT_STATUS_ERROR(status) EXPECT_PRED_FORMAT1(StatusError, status) 418 419 #define EXPECT_STATUS_ERROR_VALUE(value, status) \ 420 EXPECT_PRED_FORMAT2(StatusHasError, status, value) 421 422 #define EXPECT_STATUS_EQ(value, status) \ 423 EXPECT_PRED_FORMAT2(StatusHasValue, status, value) 424 425 #define EXPECT_STATUS_PRED(pred, status) \ 426 EXPECT_PRED_FORMAT2(StatusPred, status, pred) 427 428 #if 0 429 // Verify utility predicate/macro functionality. This section is commented out 430 // because it is designed to fail in some cases to validate the helpers. 431 TEST_F(DvrDisplayManagerTest, ExpectVoid) { 432 Status<void> status_error{ErrorStatus{EINVAL}}; 433 Status<void> status_ok{}; 434 435 EXPECT_STATUS_ERROR(status_error); 436 EXPECT_STATUS_ERROR(status_ok); 437 EXPECT_STATUS_OK(status_error); 438 EXPECT_STATUS_OK(status_ok); 439 440 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_error); 441 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_error); 442 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_ok); 443 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_ok); 444 } 445 446 TEST_F(DvrDisplayManagerTest, ExpectInt) { 447 Status<int> status_error{ErrorStatus{EINVAL}}; 448 Status<int> status_ok{10}; 449 450 EXPECT_STATUS_ERROR(status_error); 451 EXPECT_STATUS_ERROR(status_ok); 452 EXPECT_STATUS_OK(status_error); 453 EXPECT_STATUS_OK(status_ok); 454 455 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_error); 456 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_error); 457 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_ok); 458 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_ok); 459 460 EXPECT_STATUS_EQ(10, status_error); 461 EXPECT_STATUS_EQ(20, status_error); 462 EXPECT_STATUS_EQ(10, status_ok); 463 EXPECT_STATUS_EQ(20, status_ok); 464 465 auto pred1 = [](const auto& value) { return value < 15; }; 466 auto pred2 = [](const auto& value) { return value > 5; }; 467 auto pred3 = [](const auto& value) { return value > 15; }; 468 auto pred4 = [](const auto& value) { return value < 5; }; 469 470 EXPECT_STATUS_PRED(pred1, status_error); 471 EXPECT_STATUS_PRED(pred2, status_error); 472 EXPECT_STATUS_PRED(pred3, status_error); 473 EXPECT_STATUS_PRED(pred4, status_error); 474 EXPECT_STATUS_PRED(pred1, status_ok); 475 EXPECT_STATUS_PRED(pred2, status_ok); 476 EXPECT_STATUS_PRED(pred3, status_ok); 477 EXPECT_STATUS_PRED(pred4, status_ok); 478 } 479 #endif 480 TEST_F(DvrDisplayManagerTest,SurfaceCreateEvent)481 TEST_F(DvrDisplayManagerTest, SurfaceCreateEvent) { 482 // Get surface state and verify there are no surfaces. 483 ASSERT_STATUS_OK(manager_->UpdateSurfaceState()); 484 ASSERT_STATUS_EQ(0u, manager_->GetSurfaceCount()); 485 486 // Get flags for invalid surface index. 487 EXPECT_STATUS_ERROR_VALUE(EINVAL, manager_->GetUpdateFlags(0)); 488 489 // Create an application surface. 490 auto surface_status = CreateApplicationSurface(); 491 ASSERT_STATUS_OK(surface_status); 492 UniqueDvrSurface surface = surface_status.take(); 493 ASSERT_NE(nullptr, surface.get()); 494 495 const int surface_id = dvrSurfaceGetId(surface.get()); 496 ASSERT_GE(surface_id, 0); 497 498 // Now there should be one new surface. 499 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 500 EXPECT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 501 502 // Verify the new surface flag is set. 503 auto check_flags = [](const auto& value) { 504 return value & DVR_SURFACE_UPDATE_FLAGS_NEW_SURFACE; 505 }; 506 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 507 508 // Verify the surface id matches. 509 EXPECT_STATUS_EQ(surface_id, manager_->GetSurfaceId(0)); 510 511 // Verify the owning process of the surface. 512 EXPECT_STATUS_EQ(getpid(), manager_->GetProcessId(0)); 513 514 surface.reset(); 515 516 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 517 EXPECT_STATUS_EQ(0u, manager_->GetSurfaceCount()); 518 } 519 TEST_F(DvrDisplayManagerTest,SurfaceAttributeEvent)520 TEST_F(DvrDisplayManagerTest, SurfaceAttributeEvent) { 521 // Get surface state and verify there are no surfaces. 522 ASSERT_STATUS_OK(manager_->UpdateSurfaceState()); 523 ASSERT_STATUS_EQ(0u, manager_->GetSurfaceCount()); 524 525 // Get attributes for an invalid surface index. 526 EXPECT_STATUS_ERROR_VALUE(EINVAL, manager_->GetAttributes(0)); 527 528 const bool kInitialVisibility = true; 529 const int32_t kInitialZOrder = 10; 530 auto surface_status = 531 CreateApplicationSurface(kInitialVisibility, kInitialZOrder); 532 ASSERT_STATUS_OK(surface_status); 533 auto surface = surface_status.take(); 534 ASSERT_NE(nullptr, surface.get()); 535 536 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 537 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 538 539 // Check the initial attribute values. 540 auto attribute_status = manager_->GetAttributes(0); 541 ASSERT_STATUS_OK(attribute_status); 542 auto attributes = attribute_status.take(); 543 EXPECT_GE(attributes.size(), 2u); 544 545 std::set<int32_t> actual_keys; 546 std::set<int32_t> expected_keys = {DVR_SURFACE_ATTRIBUTE_Z_ORDER, 547 DVR_SURFACE_ATTRIBUTE_VISIBLE}; 548 549 // Collect all the keys in attributes that match the expected keys. 550 auto compare_keys = [](const auto& attributes, const auto& expected_keys) { 551 std::set<int32_t> keys; 552 for (const auto& attribute : attributes) { 553 if (expected_keys.find(attribute.key) != expected_keys.end()) 554 keys.emplace(attribute.key); 555 } 556 return keys; 557 }; 558 559 // If the sets match then attributes contained at least the expected keys, 560 // even if other keys were also present. 561 actual_keys = compare_keys(attributes, expected_keys); 562 EXPECT_EQ(expected_keys, actual_keys); 563 564 std::vector<DvrSurfaceAttribute> attributes_to_set = { 565 MakeAttribute(DVR_SURFACE_ATTRIBUTE_Z_ORDER, 0)}; 566 567 // Test invalid args. 568 EXPECT_EQ(-EINVAL, dvrSurfaceSetAttributes(nullptr, attributes_to_set.data(), 569 attributes_to_set.size())); 570 EXPECT_EQ(-EINVAL, dvrSurfaceSetAttributes(surface.get(), nullptr, 571 attributes_to_set.size())); 572 573 // Test attribute change events. 574 ASSERT_EQ(0, dvrSurfaceSetAttributes(surface.get(), attributes_to_set.data(), 575 attributes_to_set.size())); 576 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 577 578 // Verify the attributes changed flag is set. 579 auto check_flags = [](const auto& value) { 580 return value & DVR_SURFACE_UPDATE_FLAGS_ATTRIBUTES_CHANGED; 581 }; 582 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 583 584 attribute_status = manager_->GetAttributes(0); 585 ASSERT_STATUS_OK(attribute_status); 586 attributes = attribute_status.take(); 587 EXPECT_GE(attributes.size(), 2u); 588 589 expected_keys = {DVR_SURFACE_ATTRIBUTE_Z_ORDER, 590 DVR_SURFACE_ATTRIBUTE_VISIBLE}; 591 592 actual_keys.clear(); 593 actual_keys = compare_keys(attributes, expected_keys); 594 EXPECT_EQ(expected_keys, actual_keys); 595 596 // Test setting and then deleting an attribute. 597 const DvrSurfaceAttributeKey kUserKey = 1; 598 attributes_to_set = {MakeAttribute(kUserKey, 1024)}; 599 600 ASSERT_EQ(0, dvrSurfaceSetAttributes(surface.get(), attributes_to_set.data(), 601 attributes_to_set.size())); 602 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 603 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 604 605 attribute_status = manager_->GetAttributes(0); 606 ASSERT_STATUS_OK(attribute_status); 607 attributes = attribute_status.take(); 608 EXPECT_GE(attributes.size(), 2u); 609 610 expected_keys = {DVR_SURFACE_ATTRIBUTE_Z_ORDER, DVR_SURFACE_ATTRIBUTE_VISIBLE, 611 kUserKey}; 612 613 actual_keys.clear(); 614 actual_keys = compare_keys(attributes, expected_keys); 615 EXPECT_EQ(expected_keys, actual_keys); 616 617 // Delete the attribute. 618 attributes_to_set = {MakeAttribute(kUserKey, nullptr)}; 619 620 ASSERT_EQ(0, dvrSurfaceSetAttributes(surface.get(), attributes_to_set.data(), 621 attributes_to_set.size())); 622 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 623 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 624 625 attribute_status = manager_->GetAttributes(0); 626 ASSERT_STATUS_OK(attribute_status); 627 attributes = attribute_status.take(); 628 EXPECT_GE(attributes.size(), 2u); 629 630 expected_keys = {DVR_SURFACE_ATTRIBUTE_Z_ORDER, DVR_SURFACE_ATTRIBUTE_VISIBLE, 631 kUserKey}; 632 633 actual_keys.clear(); 634 actual_keys = compare_keys(attributes, expected_keys); 635 EXPECT_NE(expected_keys, actual_keys); 636 637 // Test deleting a reserved attribute. 638 attributes_to_set = {MakeAttribute(DVR_SURFACE_ATTRIBUTE_VISIBLE, nullptr)}; 639 640 EXPECT_EQ(0, dvrSurfaceSetAttributes(surface.get(), attributes_to_set.data(), 641 attributes_to_set.size())); 642 643 // Failed attribute operations should not trigger update events. 644 const int kTimeoutMs = 100; // 0.1s 645 EXPECT_STATUS_ERROR_VALUE(ETIMEDOUT, manager_->WaitForUpdate(kTimeoutMs)); 646 647 attribute_status = manager_->GetAttributes(0); 648 ASSERT_STATUS_OK(attribute_status); 649 attributes = attribute_status.take(); 650 EXPECT_GE(attributes.size(), 2u); 651 652 expected_keys = {DVR_SURFACE_ATTRIBUTE_Z_ORDER, 653 DVR_SURFACE_ATTRIBUTE_VISIBLE}; 654 655 actual_keys.clear(); 656 actual_keys = compare_keys(attributes, expected_keys); 657 EXPECT_EQ(expected_keys, actual_keys); 658 } 659 TEST_F(DvrDisplayManagerTest,SurfaceAttributeTypes)660 TEST_F(DvrDisplayManagerTest, SurfaceAttributeTypes) { 661 // Create an application surface. 662 auto surface_status = CreateApplicationSurface(); 663 ASSERT_STATUS_OK(surface_status); 664 UniqueDvrSurface surface = surface_status.take(); 665 ASSERT_NE(nullptr, surface.get()); 666 667 enum : std::int32_t { 668 kInt32Key = 1, 669 kInt64Key, 670 kBoolKey, 671 kFloatKey, 672 kFloat2Key, 673 kFloat3Key, 674 kFloat4Key, 675 kFloat8Key, 676 kFloat16Key, 677 }; 678 679 const std::vector<DvrSurfaceAttribute> attributes_to_set = { 680 MakeAttribute(kInt32Key, int32_t{0}), 681 MakeAttribute(kInt64Key, int64_t{0}), 682 MakeAttribute(kBoolKey, false), 683 MakeAttribute(kFloatKey, 0.0f), 684 MakeAttribute(kFloat2Key, std::array<float, 2>{{1.0f, 2.0f}}), 685 MakeAttribute(kFloat3Key, std::array<float, 3>{{3.0f, 4.0f, 5.0f}}), 686 MakeAttribute(kFloat4Key, std::array<float, 4>{{6.0f, 7.0f, 8.0f, 9.0f}}), 687 MakeAttribute(kFloat8Key, 688 std::array<float, 8>{{10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 689 15.0f, 16.0f, 17.0f}}), 690 MakeAttribute(kFloat16Key, std::array<float, 16>{ 691 {18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 692 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 693 30.0f, 31.0f, 32.0f, 33.0f}})}; 694 695 EXPECT_EQ(0, dvrSurfaceSetAttributes(surface.get(), attributes_to_set.data(), 696 attributes_to_set.size())); 697 698 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 699 auto attribute_status = manager_->GetAttributes(0); 700 ASSERT_STATUS_OK(attribute_status); 701 auto attributes = attribute_status.take(); 702 EXPECT_GE(attributes.size(), attributes_to_set.size()); 703 704 auto HasAttribute = [](const auto& attributes, 705 DvrSurfaceAttributeKey key) -> bool { 706 for (const auto& attribute : attributes) { 707 if (attribute.key == key) 708 return true; 709 } 710 return false; 711 }; 712 auto AttributeType = 713 [](const auto& attributes, 714 DvrSurfaceAttributeKey key) -> DvrSurfaceAttributeType { 715 for (const auto& attribute : attributes) { 716 if (attribute.key == key) 717 return attribute.value.type; 718 } 719 return DVR_SURFACE_ATTRIBUTE_TYPE_NONE; 720 }; 721 722 ASSERT_TRUE(HasAttribute(attributes, kInt32Key)); 723 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_INT32, 724 AttributeType(attributes, kInt32Key)); 725 726 ASSERT_TRUE(HasAttribute(attributes, kInt64Key)); 727 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_INT64, 728 AttributeType(attributes, kInt64Key)); 729 730 ASSERT_TRUE(HasAttribute(attributes, kBoolKey)); 731 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_BOOL, 732 AttributeType(attributes, kBoolKey)); 733 734 ASSERT_TRUE(HasAttribute(attributes, kFloatKey)); 735 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT, 736 AttributeType(attributes, kFloatKey)); 737 738 ASSERT_TRUE(HasAttribute(attributes, kFloat2Key)); 739 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT2, 740 AttributeType(attributes, kFloat2Key)); 741 742 ASSERT_TRUE(HasAttribute(attributes, kFloat3Key)); 743 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT3, 744 AttributeType(attributes, kFloat3Key)); 745 746 ASSERT_TRUE(HasAttribute(attributes, kFloat4Key)); 747 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT4, 748 AttributeType(attributes, kFloat4Key)); 749 750 ASSERT_TRUE(HasAttribute(attributes, kFloat8Key)); 751 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT8, 752 AttributeType(attributes, kFloat8Key)); 753 754 ASSERT_TRUE(HasAttribute(attributes, kFloat16Key)); 755 EXPECT_EQ(DVR_SURFACE_ATTRIBUTE_TYPE_FLOAT16, 756 AttributeType(attributes, kFloat16Key)); 757 } 758 TEST_F(DvrDisplayManagerTest,SurfaceQueueEvent)759 TEST_F(DvrDisplayManagerTest, SurfaceQueueEvent) { 760 // Create an application surface. 761 auto surface_status = CreateApplicationSurface(); 762 ASSERT_STATUS_OK(surface_status); 763 UniqueDvrSurface surface = surface_status.take(); 764 ASSERT_NE(nullptr, surface.get()); 765 766 const int surface_id = dvrSurfaceGetId(surface.get()); 767 ASSERT_GE(surface_id, 0); 768 // Get surface state and verify there is one surface. 769 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 770 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 771 772 // Verify there are no queues for the surface recorded in the state 773 // snapshot. 774 EXPECT_STATUS_EQ(std::vector<int>{}, manager_->GetQueueIds(0)); 775 776 // Create a new queue in the surface. 777 auto write_queue_status = CreateSurfaceQueue( 778 surface, 320, 240, AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, 1, 779 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, 1, 0); 780 ASSERT_STATUS_OK(write_queue_status); 781 UniqueDvrWriteBufferQueue write_queue = write_queue_status.take(); 782 ASSERT_NE(nullptr, write_queue.get()); 783 784 const int queue_id = dvrWriteBufferQueueGetId(write_queue.get()); 785 ASSERT_GE(queue_id, 0); 786 787 // Update surface state. 788 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 789 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 790 791 // Verify the buffers changed flag is set. 792 auto check_flags = [](const auto& value) { 793 return value & DVR_SURFACE_UPDATE_FLAGS_BUFFERS_CHANGED; 794 }; 795 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 796 797 auto queue_ids_status = manager_->GetQueueIds(0); 798 ASSERT_STATUS_OK(queue_ids_status); 799 800 auto queue_ids = queue_ids_status.take(); 801 ASSERT_EQ(1u, queue_ids.size()); 802 EXPECT_EQ(queue_id, queue_ids[0]); 803 804 auto read_queue_status = manager_->GetReadBufferQueue(surface_id, queue_id); 805 ASSERT_STATUS_OK(read_queue_status); 806 UniqueDvrReadBufferQueue read_queue = read_queue_status.take(); 807 ASSERT_NE(nullptr, read_queue.get()); 808 EXPECT_EQ(queue_id, dvrReadBufferQueueGetId(read_queue.get())); 809 810 write_queue.reset(); 811 812 // Verify that destroying the queue generates a surface update event. 813 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 814 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 815 816 // Verify that the buffers changed flag is set. 817 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 818 819 // Verify that the queue ids reflect the change. 820 queue_ids_status = manager_->GetQueueIds(0); 821 ASSERT_STATUS_OK(queue_ids_status); 822 823 queue_ids = queue_ids_status.take(); 824 ASSERT_EQ(0u, queue_ids.size()); 825 } 826 TEST_F(DvrDisplayManagerTest,MultiLayerBufferQueue)827 TEST_F(DvrDisplayManagerTest, MultiLayerBufferQueue) { 828 // Create an application surface. 829 auto surface_status = CreateApplicationSurface(); 830 ASSERT_STATUS_OK(surface_status); 831 UniqueDvrSurface surface = surface_status.take(); 832 ASSERT_NE(nullptr, surface.get()); 833 834 // Get surface state and verify there is one surface. 835 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 836 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 837 838 // Create a new queue in the surface. 839 const uint32_t kLayerCount = 3; 840 auto write_queue_status = CreateSurfaceQueue( 841 surface, 320, 240, AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, kLayerCount, 842 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, 1, 0); 843 ASSERT_STATUS_OK(write_queue_status); 844 UniqueDvrWriteBufferQueue write_queue = write_queue_status.take(); 845 ASSERT_NE(nullptr, write_queue.get()); 846 847 DvrWriteBuffer* buffer = nullptr; 848 DvrNativeBufferMetadata metadata; 849 int fence_fd = -1; 850 int error = dvrWriteBufferQueueGainBuffer(write_queue.get(), /*timeout=*/1000, 851 &buffer, &metadata, &fence_fd); 852 ASSERT_EQ(0, error); 853 854 AHardwareBuffer* hardware_buffer = nullptr; 855 error = dvrWriteBufferGetAHardwareBuffer(buffer, &hardware_buffer); 856 ASSERT_EQ(0, error); 857 858 AHardwareBuffer_Desc desc = {}; 859 AHardwareBuffer_describe(hardware_buffer, &desc); 860 ASSERT_EQ(kLayerCount, desc.layers); 861 862 AHardwareBuffer_release(hardware_buffer); 863 dvrWriteBufferDestroy(buffer); 864 } 865 TEST_F(DvrDisplayManagerTest,ConfigurationData)866 TEST_F(DvrDisplayManagerTest, ConfigurationData) { 867 // TODO(hendrikw): Move this out of the display manager tests. 868 auto data1 = manager_->GetConfigData(-1); 869 ASSERT_STATUS_ERROR(data1); 870 871 const char kDvrLensMetricsProperty[] = "ro.dvr.lens_metrics"; 872 873 // This should be run on devices with and without built in metrics. 874 bool has_metric = !base::GetProperty(kDvrLensMetricsProperty, "").empty(); 875 auto data2 = manager_->GetConfigData(DVR_CONFIGURATION_DATA_LENS_METRICS); 876 if (has_metric) { 877 ASSERT_STATUS_OK(data2); 878 ASSERT_NE(0u, data2.get().size()); 879 } else { 880 ASSERT_STATUS_ERROR(data2); 881 } 882 } 883 884 } // namespace 885 886 } // namespace dvr 887 } // namespace android 888