Capabilities + Extensions + Cast Host Extension Support for Android client

remoting/client/jni/chromoting_jni_runtime.cc

 // Copyright 2013 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 "remoting/client/jni/chromoting_jni_runtime.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
@@ skipping 59 matching lines @@
 }
 
 static void Connect(JNIEnv* env,
                     jclass clazz,
                     jstring username,
                     jstring authToken,
                     jstring hostJid,
                     jstring hostId,
                     jstring hostPubkey,
                     jstring pairId,
-                    jstring pairSecret) {
+                    jstring pairSecret,
+                    jstring capabilities) {
   remoting::ChromotingJniRuntime::GetInstance()->ConnectToHost(
       ConvertJavaStringToUTF8(env, username).c_str(),
       ConvertJavaStringToUTF8(env, authToken).c_str(),
       ConvertJavaStringToUTF8(env, hostJid).c_str(),
       ConvertJavaStringToUTF8(env, hostId).c_str(),
       ConvertJavaStringToUTF8(env, hostPubkey).c_str(),
       ConvertJavaStringToUTF8(env, pairId).c_str(),
-      ConvertJavaStringToUTF8(env, pairSecret).c_str());
+      ConvertJavaStringToUTF8(env, pairSecret).c_str(),
+      ConvertJavaStringToUTF8(env, capabilities).c_str());
 }
 
 static void Disconnect(JNIEnv* env, jclass clazz) {
   remoting::ChromotingJniRuntime::GetInstance()->DisconnectFromHost();
 }
 
 static void AuthenticationResponse(JNIEnv* env,
                                    jclass clazz,
                                    jstring pin,
                                    jboolean createPair,
@@ skipping 50 matching lines @@
                                      jstring token,
                                      jstring shared_secret) {
   ChromotingJniRuntime* runtime = remoting::ChromotingJniRuntime::GetInstance();
   runtime->network_task_runner()->PostTask(FROM_HERE, base::Bind(
       &ChromotingJniInstance::HandleOnThirdPartyTokenFetched,
       runtime->session(),
       ConvertJavaStringToUTF8(env, token),
       ConvertJavaStringToUTF8(env, shared_secret)));
 }
 
+static void SendExtensionMessage(JNIEnv* env,
+                                 jclass clazz,
+                                 jstring type,
+                                 jstring data) {
+  remoting::ChromotingJniRuntime::GetInstance()->session()->SendClientMessage(
+      ConvertJavaStringToUTF8(env, type),
+      ConvertJavaStringToUTF8(env, data));
+}
+
 // ChromotingJniRuntime implementation.
 
 // static
 ChromotingJniRuntime* ChromotingJniRuntime::GetInstance() {
   return Singleton<ChromotingJniRuntime>::get();
 }
 
 ChromotingJniRuntime::ChromotingJniRuntime() {
   at_exit_manager_.reset(new base::AtExitManager());
 
@@ skipping 38 matching lines @@
   done_event.Wait();
   base::android::DetachFromVM();
 }
 
 void ChromotingJniRuntime::ConnectToHost(const char* username,
                                   const char* auth_token,
                                   const char* host_jid,
                                   const char* host_id,
                                   const char* host_pubkey,
                                   const char* pairing_id,
-                                  const char* pairing_secret) {
+                                  const char* pairing_secret,
+                                  const char* capabilities) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(!session_);
   session_ = new ChromotingJniInstance(this,
                                        username,
                                        auth_token,
                                        host_jid,
                                        host_id,
                                        host_pubkey,
                                        pairing_id,
-                                       pairing_secret);
+                                       pairing_secret,
+                                       capabilities);
 }
 
 void ChromotingJniRuntime::DisconnectFromHost() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   if (session_) {
     session_->Disconnect();
     session_ = NULL;
   }
 }
 
@@ skipping 36 matching lines @@
   ScopedJavaLocalRef<jstring> j_url =
       ConvertUTF8ToJavaString(env, token_url.spec());
   ScopedJavaLocalRef<jstring> j_client_id =
       ConvertUTF8ToJavaString(env, client_id);
   ScopedJavaLocalRef<jstring> j_scope = ConvertUTF8ToJavaString(env, scope);
 
   Java_JniInterface_fetchThirdPartyToken(
       env, j_url.obj(), j_client_id.obj(), j_scope.obj());
 }
 
+void ChromotingJniRuntime::SetCapabilities(const std::string& capabilities) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  ScopedJavaLocalRef<jstring> j_cap =
+      ConvertUTF8ToJavaString(env, capabilities);
+
+  Java_JniInterface_setCapabilities(env, j_cap.obj());
+}
+
+void ChromotingJniRuntime::HandleExtensionMessage(const std::string& type,
+                                                  const std::string& message) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  ScopedJavaLocalRef<jstring> j_type = ConvertUTF8ToJavaString(env, type);
+  ScopedJavaLocalRef<jstring> j_message = ConvertUTF8ToJavaString(env, message);
+
+  Java_JniInterface_handleExtensionMessage(env, j_type.obj(), j_message.obj());
+}
+
 base::android::ScopedJavaLocalRef<jobject> ChromotingJniRuntime::NewBitmap(
     webrtc::DesktopSize size) {
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_JniInterface_newBitmap(env, size.width(), size.height());
 }
 
 void ChromotingJniRuntime::UpdateFrameBitmap(jobject bitmap) {
   DCHECK(display_task_runner_->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
@@ skipping 28 matching lines @@
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_redrawGraphicsInternal(env);
 }
 
 void ChromotingJniRuntime::DetachFromVmAndSignal(base::WaitableEvent* waiter) {
   base::android::DetachFromVM();
   waiter->Signal();
 }
 }  // namespace remoting