chrome/browser/notifications/notification_ui_manager_android.cc

   1 // Copyright 2014 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
   5 #include "chrome/browser/notifications/notification_ui_manager_android.h"
   6
   7 #include <utility>
   8
   9 #include "base/android/jni_array.h"
  10 #include "base/android/jni_string.h"
  11 #include "base/logging.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "chrome/browser/browser_process.h"
  14 #include "chrome/browser/notifications/notification.h"
  15 #include "chrome/browser/notifications/persistent_notification_delegate.h"
  16 #include "chrome/browser/notifications/platform_notification_service_impl.h"
  17 #include "chrome/browser/profiles/profile_manager.h"
  18 #include "content/public/common/persistent_notification_status.h"
  19 #include "content/public/common/platform_notification_data.h"
  20 #include "jni/NotificationUIManager_jni.h"
  21 #include "ui/gfx/android/java_bitmap.h"
  22 #include "ui/gfx/image/image.h"
  23
  24 using base::android::AttachCurrentThread;
  25 using base::android::ConvertJavaStringToUTF8;
  26 using base::android::ConvertUTF16ToJavaString;
  27 using base::android::ConvertUTF8ToJavaString;
  28
  29 // Called by the Java side when a notification event has been received, but the
  30 // NotificationUIManager has not been initialized yet. Enforce initialization of
  31 // the class.
  32 static void InitializeNotificationUIManager(JNIEnv* env,
  33                                             const JavaParamRef<jclass>& clazz) {
  34   g_browser_process->notification_ui_manager();
  35 }
  36
  37 // static
  38 NotificationUIManager* NotificationUIManager::Create(PrefService* local_state) {
  39   return new NotificationUIManagerAndroid();
  40 }
  41
  42 NotificationUIManagerAndroid::NotificationUIManagerAndroid() {
  43   java_object_.Reset(
  44       Java_NotificationUIManager_create(
  45           AttachCurrentThread(),
  46           reinterpret_cast<intptr_t>(this),
  47           base::android::GetApplicationContext()));
  48 }
  49
  50 NotificationUIManagerAndroid::~NotificationUIManagerAndroid() {
  51   Java_NotificationUIManager_destroy(AttachCurrentThread(),
  52                                      java_object_.obj());
  53 }
  54
  55 bool NotificationUIManagerAndroid::OnNotificationClicked(
  56     JNIEnv* env,
  57     jobject java_object,
  58     jlong persistent_notification_id,
  59     jstring java_origin,
  60     jstring java_tag) {
  61   GURL origin(ConvertJavaStringToUTF8(env, java_origin));
  62   std::string tag = ConvertJavaStringToUTF8(env, java_tag);
  63
  64   regenerated_notification_infos_[persistent_notification_id] =
  65       std::make_pair(origin.spec(), tag);
  66
  67   // TODO(peter): Rather than assuming that the last used profile is the
  68   // appropriate one for this notification, the used profile should be
  69   // stored as part of the notification's data. See https://crbug.com/437574.
  70   PlatformNotificationServiceImpl::GetInstance()->OnPersistentNotificationClick(
  71       ProfileManager::GetLastUsedProfile(),
  72       persistent_notification_id,
  73       origin,
  74       -1 /* action_index */);
  75
  76   return true;
  77 }
  78
  79 bool NotificationUIManagerAndroid::OnNotificationClosed(
  80     JNIEnv* env,
  81     jobject java_object,
  82     jlong persistent_notification_id,
  83     jstring java_origin,
  84     jstring java_tag) {
  85   GURL origin(ConvertJavaStringToUTF8(env, java_origin));
  86   std::string tag = ConvertJavaStringToUTF8(env, java_tag);
  87
  88   // The notification was closed by the platform, so clear all local state.
  89   regenerated_notification_infos_.erase(persistent_notification_id);
  90
  91   // TODO(peter): Rather than assuming that the last used profile is the
  92   // appropriate one for this notification, the used profile should be
  93   // stored as part of the notification's data. See https://crbug.com/437574.
  94   PlatformNotificationServiceImpl::GetInstance()->OnPersistentNotificationClose(
  95       ProfileManager::GetLastUsedProfile(),
  96       persistent_notification_id,
  97       origin);
  98
  99   return true;
 100 }
 101
 102 void NotificationUIManagerAndroid::Add(const Notification& notification,
 103                                        Profile* profile) {
 104   JNIEnv* env = AttachCurrentThread();
 105
 106   // The Android notification UI manager only supports Web Notifications, which
 107   // have a PersistentNotificationDelegate. The persistent id of the
 108   // notification is exposed through it's interface.
 109   //
 110   // TODO(peter): When content/ passes a message_center::Notification to the
 111   // chrome/ layer, the persistent notification id should be captured as a
 112   // property on that object instead, making this cast unnecessary.
 113   PersistentNotificationDelegate* delegate =
 114       static_cast<PersistentNotificationDelegate*>(notification.delegate());
 115   DCHECK(delegate);
 116
 117   int64_t persistent_notification_id = delegate->persistent_notification_id();
 118   GURL origin_url(notification.origin_url().GetOrigin());
 119
 120   ScopedJavaLocalRef<jstring> origin = ConvertUTF8ToJavaString(
 121       env, origin_url.spec());
 122   ScopedJavaLocalRef<jstring> tag =
 123       ConvertUTF8ToJavaString(env, notification.tag());
 124   ScopedJavaLocalRef<jstring> title = ConvertUTF16ToJavaString(
 125       env, notification.title());
 126   ScopedJavaLocalRef<jstring> body = ConvertUTF16ToJavaString(
 127       env, notification.message());
 128
 129   ScopedJavaLocalRef<jobject> icon;
 130
 131   SkBitmap icon_bitmap = notification.icon().AsBitmap();
 132   if (!icon_bitmap.isNull())
 133     icon = gfx::ConvertToJavaBitmap(&icon_bitmap);
 134
 135   ScopedJavaLocalRef<jintArray> vibration_pattern =
 136       base::android::ToJavaIntArray(env, notification.vibration_pattern());
 137
 138   Java_NotificationUIManager_displayNotification(
 139       env,
 140       java_object_.obj(),
 141       persistent_notification_id,
 142       origin.obj(),
 143       tag.obj(),
 144       title.obj(),
 145       body.obj(),
 146       icon.obj(),
 147       vibration_pattern.obj(),
 148       notification.silent());
 149
 150   regenerated_notification_infos_[persistent_notification_id] =
 151       std::make_pair(origin_url.spec(), notification.tag());
 152
 153   notification.delegate()->Display();
 154 }
 155
 156 bool NotificationUIManagerAndroid::Update(const Notification& notification,
 157                                           Profile* profile) {
 158   NOTREACHED();
 159   return false;
 160 }
 161
 162 const Notification* NotificationUIManagerAndroid::FindById(
 163     const std::string& delegate_id,
 164     ProfileID profile_id) const {
 165   NOTREACHED();
 166   return nullptr;
 167 }
 168
 169 bool NotificationUIManagerAndroid::CancelById(const std::string& delegate_id,
 170                                               ProfileID profile_id) {
 171   int64_t persistent_notification_id = 0;
 172
 173   // TODO(peter): Use the |delegate_id| directly when notification ids are being
 174   // generated by content/ instead of us.
 175   if (!base::StringToInt64(delegate_id, &persistent_notification_id))
 176     return false;
 177
 178   const auto iterator =
 179       regenerated_notification_infos_.find(persistent_notification_id);
 180   if (iterator == regenerated_notification_infos_.end())
 181     return false;
 182
 183   const RegeneratedNotificationInfo& notification_info = iterator->second;
 184
 185   JNIEnv* env = AttachCurrentThread();
 186
 187   ScopedJavaLocalRef<jstring> origin =
 188       ConvertUTF8ToJavaString(env, notification_info.first);
 189   ScopedJavaLocalRef<jstring> tag =
 190       ConvertUTF8ToJavaString(env, notification_info.second);
 191
 192   regenerated_notification_infos_.erase(iterator);
 193
 194   Java_NotificationUIManager_closeNotification(env,
 195                                                java_object_.obj(),
 196                                                persistent_notification_id,
 197                                                origin.obj(),
 198                                                tag.obj());
 199   return true;
 200 }
 201
 202 std::set<std::string>
 203 NotificationUIManagerAndroid::GetAllIdsByProfileAndSourceOrigin(
 204     ProfileID profile_id,
 205     const GURL& source) {
 206   NOTREACHED();
 207   return std::set<std::string>();
 208 }
 209
 210 std::set<std::string> NotificationUIManagerAndroid::GetAllIdsByProfile(
 211     ProfileID profile_id) {
 212   NOTREACHED();
 213   return std::set<std::string>();
 214 }
 215
 216 bool NotificationUIManagerAndroid::CancelAllBySourceOrigin(
 217     const GURL& source_origin) {
 218   NOTREACHED();
 219   return false;
 220 }
 221
 222 bool NotificationUIManagerAndroid::CancelAllByProfile(ProfileID profile_id) {
 223   NOTREACHED();
 224   return false;
 225 }
 226
 227 void NotificationUIManagerAndroid::CancelAll() {
 228   NOTREACHED();
 229 }
 230
 231 bool NotificationUIManagerAndroid::RegisterNotificationUIManager(JNIEnv* env) {
 232   return RegisterNativesImpl(env);
 233 }