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 <nativehelper/JNIPlatformHelp.h>
22 #include <nativehelper/ScopedUtfChars.h>
23 #include "android_runtime/AndroidRuntime.h"
24 #include "android_runtime/Log.h"
25 #include "MtpDescriptors.h"
26 
27 #include <stdio.h>
28 #include <asm/byteorder.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <fcntl.h>
32 #include <sys/ioctl.h>
33 #include <linux/usb/f_accessory.h>
34 
35 #define DRIVER_NAME "/dev/usb_accessory"
36 
37 namespace android
38 {
39 
40 static struct parcel_file_descriptor_offsets_t
41 {
42     jclass mClass;
43     jmethodID mConstructor;
44 } gParcelFileDescriptorOffsets;
45 
set_accessory_string(JNIEnv * env,int fd,int cmd,jobjectArray strArray,int index)46 static void set_accessory_string(JNIEnv *env, int fd, int cmd, jobjectArray strArray, int index)
47 {
48     char buffer[256];
49 
50     buffer[0] = 0;
51     ioctl(fd, cmd, buffer);
52     if (buffer[0]) {
53         jstring obj = env->NewStringUTF(buffer);
54         env->SetObjectArrayElement(strArray, index, obj);
55         env->DeleteLocalRef(obj);
56     }
57 }
58 
59 
android_server_UsbDeviceManager_getAccessoryStrings(JNIEnv * env,jobject)60 static jobjectArray android_server_UsbDeviceManager_getAccessoryStrings(JNIEnv *env,
61                                                                         jobject /* thiz */)
62 {
63     int fd = open(DRIVER_NAME, O_RDWR);
64     if (fd < 0) {
65         ALOGE("could not open %s", DRIVER_NAME);
66         return NULL;
67     }
68     jclass stringClass = env->FindClass("java/lang/String");
69     jobjectArray strArray = env->NewObjectArray(6, stringClass, NULL);
70     if (!strArray) goto out;
71     set_accessory_string(env, fd, ACCESSORY_GET_STRING_MANUFACTURER, strArray, 0);
72     set_accessory_string(env, fd, ACCESSORY_GET_STRING_MODEL, strArray, 1);
73     set_accessory_string(env, fd, ACCESSORY_GET_STRING_DESCRIPTION, strArray, 2);
74     set_accessory_string(env, fd, ACCESSORY_GET_STRING_VERSION, strArray, 3);
75     set_accessory_string(env, fd, ACCESSORY_GET_STRING_URI, strArray, 4);
76     set_accessory_string(env, fd, ACCESSORY_GET_STRING_SERIAL, strArray, 5);
77 
78 out:
79     close(fd);
80     return strArray;
81 }
82 
android_server_UsbDeviceManager_openAccessory(JNIEnv * env,jobject)83 static jobject android_server_UsbDeviceManager_openAccessory(JNIEnv *env, jobject /* thiz */)
84 {
85     int fd = open(DRIVER_NAME, O_RDWR);
86     if (fd < 0) {
87         ALOGE("could not open %s", DRIVER_NAME);
88         return NULL;
89     }
90     jobject fileDescriptor = jniCreateFileDescriptor(env, fd);
91     if (fileDescriptor == NULL) {
92         close(fd);
93         return NULL;
94     }
95     return env->NewObject(gParcelFileDescriptorOffsets.mClass,
96         gParcelFileDescriptorOffsets.mConstructor, fileDescriptor);
97 }
98 
android_server_UsbDeviceManager_isStartRequested(JNIEnv *,jobject)99 static jboolean android_server_UsbDeviceManager_isStartRequested(JNIEnv* /* env */,
100                                                                  jobject /* thiz */)
101 {
102     int fd = open(DRIVER_NAME, O_RDWR);
103     if (fd < 0) {
104         ALOGE("could not open %s", DRIVER_NAME);
105         return false;
106     }
107     int result = ioctl(fd, ACCESSORY_IS_START_REQUESTED);
108     close(fd);
109     return (result == 1);
110 }
111 
android_server_UsbDeviceManager_getAudioMode(JNIEnv *,jobject)112 static jint android_server_UsbDeviceManager_getAudioMode(JNIEnv* /* env */, jobject /* thiz */)
113 {
114     int fd = open(DRIVER_NAME, O_RDWR);
115     if (fd < 0) {
116         ALOGE("could not open %s", DRIVER_NAME);
117         return false;
118     }
119     int result = ioctl(fd, ACCESSORY_GET_AUDIO_MODE);
120     close(fd);
121     return result;
122 }
123 
android_server_UsbDeviceManager_openControl(JNIEnv * env,jobject,jstring jFunction)124 static jobject android_server_UsbDeviceManager_openControl(JNIEnv *env, jobject /* thiz */, jstring jFunction) {
125     ScopedUtfChars function(env, jFunction);
126     bool ptp = false;
127     int fd = -1;
128     if (!strcmp(function.c_str(), "ptp")) {
129         ptp = true;
130     }
131     if (!strcmp(function.c_str(), "mtp") || ptp) {
132         fd = TEMP_FAILURE_RETRY(open(ptp ? FFS_PTP_EP0 : FFS_MTP_EP0, O_RDWR));
133         if (fd < 0) {
134             ALOGE("could not open control for %s %s", function.c_str(), strerror(errno));
135             return NULL;
136         }
137         if (!writeDescriptors(fd, ptp)) {
138             close(fd);
139             return NULL;
140         }
141     }
142 
143     jobject jifd = jniCreateFileDescriptor(env, fd);
144     if (jifd == NULL) {
145         // OutOfMemoryError will be pending.
146         close(fd);
147     }
148     return jifd;
149 }
150 
151 static const JNINativeMethod method_table[] = {
152     { "nativeGetAccessoryStrings",  "()[Ljava/lang/String;",
153                                     (void*)android_server_UsbDeviceManager_getAccessoryStrings },
154     { "nativeOpenAccessory",        "()Landroid/os/ParcelFileDescriptor;",
155                                     (void*)android_server_UsbDeviceManager_openAccessory },
156     { "nativeIsStartRequested",     "()Z",
157                                     (void*)android_server_UsbDeviceManager_isStartRequested },
158     { "nativeGetAudioMode",         "()I",
159                                     (void*)android_server_UsbDeviceManager_getAudioMode },
160     { "nativeOpenControl",          "(Ljava/lang/String;)Ljava/io/FileDescriptor;",
161                                     (void*)android_server_UsbDeviceManager_openControl },
162 };
163 
register_android_server_UsbDeviceManager(JNIEnv * env)164 int register_android_server_UsbDeviceManager(JNIEnv *env)
165 {
166     jclass clazz = env->FindClass("com/android/server/usb/UsbDeviceManager");
167     if (clazz == NULL) {
168         ALOGE("Can't find com/android/server/usb/UsbDeviceManager");
169         return -1;
170     }
171 
172     clazz = env->FindClass("android/os/ParcelFileDescriptor");
173     LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.ParcelFileDescriptor");
174     gParcelFileDescriptorOffsets.mClass = (jclass) env->NewGlobalRef(clazz);
175     gParcelFileDescriptorOffsets.mConstructor = env->GetMethodID(clazz, "<init>", "(Ljava/io/FileDescriptor;)V");
176     LOG_FATAL_IF(gParcelFileDescriptorOffsets.mConstructor == NULL,
177                  "Unable to find constructor for android.os.ParcelFileDescriptor");
178 
179     return jniRegisterNativeMethods(env, "com/android/server/usb/UsbDeviceManager",
180             method_table, NELEM(method_table));
181 }
182 
183 };
184