media/jni/android_media_Media2HTTPConnection.cpp

   1 /*
   2  * Copyright 2017, 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_NDEBUG 0
  18 #define LOG_TAG "Media2HTTPConnection-JNI"
  19 #include <utils/Log.h>
  20
  21 #include <media/stagefright/foundation/ADebug.h>
  22 #include <nativehelper/ScopedLocalRef.h>
  23
  24 #include "android_media_Media2HTTPConnection.h"
  25 #include "android_util_Binder.h"
  26
  27 #include "android_runtime/AndroidRuntime.h"
  28 #include "android_runtime/Log.h"
  29 #include "jni.h"
  30 #include <nativehelper/JNIHelp.h>
  31
  32 namespace android {
  33
  34 static const size_t kBufferSize = 32768;
  35
  36 JMedia2HTTPConnection::JMedia2HTTPConnection(JNIEnv *env, jobject thiz) {
  37     mMedia2HTTPConnectionObj = env->NewGlobalRef(thiz);
  38     CHECK(mMedia2HTTPConnectionObj != NULL);
  39
  40     ScopedLocalRef<jclass> media2HTTPConnectionClass(
  41             env, env->GetObjectClass(mMedia2HTTPConnectionObj));
  42     CHECK(media2HTTPConnectionClass.get() != NULL);
  43
  44     mConnectMethod = env->GetMethodID(
  45             media2HTTPConnectionClass.get(),
  46             "connect",
  47             "(Ljava/lang/String;Ljava/lang/String;)Z");
  48     CHECK(mConnectMethod != NULL);
  49
  50     mDisconnectMethod = env->GetMethodID(
  51             media2HTTPConnectionClass.get(),
  52             "disconnect",
  53             "()V");
  54     CHECK(mDisconnectMethod != NULL);
  55
  56     mReadAtMethod = env->GetMethodID(
  57             media2HTTPConnectionClass.get(),
  58             "readAt",
  59             "(J[BI)I");
  60     CHECK(mReadAtMethod != NULL);
  61
  62     mGetSizeMethod = env->GetMethodID(
  63             media2HTTPConnectionClass.get(),
  64             "getSize",
  65             "()J");
  66     CHECK(mGetSizeMethod != NULL);
  67
  68     mGetMIMETypeMethod = env->GetMethodID(
  69             media2HTTPConnectionClass.get(),
  70             "getMIMEType",
  71             "()Ljava/lang/String;");
  72     CHECK(mGetMIMETypeMethod != NULL);
  73
  74     mGetUriMethod = env->GetMethodID(
  75             media2HTTPConnectionClass.get(),
  76             "getUri",
  77             "()Ljava/lang/String;");
  78     CHECK(mGetUriMethod != NULL);
  79
  80     ScopedLocalRef<jbyteArray> tmp(
  81         env, env->NewByteArray(kBufferSize));
  82     mByteArrayObj = (jbyteArray)env->NewGlobalRef(tmp.get());
  83     CHECK(mByteArrayObj != NULL);
  84 }
  85
  86 JMedia2HTTPConnection::~JMedia2HTTPConnection() {
  87     JNIEnv *env = AndroidRuntime::getJNIEnv();
  88     env->DeleteGlobalRef(mMedia2HTTPConnectionObj);
  89     env->DeleteGlobalRef(mByteArrayObj);
  90 }
  91
  92 bool JMedia2HTTPConnection::connect(
  93         const char *uri, const KeyedVector<String8, String8> *headers) {
  94     String8 tmp("");
  95     if (headers != NULL) {
  96         for (size_t i = 0; i < headers->size(); ++i) {
  97             tmp.append(headers->keyAt(i));
  98             tmp.append(String8(": "));
  99             tmp.append(headers->valueAt(i));
 100             tmp.append(String8("\r\n"));
 101         }
 102     }
 103
 104     JNIEnv* env = AndroidRuntime::getJNIEnv();
 105     jstring juri = env->NewStringUTF(uri);
 106     jstring jheaders = env->NewStringUTF(tmp.string());
 107
 108     jboolean ret =
 109         env->CallBooleanMethod(mMedia2HTTPConnectionObj, mConnectMethod, juri, jheaders);
 110
 111     env->DeleteLocalRef(juri);
 112     env->DeleteLocalRef(jheaders);
 113
 114     return (bool)ret;
 115 }
 116
 117 void JMedia2HTTPConnection::disconnect() {
 118     JNIEnv* env = AndroidRuntime::getJNIEnv();
 119     env->CallVoidMethod(mMedia2HTTPConnectionObj, mDisconnectMethod);
 120 }
 121
 122 ssize_t JMedia2HTTPConnection::readAt(off64_t offset, void *data, size_t size) {
 123     JNIEnv* env = AndroidRuntime::getJNIEnv();
 124
 125     if (size > kBufferSize) {
 126         size = kBufferSize;
 127     }
 128
 129     jint n = env->CallIntMethod(
 130             mMedia2HTTPConnectionObj, mReadAtMethod, (jlong)offset, mByteArrayObj, (jint)size);
 131
 132     if (n > 0) {
 133         env->GetByteArrayRegion(
 134                 mByteArrayObj,
 135                 0,
 136                 n,
 137                 (jbyte *)data);
 138     }
 139
 140     return n;
 141 }
 142
 143 off64_t JMedia2HTTPConnection::getSize() {
 144     JNIEnv* env = AndroidRuntime::getJNIEnv();
 145     return (off64_t)(env->CallLongMethod(mMedia2HTTPConnectionObj, mGetSizeMethod));
 146 }
 147
 148 status_t JMedia2HTTPConnection::getMIMEType(String8 *mimeType) {
 149     JNIEnv* env = AndroidRuntime::getJNIEnv();
 150     jstring jmime = (jstring)env->CallObjectMethod(mMedia2HTTPConnectionObj, mGetMIMETypeMethod);
 151     jboolean flag = env->ExceptionCheck();
 152     if (flag) {
 153         env->ExceptionClear();
 154         return UNKNOWN_ERROR;
 155     }
 156
 157     const char *str = env->GetStringUTFChars(jmime, 0);
 158     if (str != NULL) {
 159         *mimeType = String8(str);
 160     } else {
 161         *mimeType = "application/octet-stream";
 162     }
 163     env->ReleaseStringUTFChars(jmime, str);
 164     return OK;
 165 }
 166
 167 status_t JMedia2HTTPConnection::getUri(String8 *uri) {
 168     JNIEnv* env = AndroidRuntime::getJNIEnv();
 169     jstring juri = (jstring)env->CallObjectMethod(mMedia2HTTPConnectionObj, mGetUriMethod);
 170     jboolean flag = env->ExceptionCheck();
 171     if (flag) {
 172         env->ExceptionClear();
 173         return UNKNOWN_ERROR;
 174     }
 175
 176     const char *str = env->GetStringUTFChars(juri, 0);
 177     *uri = String8(str);
 178     env->ReleaseStringUTFChars(juri, str);
 179     return OK;
 180 }
 181
 182 }  // namespace android