media/jni/android_media_MediaHTTPConnection.cpp

   1 /*
   2  * Copyright 2013, 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 "MediaHTTPConnection-JNI"
  19 #include <utils/Log.h>
  20
  21 #include <binder/MemoryDealer.h>
  22 #include <media/stagefright/foundation/ADebug.h>
  23 #include <nativehelper/ScopedLocalRef.h>
  24
  25 #include "android_media_MediaHTTPConnection.h"
  26 #include "android_util_Binder.h"
  27
  28 #include "android_runtime/AndroidRuntime.h"
  29 #include "jni.h"
  30 #include <nativehelper/JNIHelp.h>
  31
  32 namespace android {
  33
  34 JMediaHTTPConnection::JMediaHTTPConnection(JNIEnv *env, jobject thiz)
  35     : mClass(NULL),
  36       mObject(NULL),
  37       mByteArrayObj(NULL) {
  38     jclass clazz = env->GetObjectClass(thiz);
  39     CHECK(clazz != NULL);
  40
  41     mClass = (jclass)env->NewGlobalRef(clazz);
  42     mObject = env->NewWeakGlobalRef(thiz);
  43
  44     mDealer = new MemoryDealer(kBufferSize, "MediaHTTPConnection");
  45     mMemory = mDealer->allocate(kBufferSize);
  46
  47     ScopedLocalRef<jbyteArray> tmp(
  48             env, env->NewByteArray(JMediaHTTPConnection::kBufferSize));
  49
  50     mByteArrayObj = (jbyteArray)env->NewGlobalRef(tmp.get());
  51 }
  52
  53 JMediaHTTPConnection::~JMediaHTTPConnection() {
  54     JNIEnv *env = AndroidRuntime::getJNIEnv();
  55
  56     env->DeleteGlobalRef(mByteArrayObj);
  57     mByteArrayObj = NULL;
  58     env->DeleteWeakGlobalRef(mObject);
  59     mObject = NULL;
  60     env->DeleteGlobalRef(mClass);
  61     mClass = NULL;
  62 }
  63
  64 sp<IMemory> JMediaHTTPConnection::getIMemory() {
  65     return mMemory;
  66 }
  67
  68 jbyteArray JMediaHTTPConnection::getByteArrayObj() {
  69     return mByteArrayObj;
  70 }
  71
  72 }  // namespace android
  73
  74 using namespace android;
  75
  76 struct fields_t {
  77     jfieldID context;
  78
  79     jmethodID readAtMethodID;
  80 };
  81
  82 static fields_t gFields;
  83
  84 static sp<JMediaHTTPConnection> setObject(
  85         JNIEnv *env, jobject thiz, const sp<JMediaHTTPConnection> &conn) {
  86     sp<JMediaHTTPConnection> old =
  87         (JMediaHTTPConnection *)env->GetLongField(thiz, gFields.context);
  88
  89     if (conn != NULL) {
  90         conn->incStrong(thiz);
  91     }
  92     if (old != NULL) {
  93         old->decStrong(thiz);
  94     }
  95     env->SetLongField(thiz, gFields.context, (jlong)conn.get());
  96
  97     return old;
  98 }
  99
 100 static sp<JMediaHTTPConnection> getObject(JNIEnv *env, jobject thiz) {
 101     return (JMediaHTTPConnection *)env->GetLongField(thiz, gFields.context);
 102 }
 103
 104 static void android_media_MediaHTTPConnection_native_init(JNIEnv *env) {
 105     ScopedLocalRef<jclass> clazz(
 106             env, env->FindClass("android/media/MediaHTTPConnection"));
 107     CHECK(clazz.get() != NULL);
 108
 109     gFields.context = env->GetFieldID(clazz.get(), "mNativeContext", "J");
 110     CHECK(gFields.context != NULL);
 111
 112     gFields.readAtMethodID = env->GetMethodID(clazz.get(), "readAt", "(J[BI)I");
 113 }
 114
 115 static void android_media_MediaHTTPConnection_native_setup(
 116         JNIEnv *env, jobject thiz) {
 117     sp<JMediaHTTPConnection> conn = new JMediaHTTPConnection(env, thiz);
 118
 119     setObject(env, thiz, conn);
 120 }
 121
 122 static void android_media_MediaHTTPConnection_native_finalize(
 123         JNIEnv *env, jobject thiz) {
 124     setObject(env, thiz, NULL);
 125 }
 126
 127 static jobject android_media_MediaHTTPConnection_native_getIMemory(
 128         JNIEnv *env, jobject thiz) {
 129     sp<JMediaHTTPConnection> conn = getObject(env, thiz);
 130
 131     return javaObjectForIBinder(env, IInterface::asBinder(conn->getIMemory()));
 132 }
 133
 134 static jint android_media_MediaHTTPConnection_native_readAt(
 135         JNIEnv *env, jobject thiz, jlong offset, jint size) {
 136     sp<JMediaHTTPConnection> conn = getObject(env, thiz);
 137     if (size > JMediaHTTPConnection::kBufferSize) {
 138         size = JMediaHTTPConnection::kBufferSize;
 139     }
 140
 141     jbyteArray byteArrayObj = conn->getByteArrayObj();
 142
 143     jint n = env->CallIntMethod(
 144             thiz, gFields.readAtMethodID, offset, byteArrayObj, size);
 145
 146     if (n > 0) {
 147         env->GetByteArrayRegion(
 148                 byteArrayObj,
 149                 0,
 150                 n,
 151                 (jbyte *)conn->getIMemory()->pointer());
 152     }
 153
 154     return n;
 155 }
 156
 157 static const JNINativeMethod gMethods[] = {
 158     { "native_getIMemory", "()Landroid/os/IBinder;",
 159       (void *)android_media_MediaHTTPConnection_native_getIMemory },
 160
 161     { "native_readAt", "(JI)I",
 162       (void *)android_media_MediaHTTPConnection_native_readAt },
 163
 164     { "native_init", "()V",
 165       (void *)android_media_MediaHTTPConnection_native_init },
 166
 167     { "native_setup", "()V",
 168       (void *)android_media_MediaHTTPConnection_native_setup },
 169
 170     { "native_finalize", "()V",
 171       (void *)android_media_MediaHTTPConnection_native_finalize },
 172 };
 173
 174 int register_android_media_MediaHTTPConnection(JNIEnv *env) {
 175     return AndroidRuntime::registerNativeMethods(env,
 176                 "android/media/MediaHTTPConnection", gMethods, NELEM(gMethods));
 177 }
 178