services/jni/com_android_server_UsbDeviceManager.cpp

   1 /*
   2  * Copyright (C) 2010 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 "UsbDeviceManagerJNI"
  18 #include "utils/Log.h"
  19
  20 #include "jni.h"
  21 #include "JNIHelp.h"
  22 #include "android_runtime/AndroidRuntime.h"
  23
  24 #include <stdio.h>
  25 #include <asm/byteorder.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29 #include <sys/ioctl.h>
  30 #include <linux/usb/f_accessory.h>
  31
  32 #define DRIVER_NAME "/dev/usb_accessory"
  33
  34 namespace android
  35 {
  36
  37 static struct parcel_file_descriptor_offsets_t
  38 {
  39     jclass mClass;
  40     jmethodID mConstructor;
  41 } gParcelFileDescriptorOffsets;
  42
  43 static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
  44     if (env->ExceptionCheck()) {
  45         ALOGE("An exception was thrown by callback '%s'.", methodName);
  46         LOGE_EX(env);
  47         env->ExceptionClear();
  48     }
  49 }
  50
  51 static void set_accessory_string(JNIEnv *env, int fd, int cmd, jobjectArray strArray, int index)
  52 {
  53     char buffer[256];
  54
  55     buffer[0] = 0;
  56     int length = ioctl(fd, cmd, buffer);
  57     if (buffer[0]) {
  58         jstring obj = env->NewStringUTF(buffer);
  59         env->SetObjectArrayElement(strArray, index, obj);
  60         env->DeleteLocalRef(obj);
  61     }
  62 }
  63
  64
  65 static jobjectArray android_server_UsbDeviceManager_getAccessoryStrings(JNIEnv *env, jobject thiz)
  66 {
  67     int fd = open(DRIVER_NAME, O_RDWR);
  68     if (fd < 0) {
  69         ALOGE("could not open %s", DRIVER_NAME);
  70         return NULL;
  71     }
  72     jclass stringClass = env->FindClass("java/lang/String");
  73     jobjectArray strArray = env->NewObjectArray(6, stringClass, NULL);
  74     if (!strArray) goto out;
  75     set_accessory_string(env, fd, ACCESSORY_GET_STRING_MANUFACTURER, strArray, 0);
  76     set_accessory_string(env, fd, ACCESSORY_GET_STRING_MODEL, strArray, 1);
  77     set_accessory_string(env, fd, ACCESSORY_GET_STRING_DESCRIPTION, strArray, 2);
  78     set_accessory_string(env, fd, ACCESSORY_GET_STRING_VERSION, strArray, 3);
  79     set_accessory_string(env, fd, ACCESSORY_GET_STRING_URI, strArray, 4);
  80     set_accessory_string(env, fd, ACCESSORY_GET_STRING_SERIAL, strArray, 5);
  81
  82 out:
  83     close(fd);
  84     return strArray;
  85 }
  86
  87 static jobject android_server_UsbDeviceManager_openAccessory(JNIEnv *env, jobject thiz)
  88 {
  89     int fd = open(DRIVER_NAME, O_RDWR);
  90     if (fd < 0) {
  91         ALOGE("could not open %s", DRIVER_NAME);
  92         return NULL;
  93     }
  94     jobject fileDescriptor = jniCreateFileDescriptor(env, fd);
  95     if (fileDescriptor == NULL) {
  96         return NULL;
  97     }
  98     return env->NewObject(gParcelFileDescriptorOffsets.mClass,
  99         gParcelFileDescriptorOffsets.mConstructor, fileDescriptor);
 100 }
 101
 102 static jboolean android_server_UsbDeviceManager_isStartRequested(JNIEnv *env, jobject thiz)
 103 {
 104     int fd = open(DRIVER_NAME, O_RDWR);
 105     if (fd < 0) {
 106         ALOGE("could not open %s", DRIVER_NAME);
 107         return false;
 108     }
 109     int result = ioctl(fd, ACCESSORY_IS_START_REQUESTED);
 110     close(fd);
 111     return (result == 1);
 112 }
 113
 114 static jint android_server_UsbDeviceManager_getAudioMode(JNIEnv *env, jobject thiz)
 115 {
 116     int fd = open(DRIVER_NAME, O_RDWR);
 117     if (fd < 0) {
 118         ALOGE("could not open %s", DRIVER_NAME);
 119         return false;
 120     }
 121     int result = ioctl(fd, ACCESSORY_GET_AUDIO_MODE);
 122     close(fd);
 123     return result;
 124 }
 125
 126 static JNINativeMethod method_table[] = {
 127     { "nativeGetAccessoryStrings",  "()[Ljava/lang/String;",
 128                                     (void*)android_server_UsbDeviceManager_getAccessoryStrings },
 129     { "nativeOpenAccessory",        "()Landroid/os/ParcelFileDescriptor;",
 130                                     (void*)android_server_UsbDeviceManager_openAccessory },
 131     { "nativeIsStartRequested",     "()Z",
 132                                     (void*)android_server_UsbDeviceManager_isStartRequested },
 133     { "nativeGetAudioMode",         "()I",
 134                                     (void*)android_server_UsbDeviceManager_getAudioMode },
 135 };
 136
 137 int register_android_server_UsbDeviceManager(JNIEnv *env)
 138 {
 139     jclass clazz = env->FindClass("com/android/server/usb/UsbDeviceManager");
 140     if (clazz == NULL) {
 141         ALOGE("Can't find com/android/server/usb/UsbDeviceManager");
 142         return -1;
 143     }
 144
 145     clazz = env->FindClass("android/os/ParcelFileDescriptor");
 146     LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.ParcelFileDescriptor");
 147     gParcelFileDescriptorOffsets.mClass = (jclass) env->NewGlobalRef(clazz);
 148     gParcelFileDescriptorOffsets.mConstructor = env->GetMethodID(clazz, "<init>", "(Ljava/io/FileDescriptor;)V");
 149     LOG_FATAL_IF(gParcelFileDescriptorOffsets.mConstructor == NULL,
 150                  "Unable to find constructor for android.os.ParcelFileDescriptor");
 151
 152     return jniRegisterNativeMethods(env, "com/android/server/usb/UsbDeviceManager",
 153             method_table, NELEM(method_table));
 154 }
 155
 156 };