core/jni/android_hardware_UsbDeviceConnection.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "UsbDeviceConnectionJNI"

 #include "utils/Log.h"

 #include "jni.h"
 #include <nativehelper/JNIHelp.h>
 #include "core_jni_helpers.h"

 #include <usbhost/usbhost.h>

 #include <chrono>

 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>

 using namespace android;
 using namespace std::chrono;

 static const int USB_CONTROL_READ_TIMEOUT_MS = 200;

 static jfieldID field_context;

 struct usb_device* get_device_from_object(JNIEnv* env, jobject connection)
 {
     return (struct usb_device*)env->GetLongField(connection, field_context);
 }

 static jboolean
 android_hardware_UsbDeviceConnection_open(JNIEnv *env, jobject thiz, jstring deviceName,
         jobject fileDescriptor)
 {
     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
     // duplicate the file descriptor, since ParcelFileDescriptor will eventually close its copy
     fd = dup(fd);
     if (fd < 0)
         return JNI_FALSE;

     const char *deviceNameStr = env->GetStringUTFChars(deviceName, NULL);
     struct usb_device* device = usb_device_new(deviceNameStr, fd);
     if (device) {
         env->SetLongField(thiz, field_context, (jlong)device);
     } else {
         ALOGE("usb_device_open failed for %s", deviceNameStr);
         close(fd);
     }

     env->ReleaseStringUTFChars(deviceName, deviceNameStr);
     return (device != NULL) ? JNI_TRUE : JNI_FALSE;
 }

 static void
 android_hardware_UsbDeviceConnection_close(JNIEnv *env, jobject thiz)
 {
     ALOGD("close\n");
     struct usb_device* device = get_device_from_object(env, thiz);
     if (device) {
         usb_device_close(device);
         env->SetLongField(thiz, field_context, 0);
     }
 }

 static jint
 android_hardware_UsbDeviceConnection_get_fd(JNIEnv *env, jobject thiz)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_get_fd");
         return -1;
     }
     return usb_device_get_fd(device);
 }

 static jbyteArray
 android_hardware_UsbDeviceConnection_get_desc(JNIEnv *env, jobject thiz)
 {
     char buffer[16384];
     int fd = android_hardware_UsbDeviceConnection_get_fd(env, thiz);
     if (fd < 0) return NULL;
     lseek(fd, 0, SEEK_SET);
     int length = read(fd, buffer, sizeof(buffer));
     if (length < 0) return NULL;

     jbyteArray ret = env->NewByteArray(length);
     if (ret) {
         jbyte* bytes = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
         if (bytes) {
             memcpy(bytes, buffer, length);
             env->ReleasePrimitiveArrayCritical(ret, bytes, 0);
         }
     }
     return ret;
 }

 static jboolean
 android_hardware_UsbDeviceConnection_claim_interface(JNIEnv *env, jobject thiz,
         jint interfaceID, jboolean force)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_claim_interface");
         return JNI_FALSE;
     }

     int ret = usb_device_claim_interface(device, interfaceID);
     if (ret && force && errno == EBUSY) {
         // disconnect kernel driver and try again
         usb_device_connect_kernel_driver(device, interfaceID, false);
         ret = usb_device_claim_interface(device, interfaceID);
     }
     return (ret == 0) ? JNI_TRUE : JNI_FALSE;
 }

 static jboolean
 android_hardware_UsbDeviceConnection_release_interface(JNIEnv *env, jobject thiz, jint interfaceID)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_release_interface");
         return JNI_FALSE;
     }
     int ret = usb_device_release_interface(device, interfaceID);
     if (ret == 0) {
         // allow kernel to reconnect its driver
         usb_device_connect_kernel_driver(device, interfaceID, true);
     }
     return (ret == 0) ? JNI_TRUE : JNI_FALSE;
 }

 static jboolean
 android_hardware_UsbDeviceConnection_set_interface(JNIEnv *env, jobject thiz, jint interfaceID,
         jint alternateSetting)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_set_interface");
         return JNI_FALSE;
     }
     int ret = usb_device_set_interface(device, interfaceID, alternateSetting);
     return (ret == 0) ? JNI_TRUE : JNI_FALSE;
 }

 static jboolean
 android_hardware_UsbDeviceConnection_set_configuration(JNIEnv *env, jobject thiz, jint configurationID)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_set_configuration");
         return JNI_FALSE;
     }
     int ret = usb_device_set_configuration(device, configurationID);
     return (ret == 0) ? JNI_TRUE : JNI_FALSE;
 }

 static jint
 android_hardware_UsbDeviceConnection_control_request(JNIEnv *env, jobject thiz,
         jint requestType, jint request, jint value, jint index,
         jbyteArray buffer, jint start, jint length, jint timeout)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_control_request");
         return -1;
     }

     jbyte* bufferBytes = NULL;
     if (buffer) {
         bufferBytes = (jbyte*)env->GetPrimitiveArrayCritical(buffer, NULL);
     }

     jint result = usb_device_control_transfer(device, requestType, request,
             value, index, bufferBytes + start, length, timeout);

     if (bufferBytes) {
         env->ReleasePrimitiveArrayCritical(buffer, bufferBytes, 0);
     }

     return result;
 }

 static jint
 android_hardware_UsbDeviceConnection_bulk_request(JNIEnv *env, jobject thiz,
         jint endpoint, jbyteArray buffer, jint start, jint length, jint timeout)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_control_request");
         return -1;
     }

     jbyte* bufferBytes = NULL;
     if (buffer) {
         bufferBytes = (jbyte*)env->GetPrimitiveArrayCritical(buffer, NULL);
     }

     jint result = usb_device_bulk_transfer(device, endpoint, bufferBytes + start, length, timeout);

     if (bufferBytes) {
         env->ReleasePrimitiveArrayCritical(buffer, bufferBytes, 0);
     }

     return result;
 }

 static jobject
 android_hardware_UsbDeviceConnection_request_wait(JNIEnv *env, jobject thiz, jlong timeoutMillis)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_request_wait");
         return NULL;
     }

     struct usb_request* request;
     if (timeoutMillis == -1) {
         request = usb_request_wait(device, -1);
     } else {
         steady_clock::time_point currentTime = steady_clock::now();
         steady_clock::time_point endTime = currentTime + std::chrono::milliseconds(timeoutMillis);

         // Poll the existence of a request via usb_request_wait until we get a result, an unexpected
         // error or time out. As several threads can listen on the same fd, we might get wakeups
         // without data.
         while (1) {
             request = usb_request_wait(device, duration_cast<std::chrono::milliseconds>(endTime
                                - currentTime).count());

             int error = errno;
             if (request != NULL) {
                 break;
             }

             currentTime = steady_clock::now();
             if (currentTime >= endTime) {
                 jniThrowException(env, "java/util/concurrent/TimeoutException", "");
                 break;
             }

             if (error != EAGAIN) {
                 break;
             }
         };
     }

     if (request) {
         return (jobject)request->client_data;
     } else {
         return NULL;
     }
 }

 static jstring
 android_hardware_UsbDeviceConnection_get_serial(JNIEnv *env, jobject thiz)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_get_serial");
         return NULL;
     }
     char* serial = usb_device_get_serial(device,
             USB_CONTROL_READ_TIMEOUT_MS);
     if (!serial)
         return NULL;
     jstring result = env->NewStringUTF(serial);
     free(serial);
     return result;
 }

 static jboolean
 android_hardware_UsbDeviceConnection_reset_device(JNIEnv *env, jobject thiz)
 {
     struct usb_device* device = get_device_from_object(env, thiz);
     if (!device) {
         ALOGE("device is closed in native_reset_device");
         return JNI_FALSE;
     }
     int ret = usb_device_reset(device);
     return (ret == 0) ? JNI_TRUE : JNI_FALSE;
 }

 static const JNINativeMethod method_table[] = {
     {"native_open",             "(Ljava/lang/String;Ljava/io/FileDescriptor;)Z",
                                         (void *)android_hardware_UsbDeviceConnection_open},
     {"native_close",            "()V",  (void *)android_hardware_UsbDeviceConnection_close},
     {"native_get_fd",           "()I",  (void *)android_hardware_UsbDeviceConnection_get_fd},
     {"native_get_desc",         "()[B", (void *)android_hardware_UsbDeviceConnection_get_desc},
     {"native_claim_interface",  "(IZ)Z",(void *)android_hardware_UsbDeviceConnection_claim_interface},
     {"native_release_interface","(I)Z", (void *)android_hardware_UsbDeviceConnection_release_interface},
     {"native_set_interface","(II)Z",    (void *)android_hardware_UsbDeviceConnection_set_interface},
     {"native_set_configuration","(I)Z", (void *)android_hardware_UsbDeviceConnection_set_configuration},
     {"native_control_request",  "(IIII[BIII)I",
                                         (void *)android_hardware_UsbDeviceConnection_control_request},
     {"native_bulk_request",     "(I[BIII)I",
                                         (void *)android_hardware_UsbDeviceConnection_bulk_request},
     {"native_request_wait",             "(J)Landroid/hardware/usb/UsbRequest;",
                                         (void *)android_hardware_UsbDeviceConnection_request_wait},
     { "native_get_serial",      "()Ljava/lang/String;",
                                         (void*)android_hardware_UsbDeviceConnection_get_serial },
     {"native_reset_device","()Z", (void *)android_hardware_UsbDeviceConnection_reset_device},
 };

 int register_android_hardware_UsbDeviceConnection(JNIEnv *env)
 {
     jclass clazz = FindClassOrDie(env, "android/hardware/usb/UsbDeviceConnection");
     field_context = GetFieldIDOrDie(env, clazz, "mNativeContext", "J");

     return RegisterMethodsOrDie(env, "android/hardware/usb/UsbDeviceConnection",
             method_table, NELEM(method_table));
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "UsbDeviceConnectionJNI"

	#include "utils/Log.h"

	#include "jni.h"
	#include <nativehelper/JNIHelp.h>
	#include "core_jni_helpers.h"

	#include <usbhost/usbhost.h>

	#include <chrono>

	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>

	using namespace android;
	using namespace std::chrono;

	static const int USB_CONTROL_READ_TIMEOUT_MS = 200;

	static jfieldID field_context;

	struct usb_device* get_device_from_object(JNIEnv* env, jobject connection)
	{
	return (struct usb_device*)env->GetLongField(connection, field_context);
	}

	static jboolean
	android_hardware_UsbDeviceConnection_open(JNIEnv *env, jobject thiz, jstring deviceName,
	jobject fileDescriptor)
	{
	int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
	// duplicate the file descriptor, since ParcelFileDescriptor will eventually close its copy
	fd = dup(fd);
	if (fd < 0)
	return JNI_FALSE;

	const char *deviceNameStr = env->GetStringUTFChars(deviceName, NULL);
	struct usb_device* device = usb_device_new(deviceNameStr, fd);
	if (device) {
	env->SetLongField(thiz, field_context, (jlong)device);
	} else {
	ALOGE("usb_device_open failed for %s", deviceNameStr);
	close(fd);
	}

	env->ReleaseStringUTFChars(deviceName, deviceNameStr);
	return (device != NULL) ? JNI_TRUE : JNI_FALSE;
	}

	static void
	android_hardware_UsbDeviceConnection_close(JNIEnv *env, jobject thiz)
	{
	ALOGD("close\n");
	struct usb_device* device = get_device_from_object(env, thiz);
	if (device) {
	usb_device_close(device);
	env->SetLongField(thiz, field_context, 0);
	}
	}

	static jint
	android_hardware_UsbDeviceConnection_get_fd(JNIEnv *env, jobject thiz)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_get_fd");
	return -1;
	}
	return usb_device_get_fd(device);
	}

	static jbyteArray
	android_hardware_UsbDeviceConnection_get_desc(JNIEnv *env, jobject thiz)
	{
	char buffer[16384];
	int fd = android_hardware_UsbDeviceConnection_get_fd(env, thiz);
	if (fd < 0) return NULL;
	lseek(fd, 0, SEEK_SET);
	int length = read(fd, buffer, sizeof(buffer));
	if (length < 0) return NULL;

	jbyteArray ret = env->NewByteArray(length);
	if (ret) {
	jbyte* bytes = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
	if (bytes) {
	memcpy(bytes, buffer, length);
	env->ReleasePrimitiveArrayCritical(ret, bytes, 0);
	}
	}
	return ret;
	}

	static jboolean
	android_hardware_UsbDeviceConnection_claim_interface(JNIEnv *env, jobject thiz,
	jint interfaceID, jboolean force)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_claim_interface");
	return JNI_FALSE;
	}

	int ret = usb_device_claim_interface(device, interfaceID);
	if (ret && force && errno == EBUSY) {
	// disconnect kernel driver and try again
	usb_device_connect_kernel_driver(device, interfaceID, false);
	ret = usb_device_claim_interface(device, interfaceID);
	}
	return (ret == 0) ? JNI_TRUE : JNI_FALSE;
	}

	static jboolean
	android_hardware_UsbDeviceConnection_release_interface(JNIEnv *env, jobject thiz, jint interfaceID)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_release_interface");
	return JNI_FALSE;
	}
	int ret = usb_device_release_interface(device, interfaceID);
	if (ret == 0) {
	// allow kernel to reconnect its driver
	usb_device_connect_kernel_driver(device, interfaceID, true);
	}
	return (ret == 0) ? JNI_TRUE : JNI_FALSE;
	}

	static jboolean
	android_hardware_UsbDeviceConnection_set_interface(JNIEnv *env, jobject thiz, jint interfaceID,
	jint alternateSetting)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_set_interface");
	return JNI_FALSE;
	}
	int ret = usb_device_set_interface(device, interfaceID, alternateSetting);
	return (ret == 0) ? JNI_TRUE : JNI_FALSE;
	}

	static jboolean
	android_hardware_UsbDeviceConnection_set_configuration(JNIEnv *env, jobject thiz, jint configurationID)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_set_configuration");
	return JNI_FALSE;
	}
	int ret = usb_device_set_configuration(device, configurationID);
	return (ret == 0) ? JNI_TRUE : JNI_FALSE;
	}

	static jint
	android_hardware_UsbDeviceConnection_control_request(JNIEnv *env, jobject thiz,
	jint requestType, jint request, jint value, jint index,
	jbyteArray buffer, jint start, jint length, jint timeout)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_control_request");
	return -1;
	}

	jbyte* bufferBytes = NULL;
	if (buffer) {
	bufferBytes = (jbyte*)env->GetPrimitiveArrayCritical(buffer, NULL);
	}

	jint result = usb_device_control_transfer(device, requestType, request,
	value, index, bufferBytes + start, length, timeout);

	if (bufferBytes) {
	env->ReleasePrimitiveArrayCritical(buffer, bufferBytes, 0);
	}

	return result;
	}

	static jint
	android_hardware_UsbDeviceConnection_bulk_request(JNIEnv *env, jobject thiz,
	jint endpoint, jbyteArray buffer, jint start, jint length, jint timeout)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_control_request");
	return -1;
	}

	jbyte* bufferBytes = NULL;
	if (buffer) {
	bufferBytes = (jbyte*)env->GetPrimitiveArrayCritical(buffer, NULL);
	}

	jint result = usb_device_bulk_transfer(device, endpoint, bufferBytes + start, length, timeout);

	if (bufferBytes) {
	env->ReleasePrimitiveArrayCritical(buffer, bufferBytes, 0);
	}

	return result;
	}

	static jobject
	android_hardware_UsbDeviceConnection_request_wait(JNIEnv *env, jobject thiz, jlong timeoutMillis)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_request_wait");
	return NULL;
	}

	struct usb_request* request;
	if (timeoutMillis == -1) {
	request = usb_request_wait(device, -1);
	} else {
	steady_clock::time_point currentTime = steady_clock::now();
	steady_clock::time_point endTime = currentTime + std::chrono::milliseconds(timeoutMillis);

	// Poll the existence of a request via usb_request_wait until we get a result, an unexpected
	// error or time out. As several threads can listen on the same fd, we might get wakeups
	// without data.
	while (1) {
	request = usb_request_wait(device, duration_cast<std::chrono::milliseconds>(endTime
	- currentTime).count());

	int error = errno;
	if (request != NULL) {
	break;
	}

	currentTime = steady_clock::now();
	if (currentTime >= endTime) {
	jniThrowException(env, "java/util/concurrent/TimeoutException", "");
	break;
	}

	if (error != EAGAIN) {
	break;
	}
	};
	}

	if (request) {
	return (jobject)request->client_data;
	} else {
	return NULL;
	}
	}

	static jstring
	android_hardware_UsbDeviceConnection_get_serial(JNIEnv *env, jobject thiz)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_get_serial");
	return NULL;
	}
	char* serial = usb_device_get_serial(device,
	USB_CONTROL_READ_TIMEOUT_MS);
	if (!serial)
	return NULL;
	jstring result = env->NewStringUTF(serial);
	free(serial);
	return result;
	}

	static jboolean
	android_hardware_UsbDeviceConnection_reset_device(JNIEnv *env, jobject thiz)
	{
	struct usb_device* device = get_device_from_object(env, thiz);
	if (!device) {
	ALOGE("device is closed in native_reset_device");
	return JNI_FALSE;
	}
	int ret = usb_device_reset(device);
	return (ret == 0) ? JNI_TRUE : JNI_FALSE;
	}

	static const JNINativeMethod method_table[] = {
	{"native_open", "(Ljava/lang/String;Ljava/io/FileDescriptor;)Z",
	(void *)android_hardware_UsbDeviceConnection_open},
	{"native_close", "()V", (void *)android_hardware_UsbDeviceConnection_close},
	{"native_get_fd", "()I", (void *)android_hardware_UsbDeviceConnection_get_fd},
	{"native_get_desc", "()[B", (void *)android_hardware_UsbDeviceConnection_get_desc},
	{"native_claim_interface", "(IZ)Z",(void *)android_hardware_UsbDeviceConnection_claim_interface},
	{"native_release_interface","(I)Z", (void *)android_hardware_UsbDeviceConnection_release_interface},
	{"native_set_interface","(II)Z", (void *)android_hardware_UsbDeviceConnection_set_interface},
	{"native_set_configuration","(I)Z", (void *)android_hardware_UsbDeviceConnection_set_configuration},
	{"native_control_request", "(IIII[BIII)I",
	(void *)android_hardware_UsbDeviceConnection_control_request},
	{"native_bulk_request", "(I[BIII)I",
	(void *)android_hardware_UsbDeviceConnection_bulk_request},
	{"native_request_wait", "(J)Landroid/hardware/usb/UsbRequest;",
	(void *)android_hardware_UsbDeviceConnection_request_wait},
	{ "native_get_serial", "()Ljava/lang/String;",
	(void*)android_hardware_UsbDeviceConnection_get_serial },
	{"native_reset_device","()Z", (void *)android_hardware_UsbDeviceConnection_reset_device},
	};

	int register_android_hardware_UsbDeviceConnection(JNIEnv *env)
	{
	jclass clazz = FindClassOrDie(env, "android/hardware/usb/UsbDeviceConnection");
	field_context = GetFieldIDOrDie(env, clazz, "mNativeContext", "J");

	return RegisterMethodsOrDie(env, "android/hardware/usb/UsbDeviceConnection",
	method_table, NELEM(method_table));
	}