media_item_manager_impl.cc 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/global_media_controls/media_item_manager_impl.h"
  5. #include <list>
  6. #include <memory>
  7. #include <string>
  8. #include "base/observer_list.h"
  9. #include "components/global_media_controls/public/media_dialog_delegate.h"
  10. #include "components/global_media_controls/public/media_item_manager_observer.h"
  11. #include "components/global_media_controls/public/media_item_producer.h"
  12. #include "components/media_message_center/media_notification_util.h"
  13. namespace global_media_controls {
  14. // static
  15. std::unique_ptr<MediaItemManager> MediaItemManager::Create() {
  16. return std::make_unique<MediaItemManagerImpl>();
  17. }
  18. MediaItemManagerImpl::MediaItemManagerImpl() = default;
  19. MediaItemManagerImpl::~MediaItemManagerImpl() = default;
  20. void MediaItemManagerImpl::AddObserver(MediaItemManagerObserver* observer) {
  21. observers_.AddObserver(observer);
  22. }
  23. void MediaItemManagerImpl::RemoveObserver(MediaItemManagerObserver* observer) {
  24. observers_.RemoveObserver(observer);
  25. }
  26. void MediaItemManagerImpl::AddItemProducer(MediaItemProducer* producer) {
  27. item_producers_.insert(producer);
  28. }
  29. void MediaItemManagerImpl::RemoveItemProducer(MediaItemProducer* producer) {
  30. item_producers_.erase(producer);
  31. }
  32. void MediaItemManagerImpl::ShowItem(const std::string& id) {
  33. // If new items come up while the dialog is open for a particular item, do not
  34. // show the new items.
  35. if (!HasOpenDialogForItem()) {
  36. ShowAndObserveItem(id);
  37. }
  38. }
  39. void MediaItemManagerImpl::HideItem(const std::string& id) {
  40. OnItemsChanged();
  41. if (!dialog_delegate_) {
  42. return;
  43. }
  44. dialog_delegate_->HideMediaItem(id);
  45. }
  46. void MediaItemManagerImpl::OnItemsChanged() {
  47. for (auto& observer : observers_)
  48. observer.OnItemListChanged();
  49. }
  50. void MediaItemManagerImpl::SetDialogDelegate(MediaDialogDelegate* delegate) {
  51. dialog_opened_for_single_item_ = false;
  52. SetDialogDelegateCommon(delegate);
  53. if (!dialog_delegate_)
  54. return;
  55. auto item_ids = GetActiveControllableItemIds();
  56. std::list<std::string> sorted_item_ids;
  57. for (const std::string& id : item_ids) {
  58. auto* item_producer = GetItemProducer(id);
  59. if (item_producer && item_producer->IsItemActivelyPlaying(id)) {
  60. sorted_item_ids.push_front(id);
  61. } else {
  62. sorted_item_ids.push_back(id);
  63. }
  64. }
  65. for (const std::string& id : sorted_item_ids) {
  66. base::WeakPtr<media_message_center::MediaNotificationItem> item =
  67. GetItem(id);
  68. MediaItemUI* item_ui = dialog_delegate_->ShowMediaItem(id, item);
  69. auto* item_producer = GetItemProducer(id);
  70. if (item_producer)
  71. item_producer->OnItemShown(id, item_ui);
  72. }
  73. media_message_center::RecordConcurrentNotificationCount(item_ids.size());
  74. for (auto* item_producer : item_producers_) {
  75. item_producer->OnDialogDisplayed();
  76. }
  77. }
  78. void MediaItemManagerImpl::SetDialogDelegateForId(MediaDialogDelegate* delegate,
  79. const std::string& id) {
  80. dialog_opened_for_single_item_ = true;
  81. SetDialogDelegateCommon(delegate);
  82. if (!dialog_delegate_)
  83. return;
  84. auto* producer = GetItemProducer(id);
  85. if (!producer)
  86. return;
  87. auto item = producer->GetMediaItem(id);
  88. if (!item)
  89. return;
  90. auto* item_ui = dialog_delegate_->ShowMediaItem(id, item);
  91. producer->OnItemShown(id, item_ui);
  92. }
  93. void MediaItemManagerImpl::FocusDialog() {
  94. if (dialog_delegate_)
  95. dialog_delegate_->Focus();
  96. }
  97. void MediaItemManagerImpl::HideDialog() {
  98. if (dialog_delegate_)
  99. dialog_delegate_->HideMediaDialog();
  100. }
  101. bool MediaItemManagerImpl::HasActiveItems() {
  102. return !GetActiveControllableItemIds().empty();
  103. }
  104. bool MediaItemManagerImpl::HasFrozenItems() {
  105. for (auto* item_producer : item_producers_) {
  106. if (item_producer->HasFrozenItems())
  107. return true;
  108. }
  109. return false;
  110. }
  111. bool MediaItemManagerImpl::HasOpenDialog() {
  112. return !!dialog_delegate_;
  113. }
  114. void MediaItemManagerImpl::ShowAndObserveItem(const std::string& id) {
  115. OnItemsChanged();
  116. if (!dialog_delegate_)
  117. return;
  118. auto item = GetItem(id);
  119. auto* item_ui = dialog_delegate_->ShowMediaItem(id, item);
  120. auto* producer = GetItemProducer(id);
  121. if (producer)
  122. producer->OnItemShown(id, item_ui);
  123. }
  124. std::set<std::string> MediaItemManagerImpl::GetActiveControllableItemIds()
  125. const {
  126. std::set<std::string> ids;
  127. for (auto* item_producer : item_producers_) {
  128. const std::set<std::string>& item_ids =
  129. item_producer->GetActiveControllableItemIds();
  130. ids.insert(item_ids.begin(), item_ids.end());
  131. }
  132. return ids;
  133. }
  134. base::WeakPtr<media_message_center::MediaNotificationItem>
  135. MediaItemManagerImpl::GetItem(const std::string& id) {
  136. for (auto* producer : item_producers_) {
  137. auto item = producer->GetMediaItem(id);
  138. if (item)
  139. return item;
  140. }
  141. return nullptr;
  142. }
  143. MediaItemProducer* MediaItemManagerImpl::GetItemProducer(
  144. const std::string& item_id) {
  145. for (auto* producer : item_producers_) {
  146. if (producer->GetMediaItem(item_id))
  147. return producer;
  148. }
  149. return nullptr;
  150. }
  151. void MediaItemManagerImpl::SetDialogDelegateCommon(
  152. MediaDialogDelegate* delegate) {
  153. DCHECK(!delegate || !dialog_delegate_);
  154. dialog_delegate_ = delegate;
  155. if (dialog_delegate_) {
  156. for (auto& observer : observers_)
  157. observer.OnMediaDialogOpened();
  158. } else {
  159. for (auto& observer : observers_)
  160. observer.OnMediaDialogClosed();
  161. }
  162. }
  163. bool MediaItemManagerImpl::HasOpenDialogForItem() {
  164. return HasOpenDialog() && dialog_opened_for_single_item_;
  165. }
  166. } // namespace global_media_controls