arc: Support more types of notifications.

ui/arc/notification/arc_notification_item.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/arc/notification/arc_notification_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
+#include "components/arc/bitmap/bitmap_type_converters.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
+#include "ui/gfx/text_elider.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_types.h"
 #include "ui/message_center/notifier_settings.h"
 
 namespace arc {
 
 namespace {
 
 static const char kNotifierId[] = "ARC_NOTIFICATION";
 
 static const char kNotificationIdPrefix[] = "ARC_NOTIFICATION_";
 
 SkBitmap DecodeImage(const std::vector<uint8_t>& data) {
   DCHECK(base::WorkerPool::RunsTasksOnCurrentThread());
   DCHECK(!data.empty());  // empty string should be handled in caller.
 
   // We may decode an image in the browser process since it has been generated
   // in NotificationListerService in Android and should be safe.
   SkBitmap bitmap;
   gfx::PNGCodec::Decode(&data[0], data.size(), &bitmap);
   return bitmap;
 }
 
+SkBitmap CropImage(const SkBitmap& original_bitmap) {

[hidehiko, 2016/04/15 07:09:10]

Any function comments? How to be cropped?

[yoshiki, 2016/04/15 14:36:39]

Added comment.

+  DCHECK_NE(0, original_bitmap.width());
+  DCHECK_NE(0, original_bitmap.height());
+
+  const SkSize container_size = SkSize::Make(
+      message_center::kNotificationPreferredImageWidth,
+      message_center::kNotificationPreferredImageHeight);
+  const float container_aspect_ratio =
+      static_cast<float>(message_center::kNotificationPreferredImageWidth) /
+      message_center::kNotificationPreferredImageHeight;
+  const float image_aspect_ratio =
+      static_cast<float>(original_bitmap.width()) / original_bitmap.height();
+
+  SkRect source_rect;
+  if (image_aspect_ratio > container_aspect_ratio) {
+    float width = original_bitmap.height() * container_aspect_ratio;
+    source_rect = SkRect::MakeXYWH((original_bitmap.width() - width) / 2,
+                                   0,
+                                   width,
+                                   original_bitmap.height());
+  } else {
+    float height = original_bitmap.width() / container_aspect_ratio;
+    source_rect = SkRect::MakeXYWH(0,
+                                   (original_bitmap.height() - height) / 2,
+                                   original_bitmap.width(),
+                                   height);
+  }
+
+  SkBitmap container_bitmap;
+  container_bitmap.allocN32Pixels(container_size.width(),
+                                  container_size.height());
+  SkPaint paint;
+  paint.setFilterQuality(kHigh_SkFilterQuality);
+  SkCanvas container_image(container_bitmap);
+  container_image.drawColor(message_center::kImageBackgroundColor);
+  container_image.drawBitmapRect(
+      original_bitmap, source_rect, SkRect::MakeSize(container_size), &paint);
+
+  return container_bitmap;
+}
+
 class ArcNotificationDelegate : public message_center::NotificationDelegate {
  public:
   explicit ArcNotificationDelegate(base::WeakPtr<ArcNotificationItem> item)
       : item_(item) {}
 
   void Close(bool by_user) override {
     if (item_)
       item_->Close(by_user);
   }
 
@@ skipping 53 matching lines @@
     return;
   }
 
   message_center::RichNotificationData rich_data;
   message_center::NotificationType type;
 
   switch (data.type) {
     case ArcNotificationType::BASIC:
       type = message_center::NOTIFICATION_TYPE_BASE_FORMAT;
       break;
+    case ArcNotificationType::LIST:
+      type = message_center::NOTIFICATION_TYPE_MULTIPLE;
+
+      if (data.texts.is_null())
+        break;
+
+      for (size_t i = 0;
+           i < std::min(data.texts.size(),
+                        message_center::kNotificationMaximumItems - 1);
+           i++) {
+        rich_data.items.emplace_back(
+            base::string16(), base::UTF8ToUTF16(data.texts.at(i).get()));
+      }
+
+      if (data.texts.size() > message_center::kNotificationMaximumItems) {
+        // Show an elipsis as the 5th item if there are more than 5 items.
+        rich_data.items.emplace_back(base::string16(), gfx::kEllipsisUTF16);
+      } else if (data.texts.size() ==
+                 message_center::kNotificationMaximumItems) {
+        // Show the 5th item if there are exact 5 items.
+        rich_data.items.emplace_back(
+            base::string16(),
+            base::UTF8ToUTF16(data.texts.at(data.texts.size() - 1).get()));
+      }
+      break;
     case ArcNotificationType::IMAGE:
-      // TODO(yoshiki): Implement this types.
-      type = message_center::NOTIFICATION_TYPE_BASE_FORMAT;
-      LOG(ERROR) << "Unsupported notification type: image";
+      type = message_center::NOTIFICATION_TYPE_IMAGE;
+
+      if (!data.big_picture.is_null()) {
+        rich_data.image = gfx::Image::CreateFrom1xBitmap(
+            CropImage(data.big_picture.To<SkBitmap>()));
+      }
       break;
     case ArcNotificationType::PROGRESS:
       type = message_center::NOTIFICATION_TYPE_PROGRESS;
       rich_data.timestamp = base::Time::UnixEpoch() +
                             base::TimeDelta::FromMilliseconds(data.time);
       rich_data.progress = std::max(
           0, std::min(100, static_cast<int>(std::round(
                                static_cast<float>(data.progress_current) /
                                data.progress_max * 100))));
       break;
   }
   DCHECK(IsKnownEnumValue(data.type)) << "Unsupported notification type: "
                                       << data.type;
 
   for (size_t i = 0; i < data.buttons.size(); i++) {
-    rich_data.buttons.push_back(message_center::ButtonInfo(
-        base::UTF8ToUTF16(data.buttons.at(i)->label.get())));
+    rich_data.buttons.emplace_back(
+        base::UTF8ToUTF16(data.buttons.at(i)->label.get()));
   }
 
   // If the client is old (version < 1), both |no_clear| and |ongoing_event|
   // are false.
   rich_data.pinned = (data.no_clear || data.ongoing_event);
 
   // The identifier of the notifier, which is used to distinguish the notifiers
   // in the message center.
   message_center::NotifierId notifier_id(
       message_center::NotifierId::SYSTEM_COMPONENT, kNotifierId);
@@ skipping 62 matching lines @@
   message_center_->AddNotification(std::move(notification_));
 
   if (newer_data_) {
     // There is the newer data, so updates again.
     ArcNotificationDataPtr data(std::move(newer_data_));
     UpdateWithArcNotificationData(*data);
   }
 }
 
 }  // namespace arc