WIP initial sketch for an Android GCMClient

google_apis/gcm/gcm_client_impl_android.cc

+// Copyright 2014 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 "google_apis/gcm/gcm_client_impl_android.h"
+
+#include "base/memory/scoped_ptr.h"
+
+namespace gcm {
+
+namespace {
+
+GCMClientImplAndroid::GCMClientImplAndroid()
+    : state_(UNINITIALIZED),
+      delegate_(NULL) {
+}
+
+GCMClientImplAndroid::~GCMClientImplAndroid() {
+}
+
+void GCMClientImplAndroid::Initialize(
+    const checkin_proto::ChromeBuildProto& unused,
+    const base::FilePath& unused,
+    const std::vector<std::string>& unused,
+    const scoped_refptr<base::SequencedTaskRunner>& unused,
+    const scoped_refptr<net::URLRequestContextGetter>& unused,
+    Delegate* delegate) {
+  DCHECK_EQ(UNINITIALIZED, state_);
+  DCHECK(delegate);
+
+  // TODO(johnme): Initialize JNI counterpart.
+
+  delegate_ = delegate;
+  state_ = INITIALIZED;
+}
+
+void GCMClientImplAndroid::Load() {
+  DCHECK_EQ(INITIALIZED, state_);
+
+  // Do nothing. Android GCM API doesn't require loading in advance.
+
+  state_ = READY;
+}
+
+void GCMClientImplAndroid::Stop() {
+  // Do nothing?
+
+  if (state_ == READY)
+    state_ = INITIALIZED;
+}
+
+void GCMClientImplAndroid::CheckOut() {
+  Stop();
+  // TODO(johnme): What would this map to on Android? Is it even possible?
+  NOTIMPLEMENTED();
+}
+
+void GCMClientImplAndroid::Register(const std::string& app_id,
+                             const std::vector<std::string>& sender_ids) {
+  DCHECK_EQ(INITIALIZED, state_);
+
+  // TODO(johnme): Tell JNI counterpart to register.
+}
+
+void GCMClientImplAndroid::OnRegisterCompleted(JNIEnv* env,
+                                               jobject obj,
+                                               jstring j_app_id,
+                                               jboolean success,
+                                               jstring j_registration_id) {
+  DCHECK(delegate_);
+
+  std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
+  Result result = success ? SUCCESS : UNKNOWN_ERROR;
+  std::string registration_id = ConvertJavaStringToUTF8(env, j_registration_id);
+
+  delegate_->OnRegisterFinished(
+      app_id, result == SUCCESS ? registration_id : std::string(), result);
+}
+
+void GCMClientImplAndroid::Unregister(const std::string& app_id) {
+  DCHECK_EQ(INITIALIZED, state_);
+
+  // TODO(johnme): Tell JNI counterpart to unregister.
+}
+
+void GCMClientImplAndroid::OnUnregisterCompleted(JNIEnv* env,
+                                                 jobject obj,
+                                                 jstring j_app_id,
+                                                 jboolean success) {
+  DCHECK(delegate_);
+  std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
+  DVLOG(1) << "Unregister completed for app: " << app_id
+           << " with " << (success ? "success." : "failure.");
+  delegate_->OnUnregisterFinished(app_id, success ? SUCCESS : SERVER_ERROR);
+}
+
+
+
+  void OnRegisterCompleted(JNIEnv* env,
+                           jobject obj,
+                           jstring app_id,
+                           jobjectArray sender_ids,
+                           jboolean success,
+                           jstring registration_id);
+  void OnUnregisterCompleted(JNIEnv* env,
+                             jobject obj,
+                            jstring app_id,
+                            jboolean success);
+
+
+
+void GCMClientImplAndroid::Send(const std::string& app_id,
+                         const std::string& receiver_id,
+                         const OutgoingMessage& message) {
+  DCHECK(initialized_);
+
+  NOTIMPLEMENTED() << "Send is not currently implemented on Android, as it is "
+                   << "only used by Chrome Apps & Extensions."
+}
+
+std::string GCMClientImplAndroid::GetStateString() const {
+  switch(state_) {
+    case GCMClientImpl::INITIALIZED:
+      return "INITIALIZED";
+    case GCMClientImpl::UNINITIALIZED:
+      return "UNINITIALIZED";
+    case GCMClientImpl::READY:
+      return "READY";
+    default:
+      NOTREACHED();
+      return std::string();
+  }
+}
+
+GCMClient::GCMStatistics GCMClientImplAndroid::GetStatistics() const {
+  GCMClient::GCMStatistics stats;
+  stats.gcm_client_state = GCMClientImplAndroid::GetStateString();
+  return stats;
+}
+
+void GCMClientImplAndroid::OnMessageReceived(JNIEnv* env,
+                                             jobject obj,
+                                             jstring j_sender_id,
+                                             jstring j_app_id,
+                                             jstring j_collapse_key,
+                                             jobjectArray j_data) {
+  DCHECK(delegate_);
+
+  std::string sender_id = ConvertJavaStringToUTF8(env, j_sender_id);
+  std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
+  std::string collapse_key = ConvertJavaStringToUTF8(env, j_collapse_key);
+  MessageData message_data; // TODO(johnme): Convert j_data from JNI format.
+
+  // TODO(johnme): Drop the message when the app is not registered for the
+  // sender of the message?
+
+  IncomingMessage incoming_message;
+  incoming_message.sender_id = sender_id;
+  incoming_message.collapse_key = collapse_key;
+  incoming_message.data = message_data;
+  delegate_->OnMessageReceived(app_id, incoming_message);
+}
+
+void GCMClientImplAndroid::OnMessagesDeletedByServer(JNIEnv* env,
+                                                     jobject obj,
+                                                     jstring j_app_id) {
+  DCHECK(delegate_);
+
+  std::string app_id = ConvertJavaStringToUTF8(env, j_app_id);
+
+  delegate_->OnMessagesDeleted(app_id);
+}
+
+}  // namespace gcm