1 // Copyright 2013 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.
5 #include "remoting/client/jni/chromoting_jni_runtime.h"
7 #include "base/android/jni_android.h"
8 #include "base/android/jni_array.h"
9 #include "base/android/jni_string.h"
10 #include "base/android/scoped_java_ref.h"
11 #include "base/basictypes.h"
12 #include "base/command_line.h"
13 #include "base/memory/singleton.h"
14 #include "base/stl_util.h"
15 #include "base/synchronization/waitable_event.h"
16 #include "google_apis/google_api_keys.h"
17 #include "jni/JniInterface_jni.h"
18 #include "media/base/yuv_convert.h"
19 #include "remoting/base/url_request_context_getter.h"
20 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
22 using base::android::ConvertJavaStringToUTF8;
23 using base::android::ConvertUTF8ToJavaString;
24 using base::android::ToJavaByteArray;
28 const int kBytesPerPixel = 4;
34 bool RegisterJni(JNIEnv* env) {
35 return remoting::RegisterNativesImpl(env);
38 // Implementation of stubs defined in JniInterface_jni.h. These are the entry
39 // points for JNI calls from Java into C++.
41 static void LoadNative(JNIEnv* env, jclass clazz, jobject context) {
42 base::android::ScopedJavaLocalRef<jobject> context_activity(env, context);
43 base::android::InitApplicationContext(env, context_activity);
45 // The google_apis functions check the command-line arguments to make sure no
46 // runtime API keys have been specified by the environment. Unfortunately, we
47 // neither launch Chromium nor have a command line, so we need to prevent
48 // them from DCHECKing out when they go looking.
49 base::CommandLine::Init(0, NULL);
51 // Create the singleton now so that the Chromoting threads will be set up.
52 remoting::ChromotingJniRuntime::GetInstance();
55 static jstring GetApiKey(JNIEnv* env, jclass clazz) {
56 return ConvertUTF8ToJavaString(
57 env, google_apis::GetAPIKey().c_str()).Release();
60 static jstring GetClientId(JNIEnv* env, jclass clazz) {
61 return ConvertUTF8ToJavaString(
62 env, google_apis::GetOAuth2ClientID(
63 google_apis::CLIENT_REMOTING).c_str()).Release();
66 static jstring GetClientSecret(JNIEnv* env, jclass clazz) {
67 return ConvertUTF8ToJavaString(
68 env, google_apis::GetOAuth2ClientSecret(
69 google_apis::CLIENT_REMOTING).c_str()).Release();
72 static void Connect(JNIEnv* env,
81 jstring capabilities) {
82 remoting::ChromotingJniRuntime::GetInstance()->ConnectToHost(
83 ConvertJavaStringToUTF8(env, username).c_str(),
84 ConvertJavaStringToUTF8(env, authToken).c_str(),
85 ConvertJavaStringToUTF8(env, hostJid).c_str(),
86 ConvertJavaStringToUTF8(env, hostId).c_str(),
87 ConvertJavaStringToUTF8(env, hostPubkey).c_str(),
88 ConvertJavaStringToUTF8(env, pairId).c_str(),
89 ConvertJavaStringToUTF8(env, pairSecret).c_str(),
90 ConvertJavaStringToUTF8(env, capabilities).c_str());
93 static void Disconnect(JNIEnv* env, jclass clazz) {
94 remoting::ChromotingJniRuntime::GetInstance()->DisconnectFromHost();
97 static void AuthenticationResponse(JNIEnv* env,
101 jstring deviceName) {
102 remoting::ChromotingJniRuntime::GetInstance()->session()->ProvideSecret(
103 ConvertJavaStringToUTF8(env, pin).c_str(), createPair,
104 ConvertJavaStringToUTF8(env, deviceName));
107 static void ScheduleRedraw(JNIEnv* env, jclass clazz) {
108 remoting::ChromotingJniRuntime::GetInstance()->session()->RedrawDesktop();
111 static void SendMouseEvent(JNIEnv* env,
116 jboolean buttonDown) {
117 // Button must be within the bounds of the MouseEvent_MouseButton enum.
118 DCHECK(whichButton >= 0 && whichButton < 5);
120 remoting::ChromotingJniRuntime::GetInstance()->session()->SendMouseEvent(
122 static_cast<remoting::protocol::MouseEvent_MouseButton>(whichButton),
126 static void SendMouseWheelEvent(JNIEnv* env,
130 remoting::ChromotingJniRuntime::GetInstance()->session()->SendMouseWheelEvent(
134 static jboolean SendKeyEvent(JNIEnv* env,
138 return remoting::ChromotingJniRuntime::GetInstance()->session()->SendKeyEvent(
142 static void SendTextEvent(JNIEnv* env,
145 remoting::ChromotingJniRuntime::GetInstance()->session()->SendTextEvent(
146 ConvertJavaStringToUTF8(env, text));
149 static void OnThirdPartyTokenFetched(JNIEnv* env,
152 jstring shared_secret) {
153 ChromotingJniRuntime* runtime = remoting::ChromotingJniRuntime::GetInstance();
154 runtime->network_task_runner()->PostTask(FROM_HERE, base::Bind(
155 &ChromotingJniInstance::HandleOnThirdPartyTokenFetched,
157 ConvertJavaStringToUTF8(env, token),
158 ConvertJavaStringToUTF8(env, shared_secret)));
161 static void SendExtensionMessage(JNIEnv* env,
165 remoting::ChromotingJniRuntime::GetInstance()->session()->SendClientMessage(
166 ConvertJavaStringToUTF8(env, type),
167 ConvertJavaStringToUTF8(env, data));
170 // ChromotingJniRuntime implementation.
173 ChromotingJniRuntime* ChromotingJniRuntime::GetInstance() {
174 return Singleton<ChromotingJniRuntime>::get();
177 ChromotingJniRuntime::ChromotingJniRuntime() {
178 at_exit_manager_.reset(new base::AtExitManager());
180 // On Android, the UI thread is managed by Java, so we need to attach and
181 // start a special type of message loop to allow Chromium code to run tasks.
182 ui_loop_.reset(new base::MessageLoopForUI());
185 // TODO(solb) Stop pretending to control the managed UI thread's lifetime.
186 ui_task_runner_ = new AutoThreadTaskRunner(ui_loop_->message_loop_proxy(),
187 base::MessageLoop::QuitClosure());
188 network_task_runner_ = AutoThread::CreateWithType("native_net",
190 base::MessageLoop::TYPE_IO);
191 display_task_runner_ = AutoThread::Create("native_disp",
194 url_requester_ = new URLRequestContextGetter(network_task_runner_);
196 // Allows later decoding of video frames.
197 media::InitializeCPUSpecificYUVConversions();
200 ChromotingJniRuntime::~ChromotingJniRuntime() {
201 // The singleton should only ever be destroyed on the main thread.
202 DCHECK(ui_task_runner_->BelongsToCurrentThread());
204 // The session must be shut down first, since it depends on our other
205 // components' still being alive.
206 DisconnectFromHost();
208 base::WaitableEvent done_event(false, false);
209 network_task_runner_->PostTask(FROM_HERE, base::Bind(
210 &ChromotingJniRuntime::DetachFromVmAndSignal,
211 base::Unretained(this),
214 display_task_runner_->PostTask(FROM_HERE, base::Bind(
215 &ChromotingJniRuntime::DetachFromVmAndSignal,
216 base::Unretained(this),
219 base::android::DetachFromVM();
222 void ChromotingJniRuntime::ConnectToHost(const char* username,
223 const char* auth_token,
224 const char* host_jid,
226 const char* host_pubkey,
227 const char* pairing_id,
228 const char* pairing_secret,
229 const char* capabilities) {
230 DCHECK(ui_task_runner_->BelongsToCurrentThread());
232 session_ = new ChromotingJniInstance(this,
243 void ChromotingJniRuntime::DisconnectFromHost() {
244 DCHECK(ui_task_runner_->BelongsToCurrentThread());
246 session_->Disconnect();
251 void ChromotingJniRuntime::OnConnectionState(
252 protocol::ConnectionToHost::State state,
253 protocol::ErrorCode error) {
254 DCHECK(ui_task_runner_->BelongsToCurrentThread());
256 JNIEnv* env = base::android::AttachCurrentThread();
257 Java_JniInterface_onConnectionState(env, state, error);
260 void ChromotingJniRuntime::DisplayAuthenticationPrompt(bool pairing_supported) {
261 DCHECK(ui_task_runner_->BelongsToCurrentThread());
263 JNIEnv* env = base::android::AttachCurrentThread();
264 Java_JniInterface_displayAuthenticationPrompt(env, pairing_supported);
267 void ChromotingJniRuntime::CommitPairingCredentials(const std::string& host,
268 const std::string& id,
269 const std::string& secret) {
270 DCHECK(ui_task_runner_->BelongsToCurrentThread());
272 JNIEnv* env = base::android::AttachCurrentThread();
273 ScopedJavaLocalRef<jstring> j_host = ConvertUTF8ToJavaString(env, host);
274 ScopedJavaLocalRef<jstring> j_id = ConvertUTF8ToJavaString(env, id);
275 ScopedJavaLocalRef<jstring> j_secret = ConvertUTF8ToJavaString(env,secret);
277 Java_JniInterface_commitPairingCredentials(
278 env, j_host.obj(), j_id.obj(), j_secret.obj());
281 void ChromotingJniRuntime::FetchThirdPartyToken(const GURL& token_url,
282 const std::string& client_id,
283 const std::string& scope) {
284 DCHECK(ui_task_runner_->BelongsToCurrentThread());
285 JNIEnv* env = base::android::AttachCurrentThread();
287 ScopedJavaLocalRef<jstring> j_url =
288 ConvertUTF8ToJavaString(env, token_url.spec());
289 ScopedJavaLocalRef<jstring> j_client_id =
290 ConvertUTF8ToJavaString(env, client_id);
291 ScopedJavaLocalRef<jstring> j_scope = ConvertUTF8ToJavaString(env, scope);
293 Java_JniInterface_fetchThirdPartyToken(
294 env, j_url.obj(), j_client_id.obj(), j_scope.obj());
297 void ChromotingJniRuntime::SetCapabilities(const std::string& capabilities) {
298 DCHECK(ui_task_runner_->BelongsToCurrentThread());
299 JNIEnv* env = base::android::AttachCurrentThread();
301 ScopedJavaLocalRef<jstring> j_cap =
302 ConvertUTF8ToJavaString(env, capabilities);
304 Java_JniInterface_setCapabilities(env, j_cap.obj());
307 void ChromotingJniRuntime::HandleExtensionMessage(const std::string& type,
308 const std::string& message) {
309 DCHECK(ui_task_runner_->BelongsToCurrentThread());
310 JNIEnv* env = base::android::AttachCurrentThread();
312 ScopedJavaLocalRef<jstring> j_type = ConvertUTF8ToJavaString(env, type);
313 ScopedJavaLocalRef<jstring> j_message = ConvertUTF8ToJavaString(env, message);
315 Java_JniInterface_handleExtensionMessage(env, j_type.obj(), j_message.obj());
318 base::android::ScopedJavaLocalRef<jobject> ChromotingJniRuntime::NewBitmap(
319 webrtc::DesktopSize size) {
320 JNIEnv* env = base::android::AttachCurrentThread();
321 return Java_JniInterface_newBitmap(env, size.width(), size.height());
324 void ChromotingJniRuntime::UpdateFrameBitmap(jobject bitmap) {
325 DCHECK(display_task_runner_->BelongsToCurrentThread());
327 JNIEnv* env = base::android::AttachCurrentThread();
328 Java_JniInterface_setVideoFrame(env, bitmap);
331 void ChromotingJniRuntime::UpdateCursorShape(
332 const protocol::CursorShapeInfo& cursor_shape) {
333 DCHECK(display_task_runner_->BelongsToCurrentThread());
335 // const_cast<> is safe as long as the Java updateCursorShape() method copies
336 // the data out of the buffer without mutating it, and doesn't keep any
337 // reference to the buffer afterwards. Unfortunately, there seems to be no way
338 // to create a read-only ByteBuffer from a pointer-to-const.
339 char* data = string_as_array(const_cast<std::string*>(&cursor_shape.data()));
340 int cursor_total_bytes =
341 cursor_shape.width() * cursor_shape.height() * kBytesPerPixel;
343 JNIEnv* env = base::android::AttachCurrentThread();
344 base::android::ScopedJavaLocalRef<jobject> buffer(env,
345 env->NewDirectByteBuffer(data, cursor_total_bytes));
346 Java_JniInterface_updateCursorShape(env,
347 cursor_shape.width(),
348 cursor_shape.height(),
349 cursor_shape.hotspot_x(),
350 cursor_shape.hotspot_y(),
354 void ChromotingJniRuntime::RedrawCanvas() {
355 DCHECK(display_task_runner_->BelongsToCurrentThread());
357 JNIEnv* env = base::android::AttachCurrentThread();
358 Java_JniInterface_redrawGraphicsInternal(env);
361 void ChromotingJniRuntime::DetachFromVmAndSignal(base::WaitableEvent* waiter) {
362 base::android::DetachFromVM();
365 } // namespace remoting