1#include <base/logging.h> 2#include <gtest/gtest.h> 3#include <poll.h> 4 5#include <android/hardware_buffer.h> 6 7#include <algorithm> 8#include <set> 9#include <thread> 10#include <vector> 11 12#include <dvr/dvr_deleter.h> 13#include <dvr/dvr_display_manager.h> 14#include <dvr/dvr_surface.h> 15 16#include <pdx/status.h> 17 18using android::pdx::ErrorStatus; 19using android::pdx::Status; 20 21namespace android { 22namespace dvr { 23 24namespace { 25 26DvrSurfaceAttribute GetAttribute(DvrSurfaceAttributeKey key, bool value) { 27 DvrSurfaceAttribute attribute; 28 attribute.key = key; 29 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL; 30 attribute.value.bool_value = value; 31 return attribute; 32} 33 34DvrSurfaceAttribute GetAttribute(DvrSurfaceAttributeKey key, int32_t value) { 35 DvrSurfaceAttribute attribute; 36 attribute.key = key; 37 attribute.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32; 38 attribute.value.bool_value = value; 39 return attribute; 40} 41 42Status<UniqueDvrSurface> CreateApplicationSurface(bool visible = false, 43 int32_t z_order = 0) { 44 DvrSurface* surface = nullptr; 45 DvrSurfaceAttribute attributes[] = { 46 GetAttribute(DVR_SURFACE_ATTRIBUTE_Z_ORDER, z_order), 47 GetAttribute(DVR_SURFACE_ATTRIBUTE_VISIBLE, visible)}; 48 49 const int ret = dvrSurfaceCreate( 50 attributes, std::extent<decltype(attributes)>::value, &surface); 51 if (ret < 0) 52 return ErrorStatus(-ret); 53 else 54 return {UniqueDvrSurface(surface)}; 55} 56 57Status<UniqueDvrWriteBufferQueue> CreateSurfaceQueue( 58 const UniqueDvrSurface& surface, uint32_t width, uint32_t height, 59 uint32_t format, uint32_t layer_count, uint64_t usage, size_t capacity) { 60 DvrWriteBufferQueue* queue; 61 const int ret = 62 dvrSurfaceCreateWriteBufferQueue(surface.get(), width, height, format, 63 layer_count, usage, capacity, &queue); 64 if (ret < 0) 65 return ErrorStatus(-ret); 66 else 67 return {UniqueDvrWriteBufferQueue(queue)}; 68} 69 70class TestDisplayManager { 71 public: 72 TestDisplayManager(UniqueDvrDisplayManager display_manager, 73 UniqueDvrSurfaceState surface_state) 74 : display_manager_(std::move(display_manager)), 75 surface_state_(std::move(surface_state)) { 76 const int fd = dvrDisplayManagerGetEventFd(display_manager_.get()); 77 LOG_IF(INFO, fd < 0) << "Failed to get event fd: " << strerror(-fd); 78 display_manager_event_fd_ = fd; 79 } 80 81 Status<UniqueDvrReadBufferQueue> GetReadBufferQueue(int surface_id, 82 int queue_id) { 83 DvrReadBufferQueue* queue; 84 const int ret = dvrDisplayManagerGetReadBufferQueue( 85 display_manager_.get(), surface_id, queue_id, &queue); 86 if (ret < 0) 87 return ErrorStatus(-ret); 88 else 89 return {UniqueDvrReadBufferQueue(queue)}; 90 } 91 92 Status<void> UpdateSurfaceState() { 93 const int ret = dvrDisplayManagerGetSurfaceState(display_manager_.get(), 94 surface_state_.get()); 95 if (ret < 0) 96 return ErrorStatus(-ret); 97 else 98 return {}; 99 } 100 101 Status<void> WaitForUpdate() { 102 if (display_manager_event_fd_ < 0) 103 return ErrorStatus(-display_manager_event_fd_); 104 105 const int kTimeoutMs = 10000; // 10s 106 pollfd pfd = {display_manager_event_fd_, POLLIN, 0}; 107 const int count = poll(&pfd, 1, kTimeoutMs); 108 if (count < 0) 109 return ErrorStatus(errno); 110 else if (count == 0) 111 return ErrorStatus(ETIMEDOUT); 112 113 int events; 114 const int ret = dvrDisplayManagerTranslateEpollEventMask( 115 display_manager_.get(), pfd.revents, &events); 116 if (ret < 0) 117 return ErrorStatus(-ret); 118 else if (events & POLLIN) 119 return UpdateSurfaceState(); 120 else 121 return ErrorStatus(EPROTO); 122 } 123 124 Status<size_t> GetSurfaceCount() { 125 size_t count = 0; 126 const int ret = 127 dvrSurfaceStateGetSurfaceCount(surface_state_.get(), &count); 128 if (ret < 0) 129 return ErrorStatus(-ret); 130 else 131 return {count}; 132 } 133 134 Status<DvrSurfaceUpdateFlags> GetUpdateFlags(size_t surface_index) { 135 DvrSurfaceUpdateFlags update_flags; 136 const int ret = dvrSurfaceStateGetUpdateFlags(surface_state_.get(), 137 surface_index, &update_flags); 138 if (ret < 0) 139 return ErrorStatus(-ret); 140 else 141 return {update_flags}; 142 } 143 144 Status<int> GetSurfaceId(size_t surface_index) { 145 int surface_id; 146 const int ret = dvrSurfaceStateGetSurfaceId(surface_state_.get(), 147 surface_index, &surface_id); 148 if (ret < 0) 149 return ErrorStatus(-ret); 150 else 151 return {surface_id}; 152 } 153 154 Status<int> GetProcessId(size_t surface_index) { 155 int process_id; 156 const int ret = dvrSurfaceStateGetProcessId(surface_state_.get(), 157 surface_index, &process_id); 158 if (ret < 0) 159 return ErrorStatus(-ret); 160 else 161 return {process_id}; 162 } 163 164 Status<std::vector<DvrSurfaceAttribute>> GetAttributes(size_t surface_index) { 165 std::vector<DvrSurfaceAttribute> attributes; 166 size_t count = 0; 167 const int ret = dvrSurfaceStateGetAttributeCount(surface_state_.get(), 168 surface_index, &count); 169 if (ret < 0) 170 return ErrorStatus(-ret); 171 172 attributes.resize(count); 173 const ssize_t return_count = dvrSurfaceStateGetAttributes( 174 surface_state_.get(), surface_index, attributes.data(), count); 175 if (return_count < 0) 176 return ErrorStatus(-return_count); 177 178 attributes.resize(return_count); 179 return {std::move(attributes)}; 180 } 181 182 Status<std::vector<int>> GetQueueIds(size_t surface_index) { 183 std::vector<int> queue_ids; 184 size_t count = 0; 185 const int ret = dvrSurfaceStateGetQueueCount(surface_state_.get(), 186 surface_index, &count); 187 if (ret < 0) 188 return ErrorStatus(-ret); 189 190 if (count > 0) { 191 queue_ids.resize(count); 192 const ssize_t return_count = dvrSurfaceStateGetQueueIds( 193 surface_state_.get(), surface_index, queue_ids.data(), count); 194 if (return_count < 0) 195 return ErrorStatus(-return_count); 196 197 queue_ids.resize(return_count); 198 } 199 200 return {std::move(queue_ids)}; 201 } 202 203 private: 204 UniqueDvrDisplayManager display_manager_; 205 UniqueDvrSurfaceState surface_state_; 206 207 // Owned by object in display_manager_, do not explicitly close. 208 int display_manager_event_fd_; 209 210 TestDisplayManager(const TestDisplayManager&) = delete; 211 void operator=(const TestDisplayManager&) = delete; 212}; 213 214class DvrDisplayManagerTest : public ::testing::Test { 215 protected: 216 void SetUp() override { 217 int ret; 218 DvrDisplayManager* display_manager; 219 DvrSurfaceState* surface_state; 220 221 ret = dvrDisplayManagerCreate(&display_manager); 222 ASSERT_EQ(0, ret) << "Failed to create display manager client"; 223 ASSERT_NE(nullptr, display_manager); 224 225 ret = dvrSurfaceStateCreate(&surface_state); 226 ASSERT_EQ(0, ret) << "Failed to create surface state object"; 227 ASSERT_NE(nullptr, surface_state); 228 229 manager_.reset( 230 new TestDisplayManager(UniqueDvrDisplayManager(display_manager), 231 UniqueDvrSurfaceState(surface_state))); 232 } 233 void TearDown() override {} 234 235 std::unique_ptr<TestDisplayManager> manager_; 236}; 237 238// TODO(eieio): Consider moving these somewhere more central because they are 239// broadly useful. 240 241template <typename T> 242testing::AssertionResult StatusOk(const char* status_expression, 243 const Status<T>& status) { 244 if (!status.ok()) { 245 return testing::AssertionFailure() 246 << "(" << status_expression 247 << ") expected to indicate success but actually contains error (" 248 << status.error() << ")"; 249 } else { 250 return testing::AssertionSuccess(); 251 } 252} 253 254template <typename T> 255testing::AssertionResult StatusError(const char* status_expression, 256 const Status<T>& status) { 257 if (status.ok()) { 258 return testing::AssertionFailure() 259 << "(" << status_expression 260 << ") expected to indicate error but instead indicates success."; 261 } else { 262 return testing::AssertionSuccess(); 263 } 264} 265 266template <typename T> 267testing::AssertionResult StatusHasError(const char* status_expression, 268 const char* /*error_code_expression*/, 269 const Status<T>& status, 270 int error_code) { 271 if (status.ok()) { 272 return StatusError(status_expression, status); 273 } else if (status.error() != error_code) { 274 return testing::AssertionFailure() 275 << "(" << status_expression << ") expected to indicate error (" 276 << error_code << ") but actually indicates error (" << status.error() 277 << ")"; 278 } else { 279 return testing::AssertionSuccess(); 280 } 281} 282 283template <typename T, typename U> 284testing::AssertionResult StatusHasValue(const char* status_expression, 285 const char* /*value_expression*/, 286 const Status<T>& status, 287 const U& value) { 288 if (!status.ok()) { 289 return StatusOk(status_expression, status); 290 } else if (status.get() != value) { 291 return testing::AssertionFailure() 292 << "(" << status_expression << ") expected to contain value (" 293 << testing::PrintToString(value) << ") but actually contains value (" 294 << testing::PrintToString(status.get()) << ")"; 295 } else { 296 return testing::AssertionSuccess(); 297 } 298} 299 300template <typename T, typename Op> 301testing::AssertionResult StatusPred(const char* status_expression, 302 const char* pred_expression, 303 const Status<T>& status, Op pred) { 304 if (!status.ok()) { 305 return StatusOk(status_expression, status); 306 } else if (!pred(status.get())) { 307 return testing::AssertionFailure() 308 << status_expression << " value (" 309 << testing::PrintToString(status.get()) 310 << ") failed to pass predicate " << pred_expression; 311 } else { 312 return testing::AssertionSuccess(); 313 } 314} 315 316#define ASSERT_STATUS_OK(status) ASSERT_PRED_FORMAT1(StatusOk, status) 317#define ASSERT_STATUS_ERROR(status) ASSERT_PRED_FORMAT1(StatusError, status) 318 319#define ASSERT_STATUS_ERROR_VALUE(value, status) \ 320 ASSERT_PRED_FORMAT2(StatusHasError, status, value) 321 322#define ASSERT_STATUS_EQ(value, status) \ 323 ASSERT_PRED_FORMAT2(StatusHasValue, status, value) 324 325#define EXPECT_STATUS_OK(status) EXPECT_PRED_FORMAT1(StatusOk, status) 326#define EXPECT_STATUS_ERROR(status) EXPECT_PRED_FORMAT1(StatusError, status) 327 328#define EXPECT_STATUS_ERROR_VALUE(value, status) \ 329 EXPECT_PRED_FORMAT2(StatusHasError, status, value) 330 331#define EXPECT_STATUS_EQ(value, status) \ 332 EXPECT_PRED_FORMAT2(StatusHasValue, status, value) 333 334#define EXPECT_STATUS_PRED(pred, status) \ 335 EXPECT_PRED_FORMAT2(StatusPred, status, pred) 336 337#if 0 338// Verify utility predicate/macro functionality. This section is commented out 339// because it is designed to fail in some cases to validate the helpers. 340TEST_F(DvrDisplayManagerTest, ExpectVoid) { 341 Status<void> status_error{ErrorStatus{EINVAL}}; 342 Status<void> status_ok{}; 343 344 EXPECT_STATUS_ERROR(status_error); 345 EXPECT_STATUS_ERROR(status_ok); 346 EXPECT_STATUS_OK(status_error); 347 EXPECT_STATUS_OK(status_ok); 348 349 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_error); 350 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_error); 351 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_ok); 352 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_ok); 353} 354 355TEST_F(DvrDisplayManagerTest, ExpectInt) { 356 Status<int> status_error{ErrorStatus{EINVAL}}; 357 Status<int> status_ok{10}; 358 359 EXPECT_STATUS_ERROR(status_error); 360 EXPECT_STATUS_ERROR(status_ok); 361 EXPECT_STATUS_OK(status_error); 362 EXPECT_STATUS_OK(status_ok); 363 364 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_error); 365 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_error); 366 EXPECT_STATUS_ERROR_VALUE(EINVAL, status_ok); 367 EXPECT_STATUS_ERROR_VALUE(ENOMEM, status_ok); 368 369 EXPECT_STATUS_EQ(10, status_error); 370 EXPECT_STATUS_EQ(20, status_error); 371 EXPECT_STATUS_EQ(10, status_ok); 372 EXPECT_STATUS_EQ(20, status_ok); 373 374 auto pred1 = [](const auto& value) { return value < 15; }; 375 auto pred2 = [](const auto& value) { return value > 5; }; 376 auto pred3 = [](const auto& value) { return value > 15; }; 377 auto pred4 = [](const auto& value) { return value < 5; }; 378 379 EXPECT_STATUS_PRED(pred1, status_error); 380 EXPECT_STATUS_PRED(pred2, status_error); 381 EXPECT_STATUS_PRED(pred3, status_error); 382 EXPECT_STATUS_PRED(pred4, status_error); 383 EXPECT_STATUS_PRED(pred1, status_ok); 384 EXPECT_STATUS_PRED(pred2, status_ok); 385 EXPECT_STATUS_PRED(pred3, status_ok); 386 EXPECT_STATUS_PRED(pred4, status_ok); 387} 388#endif 389 390TEST_F(DvrDisplayManagerTest, SurfaceCreateEvent) { 391 // Get surface state and verify there are no surfaces. 392 ASSERT_STATUS_OK(manager_->UpdateSurfaceState()); 393 ASSERT_STATUS_EQ(0u, manager_->GetSurfaceCount()); 394 395 // Get flags for invalid surface index. 396 EXPECT_STATUS_ERROR_VALUE(EINVAL, manager_->GetUpdateFlags(0)); 397 398 // Create an application surface. 399 auto surface_status = CreateApplicationSurface(); 400 ASSERT_STATUS_OK(surface_status); 401 UniqueDvrSurface surface = surface_status.take(); 402 ASSERT_NE(nullptr, surface.get()); 403 404 const int surface_id = dvrSurfaceGetId(surface.get()); 405 ASSERT_GE(surface_id, 0); 406 407 // Now there should be one new surface. 408 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 409 EXPECT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 410 411 // Verify the new surface flag is set. 412 auto check_flags = [](const auto& value) { 413 return value & DVR_SURFACE_UPDATE_FLAGS_NEW_SURFACE; 414 }; 415 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 416 417 // Verify the surface id matches. 418 EXPECT_STATUS_EQ(surface_id, manager_->GetSurfaceId(0)); 419 420 // Verify the owning process of the surface. 421 EXPECT_STATUS_EQ(getpid(), manager_->GetProcessId(0)); 422 423 surface.reset(); 424 425 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 426 EXPECT_STATUS_EQ(0u, manager_->GetSurfaceCount()); 427} 428 429TEST_F(DvrDisplayManagerTest, SurfaceAttributeEvent) { 430 // Get surface state and verify there are no surfaces. 431 ASSERT_STATUS_OK(manager_->UpdateSurfaceState()); 432 ASSERT_STATUS_EQ(0u, manager_->GetSurfaceCount()); 433 434 // Get attributes for an invalid surface index. 435 EXPECT_STATUS_ERROR_VALUE(EINVAL, manager_->GetAttributes(0)); 436 437 const bool kInitialVisibility = true; 438 const int32_t kInitialZOrder = 10; 439 auto surface_status = 440 CreateApplicationSurface(kInitialVisibility, kInitialZOrder); 441 ASSERT_STATUS_OK(surface_status); 442 auto surface = surface_status.take(); 443 ASSERT_NE(nullptr, surface.get()); 444 445 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 446 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 447 448 // Check the initial attribute values. 449 auto attribute_status = manager_->GetAttributes(0); 450 ASSERT_STATUS_OK(attribute_status); 451 auto attributes = attribute_status.take(); 452 EXPECT_GE(attributes.size(), 2u); 453 454 const std::set<int32_t> expected_keys = {DVR_SURFACE_ATTRIBUTE_Z_ORDER, 455 DVR_SURFACE_ATTRIBUTE_VISIBLE}; 456 457 // Collect all the keys in attributes that match the expected keys. 458 std::set<int32_t> actual_keys; 459 std::for_each(attributes.begin(), attributes.end(), 460 [&expected_keys, &actual_keys](const auto& attribute) { 461 if (expected_keys.find(attribute.key) != expected_keys.end()) 462 actual_keys.emplace(attribute.key); 463 }); 464 465 // If the sets match then attributes contained at least the expected keys, 466 // even if other keys were also present. 467 EXPECT_EQ(expected_keys, actual_keys); 468} 469 470TEST_F(DvrDisplayManagerTest, SurfaceQueueEvent) { 471 // Create an application surface. 472 auto surface_status = CreateApplicationSurface(); 473 ASSERT_STATUS_OK(surface_status); 474 UniqueDvrSurface surface = surface_status.take(); 475 ASSERT_NE(nullptr, surface.get()); 476 477 const int surface_id = dvrSurfaceGetId(surface.get()); 478 ASSERT_GE(surface_id, 0); 479 // Get surface state and verify there is one surface. 480 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 481 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 482 483 // Verify there are no queues for the surface recorded in the state snapshot. 484 EXPECT_STATUS_EQ(std::vector<int>{}, manager_->GetQueueIds(0)); 485 486 // Create a new queue in the surface. 487 auto write_queue_status = CreateSurfaceQueue( 488 surface, 320, 240, AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, 1, 489 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, 1); 490 ASSERT_STATUS_OK(write_queue_status); 491 UniqueDvrWriteBufferQueue write_queue = write_queue_status.take(); 492 ASSERT_NE(nullptr, write_queue.get()); 493 494 const int queue_id = dvrWriteBufferQueueGetId(write_queue.get()); 495 ASSERT_GE(queue_id, 0); 496 497 // Update surface state. 498 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 499 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 500 501 // Verify the buffers changed flag is set. 502 auto check_flags = [](const auto& value) { 503 return value & DVR_SURFACE_UPDATE_FLAGS_BUFFERS_CHANGED; 504 }; 505 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 506 507 auto queue_ids_status = manager_->GetQueueIds(0); 508 ASSERT_STATUS_OK(queue_ids_status); 509 510 auto queue_ids = queue_ids_status.take(); 511 ASSERT_EQ(1u, queue_ids.size()); 512 EXPECT_EQ(queue_id, queue_ids[0]); 513 514 auto read_queue_status = manager_->GetReadBufferQueue(surface_id, queue_id); 515 ASSERT_STATUS_OK(read_queue_status); 516 UniqueDvrReadBufferQueue read_queue = read_queue_status.take(); 517 ASSERT_NE(nullptr, read_queue.get()); 518 EXPECT_EQ(queue_id, dvrReadBufferQueueGetId(read_queue.get())); 519 520 write_queue.reset(); 521 522 // Verify that destroying the queue generates a surface update event. 523 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 524 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 525 526 // Verify that the buffers changed flag is set. 527 EXPECT_STATUS_PRED(check_flags, manager_->GetUpdateFlags(0)); 528 529 // Verify that the queue ids reflect the change. 530 queue_ids_status = manager_->GetQueueIds(0); 531 ASSERT_STATUS_OK(queue_ids_status); 532 533 queue_ids = queue_ids_status.take(); 534 ASSERT_EQ(0u, queue_ids.size()); 535} 536 537TEST_F(DvrDisplayManagerTest, MultiLayerBufferQueue) { 538 // Create an application surface. 539 auto surface_status = CreateApplicationSurface(); 540 ASSERT_STATUS_OK(surface_status); 541 UniqueDvrSurface surface = surface_status.take(); 542 ASSERT_NE(nullptr, surface.get()); 543 544 // Get surface state and verify there is one surface. 545 ASSERT_STATUS_OK(manager_->WaitForUpdate()); 546 ASSERT_STATUS_EQ(1u, manager_->GetSurfaceCount()); 547 548 // Create a new queue in the surface. 549 const uint32_t kLayerCount = 3; 550 auto write_queue_status = CreateSurfaceQueue( 551 surface, 320, 240, AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, kLayerCount, 552 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, 1); 553 ASSERT_STATUS_OK(write_queue_status); 554 UniqueDvrWriteBufferQueue write_queue = write_queue_status.take(); 555 ASSERT_NE(nullptr, write_queue.get()); 556 557 DvrWriteBuffer* buffer = nullptr; 558 dvrWriteBufferCreateEmpty(&buffer); 559 int fence_fd = -1; 560 int error = 561 dvrWriteBufferQueueDequeue(write_queue.get(), 1000, buffer, &fence_fd); 562 ASSERT_EQ(0, error); 563 564 AHardwareBuffer* hardware_buffer = nullptr; 565 error = dvrWriteBufferGetAHardwareBuffer(buffer, &hardware_buffer); 566 ASSERT_EQ(0, error); 567 568 AHardwareBuffer_Desc desc = {}; 569 AHardwareBuffer_describe(hardware_buffer, &desc); 570 ASSERT_EQ(kLayerCount, desc.layers); 571 572 AHardwareBuffer_release(hardware_buffer); 573 dvrWriteBufferDestroy(buffer); 574} 575 576} // namespace 577 578} // namespace dvr 579} // namespace android 580