1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// 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.h"
#include "base/android/base_jni_registrar.h"
#include "base/android/jni_android.h"
#include "base/memory/singleton.h"
#include "media/base/yuv_convert.h"
#include "net/android/net_jni_registrar.h"
#include "remoting/base/url_request_context.h"
// Class and package name of the Java class supporting the methods we call.
const char* const JAVA_CLASS = "org/chromium/chromoting/jni/JniInterface";
namespace remoting {
// static
ChromotingJni* ChromotingJni::GetInstance() {
return Singleton<ChromotingJni>::get();
}
ChromotingJni::ChromotingJni() {
// Obtain a reference to the Java environment. (Future calls to this function
// made from the same thread return the same stored reference instead of
// repeating the work of attaching to the JVM.)
JNIEnv* env = base::android::AttachCurrentThread();
// The base and networks stacks must be registered with JNI in order to work
// on Android. An AtExitManager cleans this up at process exit.
at_exit_manager_.reset(new base::AtExitManager());
base::android::RegisterJni(env);
net::android::RegisterJni(env);
// On Android, the UI thread is managed by Java, so we need to attach and
// start a special type of message loop to allow Chromium code to run tasks.
LOG(INFO) << "Starting main message loop";
ui_loop_.reset(new base::MessageLoopForUI());
ui_loop_->Start();
LOG(INFO) << "Spawning additional threads";
// TODO(solb) Stop pretending to control the managed UI thread's lifetime.
ui_task_runner_ = new AutoThreadTaskRunner(ui_loop_->message_loop_proxy(),
base::MessageLoop::QuitClosure());
network_task_runner_ = AutoThread::CreateWithType("native_net",
ui_task_runner_,
base::MessageLoop::TYPE_IO);
display_task_runner_ = AutoThread::Create("native_disp",
ui_task_runner_);
url_requester_ = new URLRequestContextGetter(ui_task_runner_,
network_task_runner_);
// Allows later decoding of video frames.
media::InitializeCPUSpecificYUVConversions();
class_ = static_cast<jclass>(env->NewGlobalRef(env->FindClass(JAVA_CLASS)));
}
ChromotingJni::~ChromotingJni() {
// The singleton should only ever be destroyed on the main thread.
DCHECK(ui_task_runner_->BelongsToCurrentThread());
// The session must be shut down first, since it depends on our other
// components' still being alive.
DisconnectFromHost();
JNIEnv* env = base::android::AttachCurrentThread();
env->DeleteGlobalRef(class_);
// TODO(solb): crbug.com/259594 Detach all threads from JVM here.
}
void ChromotingJni::ConnectToHost(const char* username,
const char* auth_token,
const char* host_jid,
const char* host_id,
const char* host_pubkey) {
DCHECK(ui_task_runner_->BelongsToCurrentThread());
DCHECK(!session_);
session_ = new ChromotingJniInstance(username,
auth_token,
host_jid,
host_id,
host_pubkey);
}
void ChromotingJni::DisconnectFromHost() {
DCHECK(ui_task_runner_->BelongsToCurrentThread());
if (session_) {
session_->Cleanup();
session_ = NULL;
}
}
void ChromotingJni::ReportConnectionStatus(
protocol::ConnectionToHost::State state,
protocol::ErrorCode error) {
DCHECK(ui_task_runner_->BelongsToCurrentThread());
JNIEnv* env = base::android::AttachCurrentThread();
env->CallStaticVoidMethod(
class_,
env->GetStaticMethodID(class_, "reportConnectionStatus", "(II)V"),
state,
error);
}
void ChromotingJni::DisplayAuthenticationPrompt() {
DCHECK(ui_task_runner_->BelongsToCurrentThread());
JNIEnv* env = base::android::AttachCurrentThread();
env->CallStaticVoidMethod(
class_,
env->GetStaticMethodID(class_, "displayAuthenticationPrompt", "()V"));
}
void ChromotingJni::UpdateImageBuffer(int width, int height, jobject buffer) {
DCHECK(display_task_runner_->BelongsToCurrentThread());
JNIEnv* env = base::android::AttachCurrentThread();
env->SetStaticIntField(
class_,
env->GetStaticFieldID(class_, "sWidth", "I"),
width);
env->SetStaticIntField(
class_,
env->GetStaticFieldID(class_, "sHeight", "I"),
height);
env->SetStaticObjectField(
class_,
env->GetStaticFieldID(class_, "sBuffer", "Ljava/nio/ByteBuffer;"),
buffer);
}
void ChromotingJni::RedrawCanvas() {
DCHECK(display_task_runner_->BelongsToCurrentThread());
JNIEnv* env = base::android::AttachCurrentThread();
env->CallStaticVoidMethod(
class_,
env->GetStaticMethodID(class_, "redrawGraphicsInternal", "()V"));
}
} // namespace remoting
|
