ash / system / notification_center / ash_notification_drag_controller.cc [blame]

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/system/notification_center/ash_notification_drag_controller.h"

#include "ash/root_window_controller.h"
#include "ash/shell.h"
#include "ash/system/notification_center/views/ash_notification_view.h"
#include "ash/system/notification_center/message_center_utils.h"
#include "ash/system/notification_center/notification_center_tray.h"
#include "ash/system/status_area_widget.h"
#include "ash/system/unified/unified_system_tray.h"
#include "base/metrics/histogram_functions.h"
#include "ui/aura/client/drag_drop_client.h"
#include "ui/base/dragdrop/drag_drop_types.h"
#include "ui/base/dragdrop/drop_target_event.h"
#include "ui/base/dragdrop/mojom/drag_drop_types.mojom-shared.h"
#include "ui/base/dragdrop/os_exchange_data.h"
#include "ui/base/dragdrop/os_exchange_data_provider.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/vector2d.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/public/cpp/notification.h"
#include "ui/views/view.h"

namespace ash {

AshNotificationDragController::AshNotificationDragController() = default;

AshNotificationDragController::~AshNotificationDragController() = default;

void AshNotificationDragController::OnDragStarted() {
  if (drag_in_progress_) {
    // A drag-and-drop session could start before an async drop finishes. In
    // this case, neither `OnDropCompleted()` nor `OnDragCancelled()` is called.
    // Therefore, clean up the active notification drag handling.
    CleanUp(DragEndState::kInterruptedByNewDrag);
  } else {
    drag_in_progress_ = true;
  }
}

void AshNotificationDragController::OnDragCancelled() {
  CleanUp(DragEndState::kCancelled);
}

void AshNotificationDragController::OnDropCompleted(
    ui::mojom::DragOperation drag_operation) {
  // Remove the dragged notification from the message center if drag-and-drop
  // ends with copy. `MessageCenter::RemoveNotification()` guarantees that only
  // unpinned notifications are removable to users.
  DragEndState state = DragEndState::kCompletedWithoutDrop;
  if (drag_operation == ui::mojom::DragOperation::kCopy) {
    message_center::MessageCenter::Get()->RemoveNotification(
        *dragged_notification_id_, /*by_user=*/true);
    state = DragEndState::kCompletedWithDrop;
  }

  CleanUp(state);
}

void AshNotificationDragController::WriteDragDataForView(
    views::View* sender,
    const gfx::Point& press_pt,
    ui::OSExchangeData* data) {
  // Sets the image to show during drag.
  // TODO(b/308814203): clean the static_cast checks by replacing
  // `AshNotificationView*` with a base class.
  if (!message_center_utils::IsAshNotificationView(sender)) {
    return;
  }

  AshNotificationView* notification_view =
      static_cast<AshNotificationView*>(sender);
  const std::optional<gfx::ImageSkia> drag_image =
      notification_view->GetDragImage();
  DCHECK(drag_image);

  // The drag point is at the top left corner, or top right corner under RTL.
  data->provider().SetDragImage(
      *drag_image, base::i18n::IsRTL()
                       ? gfx::Vector2d(drag_image->size().width(), /*y=*/0)
                       : gfx::Vector2d());

  notification_view->AttachDropData(data);
}

int AshNotificationDragController::GetDragOperationsForView(
    views::View* sender,
    const gfx::Point& p) {
  // TODO(b/308814203): clean the static_cast checks by replacing
  // `AshNotificationView*` with a base class.
  if (!message_center_utils::IsAshNotificationView(sender)) {
    return ui::DragDropTypes::DRAG_NONE;
  }

  const std::optional<gfx::Rect> drag_area =
      static_cast<AshNotificationView*>(sender)->GetDragAreaBounds();

  // Use `DRAG_COPY` if:
  // 1. `sender` is draggable; and
  // 2. `drag_area` contains `p`.
  if (drag_area && drag_area->Contains(p)) {
    return ui::DragDropTypes::DRAG_COPY;
  }

  return ui::DragDropTypes::DRAG_NONE;
}

bool AshNotificationDragController::CanStartDragForView(
    views::View* sender,
    const gfx::Point& press_pt,
    const gfx::Point& p) {
  // TODO(b/308814203): clean the static_cast checks by replacing
  // `AshNotificationView*` with a base class.
  if (!message_center_utils::IsAshNotificationView(sender)) {
    return false;
  }

  const AshNotificationView* const notification_view =
      static_cast<AshNotificationView*>(sender);
  const std::optional<gfx::Rect> drag_area =
      notification_view->GetDragAreaBounds();

  // Enable dragging `notification_view_` if:
  // 1. `notification_view` is backed by a notification; and
  // 2. `notification_view` is draggable; and
  // 3. `drag_area` contains the initial press point.
  const bool can_start_drag =
      (!!message_center::MessageCenter::Get()->FindNotificationById(
           notification_view->notification_id()) &&
       drag_area && drag_area->Contains(press_pt));

  // Assume that the drag on `sender` will start when `can_start_drag` is true.
  // TODO(crbug.com/40254274): in some edge cases, the view drag does not
  // start when `CanStartDragForView()` returns true. We should come up with a
  // general solution to observe drag start.
  if (can_start_drag) {
    // A drag-and-drop session could start before an async drop finishes. In
    // this case, neither `OnDropCompleted()` nor `OnDragCancelled()` is called.
    // Therefore, clean up the active notification drag handling.
    if (drag_in_progress_) {
      CleanUp(DragEndState::kInterruptedByNewDrag);
    }
  }

  return can_start_drag;
}

void AshNotificationDragController::OnWillStartDragForView(
    views::View* dragged_view) {
  // TODO(b/308814203): clean the static_cast checks by replacing
  // `AshNotificationView*` with a base class.
  if (!message_center_utils::IsAshNotificationView(dragged_view)) {
    return;
  }
  OnNotificationDragWillStart(static_cast<AshNotificationView*>(dragged_view));
}

void AshNotificationDragController::OnNotificationDragWillStart(
    AshNotificationView* dragged_view) {
  DCHECK(!drag_in_progress_);
  dragged_notification_id_ = dragged_view->notification_id();

  // The drag drop client in Ash, i.e. `DragDropController`, is a singleton.
  // Hence, always use the primary root window to access the drag drop client.
  drag_drop_client_observer_.Observe(
      aura::client::GetDragDropClient(Shell::GetPrimaryRootWindow()));

  message_center::MessageCenter* message_center_ptr =
      message_center::MessageCenter::Get();
  message_center::Notification* notification =
      message_center_ptr->FindNotificationById(*dragged_notification_id_);
  base::UmaHistogramEnumeration("Ash.NotificationView.ImageDrag.Start",
                                notification->notifier_id().catalog_name);

  // Hide the message center bubble if it is open.
  if (message_center_ptr->IsMessageCenterVisible()) {
    StatusAreaWidget* status_area_widget =
        RootWindowController::ForWindow(
            dragged_view->GetWidget()->GetNativeView())
            ->GetStatusAreaWidget();
    TrayBackgroundView* message_center_bubble = nullptr;
    message_center_bubble = status_area_widget->notification_center_tray();

    // We cannot destroy the message center bubble instantly. Otherwise, if
    // `dragged_view` is under gesture drag, the gesture state will be reset
    // when the bubble is closed. Therefore, post a task to close the bubble
    // asynchronously.
    DCHECK(message_center_bubble);
    base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(
                       [](const base::WeakPtr<TrayBackgroundView>& weak_ptr) {
                         if (weak_ptr) {
                           weak_ptr->CloseBubble();
                         }
                       },
                       message_center_bubble->GetWeakPtr()));

    return;
  }

  // Hide the dragged notification popup if any. Assume that the notification
  // popup only shows when the message center is hidden.
  // NOTE: if the dragged notification is a child of a notification group, hide
  // the group notification popup.
  message_center_ptr->MarkSinglePopupAsShown(
      notification->group_child()
          ? message_center_ptr->FindParentNotification(notification)->id()
          : *dragged_notification_id_,
      /*mark_notification_as_read=*/true);
}

void AshNotificationDragController::CleanUp(DragEndState state) {
  DCHECK(drag_in_progress_);
  drag_in_progress_ = false;
  dragged_notification_id_.reset();
  drag_drop_client_observer_.Reset();

  base::UmaHistogramEnumeration("Ash.NotificationView.ImageDrag.EndState",
                                state);
}

}  // namespace ash