1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "UsbDeviceConnectionJNI" 18 19 #include "utils/Log.h" 20 21 #include "jni.h" 22 #include "JNIHelp.h" 23 #include "core_jni_helpers.h" 24 25 #include <usbhost/usbhost.h> 26 27 #include <stdio.h> 28 #include <sys/types.h> 29 #include <sys/stat.h> 30 #include <fcntl.h> 31 32 using namespace android; 33 34 static jfieldID field_context; 35 36 struct usb_device* get_device_from_object(JNIEnv* env, jobject connection) 37 { 38 return (struct usb_device*)env->GetLongField(connection, field_context); 39 } 40 41 static jboolean 42 android_hardware_UsbDeviceConnection_open(JNIEnv *env, jobject thiz, jstring deviceName, 43 jobject fileDescriptor) 44 { 45 int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); 46 // duplicate the file descriptor, since ParcelFileDescriptor will eventually close its copy 47 fd = dup(fd); 48 if (fd < 0) 49 return JNI_FALSE; 50 51 const char *deviceNameStr = env->GetStringUTFChars(deviceName, NULL); 52 struct usb_device* device = usb_device_new(deviceNameStr, fd); 53 if (device) { 54 env->SetLongField(thiz, field_context, (jlong)device); 55 } else { 56 ALOGE("usb_device_open failed for %s", deviceNameStr); 57 close(fd); 58 } 59 60 env->ReleaseStringUTFChars(deviceName, deviceNameStr); 61 return (device != NULL) ? JNI_TRUE : JNI_FALSE; 62 } 63 64 static void 65 android_hardware_UsbDeviceConnection_close(JNIEnv *env, jobject thiz) 66 { 67 ALOGD("close\n"); 68 struct usb_device* device = get_device_from_object(env, thiz); 69 if (device) { 70 usb_device_close(device); 71 env->SetLongField(thiz, field_context, 0); 72 } 73 } 74 75 static jint 76 android_hardware_UsbDeviceConnection_get_fd(JNIEnv *env, jobject thiz) 77 { 78 struct usb_device* device = get_device_from_object(env, thiz); 79 if (!device) { 80 ALOGE("device is closed in native_get_fd"); 81 return -1; 82 } 83 return usb_device_get_fd(device); 84 } 85 86 static jbyteArray 87 android_hardware_UsbDeviceConnection_get_desc(JNIEnv *env, jobject thiz) 88 { 89 char buffer[16384]; 90 int fd = android_hardware_UsbDeviceConnection_get_fd(env, thiz); 91 if (fd < 0) return NULL; 92 lseek(fd, 0, SEEK_SET); 93 int length = read(fd, buffer, sizeof(buffer)); 94 if (length < 0) return NULL; 95 96 jbyteArray ret = env->NewByteArray(length); 97 if (ret) { 98 jbyte* bytes = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0); 99 if (bytes) { 100 memcpy(bytes, buffer, length); 101 env->ReleasePrimitiveArrayCritical(ret, bytes, 0); 102 } 103 } 104 return ret; 105 } 106 107 static jboolean 108 android_hardware_UsbDeviceConnection_claim_interface(JNIEnv *env, jobject thiz, 109 jint interfaceID, jboolean force) 110 { 111 struct usb_device* device = get_device_from_object(env, thiz); 112 if (!device) { 113 ALOGE("device is closed in native_claim_interface"); 114 return JNI_FALSE; 115 } 116 117 int ret = usb_device_claim_interface(device, interfaceID); 118 if (ret && force && errno == EBUSY) { 119 // disconnect kernel driver and try again 120 usb_device_connect_kernel_driver(device, interfaceID, false); 121 ret = usb_device_claim_interface(device, interfaceID); 122 } 123 return (ret == 0) ? JNI_TRUE : JNI_FALSE; 124 } 125 126 static jboolean 127 android_hardware_UsbDeviceConnection_release_interface(JNIEnv *env, jobject thiz, jint interfaceID) 128 { 129 struct usb_device* device = get_device_from_object(env, thiz); 130 if (!device) { 131 ALOGE("device is closed in native_release_interface"); 132 return JNI_FALSE; 133 } 134 int ret = usb_device_release_interface(device, interfaceID); 135 if (ret == 0) { 136 // allow kernel to reconnect its driver 137 usb_device_connect_kernel_driver(device, interfaceID, true); 138 } 139 return (ret == 0) ? JNI_TRUE : JNI_FALSE; 140 } 141 142 static jboolean 143 android_hardware_UsbDeviceConnection_set_interface(JNIEnv *env, jobject thiz, jint interfaceID, 144 jint alternateSetting) 145 { 146 struct usb_device* device = get_device_from_object(env, thiz); 147 if (!device) { 148 ALOGE("device is closed in native_set_interface"); 149 return JNI_FALSE; 150 } 151 int ret = usb_device_set_interface(device, interfaceID, alternateSetting); 152 return (ret == 0) ? JNI_TRUE : JNI_FALSE; 153 } 154 155 static jboolean 156 android_hardware_UsbDeviceConnection_set_configuration(JNIEnv *env, jobject thiz, jint configurationID) 157 { 158 struct usb_device* device = get_device_from_object(env, thiz); 159 if (!device) { 160 ALOGE("device is closed in native_set_configuration"); 161 return JNI_FALSE; 162 } 163 int ret = usb_device_set_configuration(device, configurationID); 164 return (ret == 0) ? JNI_TRUE : JNI_FALSE; 165 } 166 167 static jint 168 android_hardware_UsbDeviceConnection_control_request(JNIEnv *env, jobject thiz, 169 jint requestType, jint request, jint value, jint index, 170 jbyteArray buffer, jint start, jint length, jint timeout) 171 { 172 struct usb_device* device = get_device_from_object(env, thiz); 173 if (!device) { 174 ALOGE("device is closed in native_control_request"); 175 return -1; 176 } 177 178 jbyte* bufferBytes = NULL; 179 if (buffer) { 180 bufferBytes = (jbyte*)env->GetPrimitiveArrayCritical(buffer, NULL); 181 } 182 183 jint result = usb_device_control_transfer(device, requestType, request, 184 value, index, bufferBytes + start, length, timeout); 185 186 if (bufferBytes) { 187 env->ReleasePrimitiveArrayCritical(buffer, bufferBytes, 0); 188 } 189 190 return result; 191 } 192 193 static jint 194 android_hardware_UsbDeviceConnection_bulk_request(JNIEnv *env, jobject thiz, 195 jint endpoint, jbyteArray buffer, jint start, jint length, jint timeout) 196 { 197 struct usb_device* device = get_device_from_object(env, thiz); 198 if (!device) { 199 ALOGE("device is closed in native_control_request"); 200 return -1; 201 } 202 203 jbyte* bufferBytes = NULL; 204 if (buffer) { 205 bufferBytes = (jbyte*)env->GetPrimitiveArrayCritical(buffer, NULL); 206 } 207 208 jint result = usb_device_bulk_transfer(device, endpoint, bufferBytes + start, length, timeout); 209 210 if (bufferBytes) { 211 env->ReleasePrimitiveArrayCritical(buffer, bufferBytes, 0); 212 } 213 214 return result; 215 } 216 217 static jobject 218 android_hardware_UsbDeviceConnection_request_wait(JNIEnv *env, jobject thiz) 219 { 220 struct usb_device* device = get_device_from_object(env, thiz); 221 if (!device) { 222 ALOGE("device is closed in native_request_wait"); 223 return NULL; 224 } 225 226 struct usb_request* request = usb_request_wait(device); 227 if (request) 228 return (jobject)request->client_data; 229 else 230 return NULL; 231 } 232 233 static jstring 234 android_hardware_UsbDeviceConnection_get_serial(JNIEnv *env, jobject thiz) 235 { 236 struct usb_device* device = get_device_from_object(env, thiz); 237 if (!device) { 238 ALOGE("device is closed in native_request_wait"); 239 return NULL; 240 } 241 char* serial = usb_device_get_serial(device); 242 if (!serial) 243 return NULL; 244 jstring result = env->NewStringUTF(serial); 245 free(serial); 246 return result; 247 } 248 249 static const JNINativeMethod method_table[] = { 250 {"native_open", "(Ljava/lang/String;Ljava/io/FileDescriptor;)Z", 251 (void *)android_hardware_UsbDeviceConnection_open}, 252 {"native_close", "()V", (void *)android_hardware_UsbDeviceConnection_close}, 253 {"native_get_fd", "()I", (void *)android_hardware_UsbDeviceConnection_get_fd}, 254 {"native_get_desc", "()[B", (void *)android_hardware_UsbDeviceConnection_get_desc}, 255 {"native_claim_interface", "(IZ)Z",(void *)android_hardware_UsbDeviceConnection_claim_interface}, 256 {"native_release_interface","(I)Z", (void *)android_hardware_UsbDeviceConnection_release_interface}, 257 {"native_set_interface","(II)Z", (void *)android_hardware_UsbDeviceConnection_set_interface}, 258 {"native_set_configuration","(I)Z", (void *)android_hardware_UsbDeviceConnection_set_configuration}, 259 {"native_control_request", "(IIII[BIII)I", 260 (void *)android_hardware_UsbDeviceConnection_control_request}, 261 {"native_bulk_request", "(I[BIII)I", 262 (void *)android_hardware_UsbDeviceConnection_bulk_request}, 263 {"native_request_wait", "()Landroid/hardware/usb/UsbRequest;", 264 (void *)android_hardware_UsbDeviceConnection_request_wait}, 265 { "native_get_serial", "()Ljava/lang/String;", 266 (void*)android_hardware_UsbDeviceConnection_get_serial }, 267 }; 268 269 int register_android_hardware_UsbDeviceConnection(JNIEnv *env) 270 { 271 jclass clazz = FindClassOrDie(env, "android/hardware/usb/UsbDeviceConnection"); 272 field_context = GetFieldIDOrDie(env, clazz, "mNativeContext", "J"); 273 274 return RegisterMethodsOrDie(env, "android/hardware/usb/UsbDeviceConnection", 275 method_table, NELEM(method_table)); 276 } 277
