components/gcm_driver/gcm_driver_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 "components/gcm_driver/gcm_driver_android.h"
   6
   7 #include "base/android/jni_android.h"
   8 #include "base/android/jni_array.h"
   9 #include "base/android/jni_string.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/logging.h"
  12 #include "jni/GCMDriver_jni.h"
  13
  14 using base::android::AppendJavaStringArrayToStringVector;
  15 using base::android::AttachCurrentThread;
  16 using base::android::ConvertJavaStringToUTF8;
  17 using base::android::ConvertUTF8ToJavaString;
  18 using base::android::ToJavaArrayOfStrings;
  19
  20 namespace gcm {
  21
  22  GCMDriverAndroid::GCMDriverAndroid() {
  23   JNIEnv* env = AttachCurrentThread();
  24   java_ref_.Reset(
  25       Java_GCMDriver_create(env,
  26                             reinterpret_cast<intptr_t>(this),
  27                             base::android::GetApplicationContext()));
  28 }
  29
  30 GCMDriverAndroid::~GCMDriverAndroid() {
  31   JNIEnv* env = AttachCurrentThread();
  32   Java_GCMDriver_destroy(env, java_ref_.obj());
  33 }
  34
  35 void GCMDriverAndroid::OnRegisterFinished(JNIEnv* env,
  36                                           jobject obj,
  37                                           jstring j_app_id,
  38                                           jstring j_registration_id,
  39                                           jboolean success) {
  40   std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
  41   std::string registration_id = ConvertJavaStringToUTF8(env, j_registration_id);
  42   GCMClient::Result result = success ? GCMClient::SUCCESS
  43                                      : GCMClient::UNKNOWN_ERROR;
  44
  45   RegisterFinished(app_id, registration_id, result);
  46 }
  47
  48 void GCMDriverAndroid::OnUnregisterFinished(JNIEnv* env,
  49                                             jobject obj,
  50                                             jstring j_app_id,
  51                                             jboolean success) {
  52   std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
  53   GCMClient::Result result = success ? GCMClient::SUCCESS
  54                                      : GCMClient::UNKNOWN_ERROR;
  55
  56   UnregisterFinished(app_id, result);
  57 }
  58
  59 void GCMDriverAndroid::OnMessageReceived(JNIEnv* env,
  60                                          jobject obj,
  61                                          jstring j_app_id,
  62                                          jstring j_sender_id,
  63                                          jstring j_collapse_key,
  64                                          jobjectArray j_data_keys_and_values) {
  65   std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
  66
  67   GCMClient::IncomingMessage message;
  68   message.sender_id = ConvertJavaStringToUTF8(env, j_sender_id);
  69   message.collapse_key = ConvertJavaStringToUTF8(env, j_collapse_key);
  70   // Expand j_data_keys_and_values from array to map.
  71   std::vector<std::string> data_keys_and_values;
  72   AppendJavaStringArrayToStringVector(env,
  73                                       j_data_keys_and_values,
  74                                       &data_keys_and_values);
  75   for (size_t i = 0; i + 1 < data_keys_and_values.size(); i += 2) {
  76     message.data[data_keys_and_values[i]] = data_keys_and_values[i+1];
  77   }
  78
  79   GetAppHandler(app_id)->OnMessage(app_id, message);
  80 }
  81
  82 void GCMDriverAndroid::OnMessagesDeleted(JNIEnv* env,
  83                                          jobject obj,
  84                                          jstring j_app_id) {
  85   std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
  86
  87   GetAppHandler(app_id)->OnMessagesDeleted(app_id);
  88 }
  89
  90 // static
  91 bool GCMDriverAndroid::RegisterBindings(JNIEnv* env) {
  92   return RegisterNativesImpl(env);
  93 }
  94
  95 void GCMDriverAndroid::OnSignedIn() {
  96 }
  97
  98 void GCMDriverAndroid::Purge() {
  99 }
 100
 101 void GCMDriverAndroid::Enable() {
 102 }
 103
 104 void GCMDriverAndroid::Disable() {
 105 }
 106
 107 GCMClient* GCMDriverAndroid::GetGCMClientForTesting() const {
 108   NOTIMPLEMENTED();
 109   return NULL;
 110 }
 111
 112 bool GCMDriverAndroid::IsStarted() const {
 113   return true;
 114 }
 115
 116 bool GCMDriverAndroid::IsConnected() const {
 117   // TODO(gcm): hook up to GCM connected status
 118   return true;
 119 }
 120
 121 void GCMDriverAndroid::GetGCMStatistics(
 122     const GetGCMStatisticsCallback& callback,
 123     bool clear_logs) {
 124   NOTIMPLEMENTED();
 125 }
 126
 127 void GCMDriverAndroid::SetGCMRecording(const GetGCMStatisticsCallback& callback,
 128                                        bool recording) {
 129   NOTIMPLEMENTED();
 130 }
 131
 132 GCMClient::Result GCMDriverAndroid::EnsureStarted() {
 133   // TODO(johnme): Maybe we should check if GMS is available?
 134   return GCMClient::SUCCESS;
 135 }
 136
 137 void GCMDriverAndroid::RegisterImpl(
 138     const std::string& app_id,
 139     const std::vector<std::string>& sender_ids) {
 140   JNIEnv* env = AttachCurrentThread();
 141   Java_GCMDriver_register(
 142       env, java_ref_.obj(),
 143       ConvertUTF8ToJavaString(env, app_id).Release(),
 144       ToJavaArrayOfStrings(env, sender_ids).obj());
 145 }
 146
 147 void GCMDriverAndroid::UnregisterImpl(const std::string& app_id) {
 148   JNIEnv* env = AttachCurrentThread();
 149   Java_GCMDriver_unregister(
 150       env, java_ref_.obj(),
 151       ConvertUTF8ToJavaString(env, app_id).Release());
 152 }
 153
 154 void GCMDriverAndroid::SendImpl(const std::string& app_id,
 155                                 const std::string& receiver_id,
 156                                 const GCMClient::OutgoingMessage& message) {
 157   NOTIMPLEMENTED();
 158 }
 159
 160 }  // namespace gcm