zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Android: Generate JNI code for androidnetworkmonitor_jni"

Browse Source 
This reverts commit 768e1c0ea1f2077675df31915132a0557aca400e.

Reason for revert: Breaks AppRTCMobile.

Original change's description:
> Android: Generate JNI code for androidnetworkmonitor_jni
> 
> Bug: webrtc:8278
> Change-Id: I8447b2de5ec2610760f7112b6f86e54d94325322
> Reviewed-on: https://webrtc-review.googlesource.com/24520
> Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
> Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#20796}

TBR=magjed@webrtc.org,sakal@webrtc.org

Change-Id: I45f8d19abd81386872b7c095ac7eca21fa06077c
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:8278,webrtc:8556
Reviewed-on: https://webrtc-review.googlesource.com/24622
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20800}
This commit is contained in:
Magnus Jedvert
2017-11-20 20:51:40 +00:00
committed by Commit Bot
parent eeb2765f6c
commit 522c1bc6bb
5 changed files with 110 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
sdk/android/BUILD.gn
View File

@ -269,15 +269,6 @@ rtc_static_library("null_media_jni") {
} }
} }
generate_jni("generated_peerconnection_jni") {
sources = [
"api/org/webrtc/NetworkMonitor.java",
"api/org/webrtc/NetworkMonitorAutoDetect.java",
]
jni_package = ""
jni_generator_include = "//sdk/android/src/jni/jni_generator_helper.h"
}
rtc_static_library("peerconnection_jni") { rtc_static_library("peerconnection_jni") {
sources = [ sources = [
"src/jni/androidnetworkmonitor_jni.h", "src/jni/androidnetworkmonitor_jni.h",
@ -337,7 +328,6 @@ rtc_static_library("peerconnection_jni") {
deps = [ deps = [
":base_jni", ":base_jni",
":generated_peerconnection_jni",
"../..:webrtc_common", "../..:webrtc_common",
"../../api/video_codecs:video_codecs_api", "../../api/video_codecs:video_codecs_api",
"../../media:rtc_data", "../../media:rtc_data",

19
sdk/android/api/org/webrtc/NetworkMonitor.java
View File

@ -63,7 +63,6 @@ public class NetworkMonitor {
/** /**
* Returns the singleton instance. * Returns the singleton instance.
*/ */
@CalledByNative
public static NetworkMonitor getInstance() { public static NetworkMonitor getInstance() {
if (instance == null) { if (instance == null) {
instance = new NetworkMonitor(); instance = new NetworkMonitor();
@ -78,11 +77,12 @@ public class NetworkMonitor {
} }
/** /**
* Called by the native code.
*
* Enables auto detection of the current network state based on notifications * Enables auto detection of the current network state based on notifications
* from the system. Note that this requires the embedding app have the * from the system. Note that this requires the embedding app have the
* platform ACCESS_NETWORK_STATE permission. * platform ACCESS_NETWORK_STATE permission.
*/ */
@CalledByNative
private void startMonitoring(long nativeObserver) { private void startMonitoring(long nativeObserver) {
Logging.d(TAG, "Start monitoring from native observer " + nativeObserver); Logging.d(TAG, "Start monitoring from native observer " + nativeObserver);
nativeNetworkObservers.add(nativeObserver); nativeNetworkObservers.add(nativeObserver);
@ -96,7 +96,7 @@ public class NetworkMonitor {
updateObserverActiveNetworkList(nativeObserver); updateObserverActiveNetworkList(nativeObserver);
} }
@CalledByNative // Called by the native code.
private void stopMonitoring(long nativeObserver) { private void stopMonitoring(long nativeObserver) {
Logging.d(TAG, "Stop monitoring from native observer " + nativeObserver); Logging.d(TAG, "Stop monitoring from native observer " + nativeObserver);
nativeNetworkObservers.remove(nativeObserver); nativeNetworkObservers.remove(nativeObserver);
@ -106,13 +106,13 @@ public class NetworkMonitor {
} }
} }
// Returns true if network binding is supported on this platform. // Called by the native code to determine if network binding is supported
@CalledByNative // on this platform.
private boolean networkBindingSupported() { private boolean networkBindingSupported() {
return autoDetector != null && autoDetector.supportNetworkCallback(); return autoDetector != null && autoDetector.supportNetworkCallback();
} }
@CalledByNative // Called by the native code to get the Android SDK version.
private static int androidSdkInt() { private static int androidSdkInt() {
return Build.VERSION.SDK_INT; return Build.VERSION.SDK_INT;
} }
@ -215,16 +215,9 @@ public class NetworkMonitor {
return connectionType != ConnectionType.CONNECTION_NONE; return connectionType != ConnectionType.CONNECTION_NONE;
} }
@NativeClassQualifiedName("webrtc::jni::AndroidNetworkMonitor")
private native void nativeNotifyConnectionTypeChanged(long nativePtr); private native void nativeNotifyConnectionTypeChanged(long nativePtr);
@NativeClassQualifiedName("webrtc::jni::AndroidNetworkMonitor")
private native void nativeNotifyOfNetworkConnect(long nativePtr, NetworkInformation networkInfo); private native void nativeNotifyOfNetworkConnect(long nativePtr, NetworkInformation networkInfo);
@NativeClassQualifiedName("webrtc::jni::AndroidNetworkMonitor")
private native void nativeNotifyOfNetworkDisconnect(long nativePtr, long networkHandle); private native void nativeNotifyOfNetworkDisconnect(long nativePtr, long networkHandle);
@NativeClassQualifiedName("webrtc::jni::AndroidNetworkMonitor")
private native void nativeNotifyOfActiveNetworkList( private native void nativeNotifyOfActiveNetworkList(
long nativePtr, NetworkInformation[] networkInfos); long nativePtr, NetworkInformation[] networkInfos);

25
sdk/android/api/org/webrtc/NetworkMonitorAutoDetect.java
View File

@ -62,11 +62,6 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
public IPAddress(byte[] address) { public IPAddress(byte[] address) {
this.address = address; this.address = address;
} }
@CalledByNative("IPAddress")
private byte[] getAddress() {
return address;
}
} }
/** Java version of NetworkMonitor.NetworkInformation */ /** Java version of NetworkMonitor.NetworkInformation */
@ -82,26 +77,6 @@ public class NetworkMonitorAutoDetect extends BroadcastReceiver {
this.handle = handle; this.handle = handle;
this.ipAddresses = addresses; this.ipAddresses = addresses;
} }
@CalledByNative("NetworkInformation")
private IPAddress[] getIpAddresses() {
return ipAddresses;
}
@CalledByNative("NetworkInformation")
private ConnectionType getConnectionType() {
return type;
}
@CalledByNative("NetworkInformation")
private long getHandle() {
return handle;
}
@CalledByNative("NetworkInformation")
private String getName() {
return name;
}
}; };
static class NetworkState { static class NetworkState {

134
sdk/android/src/jni/pc/androidnetworkmonitor_jni.cc
View File

@ -17,8 +17,7 @@
#include "rtc_base/bind.h" #include "rtc_base/bind.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/ipaddress.h" #include "rtc_base/ipaddress.h"
#include "sdk/android/generated_peerconnection_jni/jni/NetworkMonitorAutoDetect_jni.h" #include "sdk/android/src/jni/classreferenceholder.h"
#include "sdk/android/generated_peerconnection_jni/jni/NetworkMonitor_jni.h"
#include "sdk/android/src/jni/jni_helpers.h" #include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc { namespace webrtc {
@ -29,6 +28,8 @@ enum AndroidSdkVersion {
SDK_VERSION_MARSHMALLOW = 23 SDK_VERSION_MARSHMALLOW = 23
}; };
int AndroidNetworkMonitor::android_sdk_int_ = 0;
static NetworkType GetNetworkTypeFromJava(JNIEnv* jni, jobject j_network_type) { static NetworkType GetNetworkTypeFromJava(JNIEnv* jni, jobject j_network_type) {
std::string enum_name = GetJavaEnumName(jni, j_network_type); std::string enum_name = GetJavaEnumName(jni, j_network_type);
if (enum_name == "CONNECTION_UNKNOWN") { if (enum_name == "CONNECTION_UNKNOWN") {
@ -86,7 +87,10 @@ static rtc::AdapterType AdapterTypeFromNetworkType(NetworkType network_type) {
} }
static rtc::IPAddress GetIPAddressFromJava(JNIEnv* jni, jobject j_ip_address) { static rtc::IPAddress GetIPAddressFromJava(JNIEnv* jni, jobject j_ip_address) {
jbyteArray j_addresses = Java_IPAddress_getAddress(jni, j_ip_address); jclass j_ip_address_class = GetObjectClass(jni, j_ip_address);
jfieldID j_address_id = GetFieldID(jni, j_ip_address_class, "address", "[B");
jbyteArray j_addresses =
static_cast<jbyteArray>(GetObjectField(jni, j_ip_address, j_address_id));
size_t address_length = jni->GetArrayLength(j_addresses); size_t address_length = jni->GetArrayLength(j_addresses);
jbyte* addr_array = jni->GetByteArrayElements(j_addresses, nullptr); jbyte* addr_array = jni->GetByteArrayElements(j_addresses, nullptr);
CHECK_EXCEPTION(jni) << "Error during GetIPAddressFromJava"; CHECK_EXCEPTION(jni) << "Error during GetIPAddressFromJava";
@ -122,15 +126,26 @@ static void GetIPAddressesFromJava(JNIEnv* jni,
static NetworkInformation GetNetworkInformationFromJava( static NetworkInformation GetNetworkInformationFromJava(
JNIEnv* jni, JNIEnv* jni,
jobject j_network_info) { jobject j_network_info) {
jclass j_network_info_class = GetObjectClass(jni, j_network_info);
jfieldID j_interface_name_id =
GetFieldID(jni, j_network_info_class, "name", "Ljava/lang/String;");
jfieldID j_handle_id = GetFieldID(jni, j_network_info_class, "handle", "J");
jfieldID j_type_id =
GetFieldID(jni, j_network_info_class, "type",
"Lorg/webrtc/NetworkMonitorAutoDetect$ConnectionType;");
jfieldID j_ip_addresses_id =
GetFieldID(jni, j_network_info_class, "ipAddresses",
"[Lorg/webrtc/NetworkMonitorAutoDetect$IPAddress;");
NetworkInformation network_info; NetworkInformation network_info;
network_info.interface_name = JavaToStdString( network_info.interface_name = JavaToStdString(
jni, Java_NetworkInformation_getName(jni, j_network_info)); jni, GetStringField(jni, j_network_info, j_interface_name_id));
network_info.handle = static_cast<NetworkHandle>( network_info.handle = static_cast<NetworkHandle>(
Java_NetworkInformation_getHandle(jni, j_network_info)); GetLongField(jni, j_network_info, j_handle_id));
network_info.type = GetNetworkTypeFromJava( network_info.type = GetNetworkTypeFromJava(
jni, Java_NetworkInformation_getConnectionType(jni, j_network_info)); jni, GetObjectField(jni, j_network_info, j_type_id));
jobjectArray j_ip_addresses = jobjectArray j_ip_addresses = static_cast<jobjectArray>(
Java_NetworkInformation_getIpAddresses(jni, j_network_info); GetObjectField(jni, j_network_info, j_ip_addresses_id));
GetIPAddressesFromJava(jni, j_ip_addresses, &network_info.ip_addresses); GetIPAddressesFromJava(jni, j_ip_addresses, &network_info.ip_addresses);
return network_info; return network_info;
} }
@ -146,9 +161,25 @@ std::string NetworkInformation::ToString() const {
return ss.str(); return ss.str();
} }
AndroidNetworkMonitor::AndroidNetworkMonitor(JNIEnv* env) AndroidNetworkMonitor::AndroidNetworkMonitor()
: android_sdk_int_(Java_NetworkMonitor_androidSdkInt(env)), : j_network_monitor_class_(jni(),
j_network_monitor_(env, Java_NetworkMonitor_getInstance(env)) {} FindClass(jni(), "org/webrtc/NetworkMonitor")),
j_network_monitor_(
jni(),
jni()->CallStaticObjectMethod(
*j_network_monitor_class_,
GetStaticMethodID(jni(),
*j_network_monitor_class_,
"getInstance",
"()Lorg/webrtc/NetworkMonitor;"))) {
CHECK_EXCEPTION(jni()) << "Error during NetworkMonitor.init";
if (android_sdk_int_ <= 0) {
jmethodID m = GetStaticMethodID(jni(), *j_network_monitor_class_,
"androidSdkInt", "()I");
android_sdk_int_ = jni()->CallStaticIntMethod(*j_network_monitor_class_, m);
CHECK_EXCEPTION(jni()) << "Error during NetworkMonitor.androidSdkInt";
}
}
void AndroidNetworkMonitor::Start() { void AndroidNetworkMonitor::Start() {
RTC_CHECK(thread_checker_.CalledOnValidThread()); RTC_CHECK(thread_checker_.CalledOnValidThread());
@ -162,9 +193,10 @@ void AndroidNetworkMonitor::Start() {
// it creates sockets. // it creates sockets.
worker_thread()->socketserver()->set_network_binder(this); worker_thread()->socketserver()->set_network_binder(this);
JNIEnv* env = AttachCurrentThreadIfNeeded(); jmethodID m =
Java_NetworkMonitor_startMonitoring(env, *j_network_monitor_, GetMethodID(jni(), *j_network_monitor_class_, "startMonitoring", "(J)V");
jlongFromPointer(this)); jni()->CallVoidMethod(*j_network_monitor_, m, jlongFromPointer(this));
CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod";
} }
void AndroidNetworkMonitor::Stop() { void AndroidNetworkMonitor::Stop() {
@ -180,9 +212,10 @@ void AndroidNetworkMonitor::Stop() {
worker_thread()->socketserver()->set_network_binder(nullptr); worker_thread()->socketserver()->set_network_binder(nullptr);
} }
JNIEnv* env = AttachCurrentThreadIfNeeded(); jmethodID m =
Java_NetworkMonitor_stopMonitoring(env, *j_network_monitor_, GetMethodID(jni(), *j_network_monitor_class_, "stopMonitoring", "(J)V");
jlongFromPointer(this)); jni()->CallVoidMethod(*j_network_monitor_, m, jlongFromPointer(this));
CHECK_EXCEPTION(jni()) << "Error during NetworkMonitor.stopMonitoring";
network_handle_by_address_.clear(); network_handle_by_address_.clear();
network_info_by_handle_.clear(); network_info_by_handle_.clear();
@ -195,11 +228,14 @@ rtc::NetworkBindingResult AndroidNetworkMonitor::BindSocketToNetwork(
const rtc::IPAddress& address) { const rtc::IPAddress& address) {
RTC_CHECK(thread_checker_.CalledOnValidThread()); RTC_CHECK(thread_checker_.CalledOnValidThread());
jmethodID network_binding_supported_id = GetMethodID(
jni(), *j_network_monitor_class_, "networkBindingSupported", "()Z");
// Android prior to Lollipop didn't have support for binding sockets to // Android prior to Lollipop didn't have support for binding sockets to
// networks. This may also occur if there is no connectivity manager service. // networks. This may also occur if there is no connectivity manager service.
JNIEnv* env = AttachCurrentThreadIfNeeded(); bool network_binding_supported = jni()->CallBooleanMethod(
const bool network_binding_supported = *j_network_monitor_, network_binding_supported_id);
Java_NetworkMonitor_networkBindingSupported(env, *j_network_monitor_); CHECK_EXCEPTION(jni())
<< "Error during NetworkMonitor.networkBindingSupported";
if (!network_binding_supported) { if (!network_binding_supported) {
RTC_LOG(LS_WARNING) RTC_LOG(LS_WARNING)
<< "BindSocketToNetwork is not supported on this platform " << "BindSocketToNetwork is not supported on this platform "
@ -351,40 +387,60 @@ rtc::AdapterType AndroidNetworkMonitor::GetAdapterType(
rtc::NetworkMonitorInterface* rtc::NetworkMonitorInterface*
AndroidNetworkMonitorFactory::CreateNetworkMonitor() { AndroidNetworkMonitorFactory::CreateNetworkMonitor() {
return new AndroidNetworkMonitor(AttachCurrentThreadIfNeeded()); return new AndroidNetworkMonitor();
} }
void AndroidNetworkMonitor::NotifyConnectionTypeChanged(JNIEnv* env, JNI_FUNCTION_DECLARATION(void,
jobject j_caller) { NetworkMonitor_nativeNotifyConnectionTypeChanged,
OnNetworksChanged(); JNIEnv* jni,
jobject j_monitor,
jlong j_native_monitor) {
rtc::NetworkMonitorInterface* network_monitor =
reinterpret_cast<rtc::NetworkMonitorInterface*>(j_native_monitor);
network_monitor->OnNetworksChanged();
} }
void AndroidNetworkMonitor::NotifyOfActiveNetworkList( JNI_FUNCTION_DECLARATION(void,
JNIEnv* env, NetworkMonitor_nativeNotifyOfActiveNetworkList,
jobject j_caller, JNIEnv* jni,
jobject j_monitor,
jlong j_native_monitor,
jobjectArray j_network_infos) { jobjectArray j_network_infos) {
AndroidNetworkMonitor* network_monitor =
reinterpret_cast<AndroidNetworkMonitor*>(j_native_monitor);
std::vector<NetworkInformation> network_infos; std::vector<NetworkInformation> network_infos;
size_t num_networks = env->GetArrayLength(j_network_infos); size_t num_networks = jni->GetArrayLength(j_network_infos);
for (size_t i = 0; i < num_networks; ++i) { for (size_t i = 0; i < num_networks; ++i) {
jobject j_network_info = env->GetObjectArrayElement(j_network_infos, i); jobject j_network_info = jni->GetObjectArrayElement(j_network_infos, i);
CHECK_EXCEPTION(env) << "Error during GetObjectArrayElement"; CHECK_EXCEPTION(jni) << "Error during GetObjectArrayElement";
network_infos.push_back(GetNetworkInformationFromJava(env, j_network_info)); network_infos.push_back(GetNetworkInformationFromJava(jni, j_network_info));
} }
SetNetworkInfos(network_infos); network_monitor->SetNetworkInfos(network_infos);
} }
void AndroidNetworkMonitor::NotifyOfNetworkConnect(JNIEnv* env, JNI_FUNCTION_DECLARATION(void,
jobject j_caller, NetworkMonitor_nativeNotifyOfNetworkConnect,
JNIEnv* jni,
jobject j_monitor,
jlong j_native_monitor,
jobject j_network_info) { jobject j_network_info) {
AndroidNetworkMonitor* network_monitor =
reinterpret_cast<AndroidNetworkMonitor*>(j_native_monitor);
NetworkInformation network_info = NetworkInformation network_info =
GetNetworkInformationFromJava(env, j_network_info); GetNetworkInformationFromJava(jni, j_network_info);
OnNetworkConnected(network_info); network_monitor->OnNetworkConnected(network_info);
} }
void AndroidNetworkMonitor::NotifyOfNetworkDisconnect(JNIEnv* env, JNI_FUNCTION_DECLARATION(void,
jobject j_caller, NetworkMonitor_nativeNotifyOfNetworkDisconnect,
JNIEnv* jni,
jobject j_monitor,
jlong j_native_monitor,
jlong network_handle) { jlong network_handle) {
OnNetworkDisconnected(static_cast<NetworkHandle>(network_handle)); AndroidNetworkMonitor* network_monitor =
reinterpret_cast<AndroidNetworkMonitor*>(j_native_monitor);
network_monitor->OnNetworkDisconnected(
static_cast<NetworkHandle>(network_handle));
} }
} // namespace jni } // namespace jni

19
sdk/android/src/jni/pc/androidnetworkmonitor_jni.h
View File

@ -52,7 +52,7 @@ struct NetworkInformation {
class AndroidNetworkMonitor : public rtc::NetworkMonitorBase, class AndroidNetworkMonitor : public rtc::NetworkMonitorBase,
public rtc::NetworkBinderInterface { public rtc::NetworkBinderInterface {
public: public:
explicit AndroidNetworkMonitor(JNIEnv* env); AndroidNetworkMonitor();
// TODO(sakal): Remove once down stream dependencies have been updated. // TODO(sakal): Remove once down stream dependencies have been updated.
static void SetAndroidContext(JNIEnv* jni, jobject context) {} static void SetAndroidContext(JNIEnv* jni, jobject context) {}
@ -69,22 +69,15 @@ class AndroidNetworkMonitor : public rtc::NetworkMonitorBase,
// Always expected to be called on the network thread. // Always expected to be called on the network thread.
void SetNetworkInfos(const std::vector<NetworkInformation>& network_infos); void SetNetworkInfos(const std::vector<NetworkInformation>& network_infos);
void NotifyConnectionTypeChanged(JNIEnv* env, jobject j_caller);
void NotifyOfNetworkConnect(JNIEnv* env,
jobject j_caller,
jobject j_network_info);
void NotifyOfNetworkDisconnect(JNIEnv* env,
jobject j_caller,
jlong network_handle);
void NotifyOfActiveNetworkList(JNIEnv* env,
jobject j_caller,
jobjectArray j_network_infos);
private: private:
static jobject application_context_;
static int android_sdk_int_;
JNIEnv* jni() { return AttachCurrentThreadIfNeeded(); }
void OnNetworkConnected_w(const NetworkInformation& network_info); void OnNetworkConnected_w(const NetworkInformation& network_info);
void OnNetworkDisconnected_w(NetworkHandle network_handle); void OnNetworkDisconnected_w(NetworkHandle network_handle);
const int android_sdk_int_; ScopedGlobalRef<jclass> j_network_monitor_class_;
ScopedGlobalRef<jobject> j_network_monitor_; ScopedGlobalRef<jobject> j_network_monitor_;
rtc::ThreadChecker thread_checker_; rtc::ThreadChecker thread_checker_;
bool started_ = false; bool started_ = false;