src/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::OnSignedOut() {
  99 }
 100
 101 void GCMDriverAndroid::Purge() {
 102 }
 103
 104 void GCMDriverAndroid::AddConnectionObserver(GCMConnectionObserver* observer) {
 105 }
 106
 107 void GCMDriverAndroid::RemoveConnectionObserver(
 108     GCMConnectionObserver* observer) {
 109 }
 110
 111 void GCMDriverAndroid::Enable() {
 112 }
 113
 114 void GCMDriverAndroid::Disable() {
 115 }
 116
 117 GCMClient* GCMDriverAndroid::GetGCMClientForTesting() const {
 118   NOTIMPLEMENTED();
 119   return NULL;
 120 }
 121
 122 bool GCMDriverAndroid::IsStarted() const {
 123   return true;
 124 }
 125
 126 bool GCMDriverAndroid::IsConnected() const {
 127   // TODO(gcm): hook up to GCM connected status
 128   return true;
 129 }
 130
 131 void GCMDriverAndroid::GetGCMStatistics(
 132     const GetGCMStatisticsCallback& callback,
 133     bool clear_logs) {
 134   NOTIMPLEMENTED();
 135 }
 136
 137 void GCMDriverAndroid::SetGCMRecording(const GetGCMStatisticsCallback& callback,
 138                                        bool recording) {
 139   NOTIMPLEMENTED();
 140 }
 141
 142 void GCMDriverAndroid::SetAccountTokens(
 143     const std::vector<GCMClient::AccountTokenInfo>& account_tokens) {
 144   NOTIMPLEMENTED();
 145 }
 146
 147 void GCMDriverAndroid::UpdateAccountMapping(
 148     const AccountMapping& account_mapping) {
 149   NOTIMPLEMENTED();
 150 }
 151
 152 void GCMDriverAndroid::RemoveAccountMapping(const std::string& account_id) {
 153   NOTIMPLEMENTED();
 154 }
 155
 156 base::Time GCMDriverAndroid::GetLastTokenFetchTime() {
 157   NOTIMPLEMENTED();
 158   return base::Time();
 159 }
 160
 161 void GCMDriverAndroid::SetLastTokenFetchTime(const base::Time& time) {
 162   NOTIMPLEMENTED();
 163 }
 164
 165 GCMClient::Result GCMDriverAndroid::EnsureStarted() {
 166   // TODO(johnme): Maybe we should check if GMS is available?
 167   return GCMClient::SUCCESS;
 168 }
 169
 170 void GCMDriverAndroid::RegisterImpl(
 171     const std::string& app_id,
 172     const std::vector<std::string>& sender_ids) {
 173   JNIEnv* env = AttachCurrentThread();
 174   Java_GCMDriver_register(
 175       env, java_ref_.obj(),
 176       ConvertUTF8ToJavaString(env, app_id).Release(),
 177       ToJavaArrayOfStrings(env, sender_ids).obj());
 178 }
 179
 180 void GCMDriverAndroid::UnregisterImpl(const std::string& app_id) {
 181   JNIEnv* env = AttachCurrentThread();
 182   Java_GCMDriver_unregister(
 183       env, java_ref_.obj(),
 184       ConvertUTF8ToJavaString(env, app_id).Release());
 185 }
 186
 187 void GCMDriverAndroid::SendImpl(const std::string& app_id,
 188                                 const std::string& receiver_id,
 189                                 const GCMClient::OutgoingMessage& message) {
 190   NOTIMPLEMENTED();
 191 }
 192
 193 }  // namespace gcm