media/jni/android_media_MediaPlayer.cpp

   1 /*
   2 **
   3 ** Copyright 2007, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 //#define LOG_NDEBUG 0
  19 #define LOG_TAG "MediaPlayer-JNI"
  20 #include "utils/Log.h"
  21
  22 #include <media/mediaplayer.h>
  23 #include <media/MediaPlayerInterface.h>
  24 #include <stdio.h>
  25 #include <assert.h>
  26 #include <limits.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <utils/threads.h>
  30 #include "jni.h"
  31 #include "JNIHelp.h"
  32 #include "android_runtime/AndroidRuntime.h"
  33 #include "android_runtime/android_view_Surface.h"
  34 #include "utils/Errors.h"  // for status_t
  35 #include "utils/KeyedVector.h"
  36 #include "utils/String8.h"
  37 #include "android_media_Utils.h"
  38
  39 #include "android_os_Parcel.h"
  40 #include "android_util_Binder.h"
  41 #include <binder/Parcel.h>
  42 #include <gui/IGraphicBufferProducer.h>
  43 #include <gui/Surface.h>
  44 #include <binder/IPCThreadState.h>
  45 #include <binder/IServiceManager.h>
  46
  47 // ----------------------------------------------------------------------------
  48
  49 using namespace android;
  50
  51 // ----------------------------------------------------------------------------
  52
  53 struct fields_t {
  54     jfieldID    context;
  55     jfieldID    surface_texture;
  56
  57     jmethodID   post_event;
  58
  59     jmethodID   proxyConfigGetHost;
  60     jmethodID   proxyConfigGetPort;
  61     jmethodID   proxyConfigGetExclusionList;
  62 };
  63 static fields_t fields;
  64
  65 static Mutex sLock;
  66
  67 // ----------------------------------------------------------------------------
  68 // ref-counted object for callbacks
  69 class JNIMediaPlayerListener: public MediaPlayerListener
  70 {
  71 public:
  72     JNIMediaPlayerListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
  73     ~JNIMediaPlayerListener();
  74     virtual void notify(int msg, int ext1, int ext2, const Parcel *obj = NULL);
  75 private:
  76     JNIMediaPlayerListener();
  77     jclass      mClass;     // Reference to MediaPlayer class
  78     jobject     mObject;    // Weak ref to MediaPlayer Java object to call on
  79 };
  80
  81 JNIMediaPlayerListener::JNIMediaPlayerListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
  82 {
  83
  84     // Hold onto the MediaPlayer class for use in calling the static method
  85     // that posts events to the application thread.
  86     jclass clazz = env->GetObjectClass(thiz);
  87     if (clazz == NULL) {
  88         ALOGE("Can't find android/media/MediaPlayer");
  89         jniThrowException(env, "java/lang/Exception", NULL);
  90         return;
  91     }
  92     mClass = (jclass)env->NewGlobalRef(clazz);
  93
  94     // We use a weak reference so the MediaPlayer object can be garbage collected.
  95     // The reference is only used as a proxy for callbacks.
  96     mObject  = env->NewGlobalRef(weak_thiz);
  97 }
  98
  99 JNIMediaPlayerListener::~JNIMediaPlayerListener()
 100 {
 101     // remove global references
 102     JNIEnv *env = AndroidRuntime::getJNIEnv();
 103     env->DeleteGlobalRef(mObject);
 104     env->DeleteGlobalRef(mClass);
 105 }
 106
 107 void JNIMediaPlayerListener::notify(int msg, int ext1, int ext2, const Parcel *obj)
 108 {
 109     JNIEnv *env = AndroidRuntime::getJNIEnv();
 110     if (obj && obj->dataSize() > 0) {
 111         jobject jParcel = createJavaParcelObject(env);
 112         if (jParcel != NULL) {
 113             Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
 114             nativeParcel->setData(obj->data(), obj->dataSize());
 115             env->CallStaticVoidMethod(mClass, fields.post_event, mObject,
 116                     msg, ext1, ext2, jParcel);
 117         }
 118     } else {
 119         env->CallStaticVoidMethod(mClass, fields.post_event, mObject,
 120                 msg, ext1, ext2, NULL);
 121     }
 122     if (env->ExceptionCheck()) {
 123         ALOGW("An exception occurred while notifying an event.");
 124         LOGW_EX(env);
 125         env->ExceptionClear();
 126     }
 127 }
 128
 129 // ----------------------------------------------------------------------------
 130
 131 static sp<MediaPlayer> getMediaPlayer(JNIEnv* env, jobject thiz)
 132 {
 133     Mutex::Autolock l(sLock);
 134     MediaPlayer* const p = (MediaPlayer*)env->GetIntField(thiz, fields.context);
 135     return sp<MediaPlayer>(p);
 136 }
 137
 138 static sp<MediaPlayer> setMediaPlayer(JNIEnv* env, jobject thiz, const sp<MediaPlayer>& player)
 139 {
 140     Mutex::Autolock l(sLock);
 141     sp<MediaPlayer> old = (MediaPlayer*)env->GetIntField(thiz, fields.context);
 142     if (player.get()) {
 143         player->incStrong((void*)setMediaPlayer);
 144     }
 145     if (old != 0) {
 146         old->decStrong((void*)setMediaPlayer);
 147     }
 148     env->SetIntField(thiz, fields.context, (int)player.get());
 149     return old;
 150 }
 151
 152 // If exception is NULL and opStatus is not OK, this method sends an error
 153 // event to the client application; otherwise, if exception is not NULL and
 154 // opStatus is not OK, this method throws the given exception to the client
 155 // application.
 156 static void process_media_player_call(JNIEnv *env, jobject thiz, status_t opStatus, const char* exception, const char *message)
 157 {
 158     if (exception == NULL) {  // Don't throw exception. Instead, send an event.
 159         if (opStatus != (status_t) OK) {
 160             sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 161             if (mp != 0) mp->notify(MEDIA_ERROR, opStatus, 0);
 162         }
 163     } else {  // Throw exception!
 164         if ( opStatus == (status_t) INVALID_OPERATION ) {
 165             jniThrowException(env, "java/lang/IllegalStateException", NULL);
 166         } else if ( opStatus == (status_t) PERMISSION_DENIED ) {
 167             jniThrowException(env, "java/lang/SecurityException", NULL);
 168         } else if ( opStatus != (status_t) OK ) {
 169             if (strlen(message) > 230) {
 170                // if the message is too long, don't bother displaying the status code
 171                jniThrowException( env, exception, message);
 172             } else {
 173                char msg[256];
 174                 // append the status code to the message
 175                sprintf(msg, "%s: status=0x%X", message, opStatus);
 176                jniThrowException( env, exception, msg);
 177             }
 178         }
 179     }
 180 }
 181
 182 static void
 183 android_media_MediaPlayer_setDataSourceAndHeaders(
 184         JNIEnv *env, jobject thiz, jstring path,
 185         jobjectArray keys, jobjectArray values) {
 186
 187     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 188     if (mp == NULL ) {
 189         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 190         return;
 191     }
 192
 193     if (path == NULL) {
 194         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
 195         return;
 196     }
 197
 198     const char *tmp = env->GetStringUTFChars(path, NULL);
 199     if (tmp == NULL) {  // Out of memory
 200         return;
 201     }
 202     ALOGV("setDataSource: path %s", tmp);
 203
 204     String8 pathStr(tmp);
 205     env->ReleaseStringUTFChars(path, tmp);
 206     tmp = NULL;
 207
 208     // We build a KeyedVector out of the key and val arrays
 209     KeyedVector<String8, String8> headersVector;
 210     if (!ConvertKeyValueArraysToKeyedVector(
 211             env, keys, values, &headersVector)) {
 212         return;
 213     }
 214
 215     status_t opStatus =
 216         mp->setDataSource(
 217                 pathStr,
 218                 headersVector.size() > 0? &headersVector : NULL);
 219
 220     process_media_player_call(
 221             env, thiz, opStatus, "java/io/IOException",
 222             "setDataSource failed." );
 223 }
 224
 225 static void
 226 android_media_MediaPlayer_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length)
 227 {
 228     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 229     if (mp == NULL ) {
 230         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 231         return;
 232     }
 233
 234     if (fileDescriptor == NULL) {
 235         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
 236         return;
 237     }
 238     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
 239     ALOGV("setDataSourceFD: fd %d", fd);
 240     process_media_player_call( env, thiz, mp->setDataSource(fd, offset, length), "java/io/IOException", "setDataSourceFD failed." );
 241 }
 242
 243 static sp<IGraphicBufferProducer>
 244 getVideoSurfaceTexture(JNIEnv* env, jobject thiz) {
 245     IGraphicBufferProducer * const p = (IGraphicBufferProducer*)env->GetIntField(thiz, fields.surface_texture);
 246     return sp<IGraphicBufferProducer>(p);
 247 }
 248
 249 static void
 250 decVideoSurfaceRef(JNIEnv *env, jobject thiz)
 251 {
 252     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 253     if (mp == NULL) {
 254         return;
 255     }
 256
 257     sp<IGraphicBufferProducer> old_st = getVideoSurfaceTexture(env, thiz);
 258     if (old_st != NULL) {
 259         old_st->decStrong((void*)decVideoSurfaceRef);
 260     }
 261 }
 262
 263 static void
 264 setVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface, jboolean mediaPlayerMustBeAlive)
 265 {
 266     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 267     if (mp == NULL) {
 268         if (mediaPlayerMustBeAlive) {
 269             jniThrowException(env, "java/lang/IllegalStateException", NULL);
 270         }
 271         return;
 272     }
 273
 274     decVideoSurfaceRef(env, thiz);
 275
 276     sp<IGraphicBufferProducer> new_st;
 277     if (jsurface) {
 278         sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
 279         if (surface != NULL) {
 280             new_st = surface->getIGraphicBufferProducer();
 281             if (new_st == NULL) {
 282                 jniThrowException(env, "java/lang/IllegalArgumentException",
 283                     "The surface does not have a binding SurfaceTexture!");
 284                 return;
 285             }
 286             new_st->incStrong((void*)decVideoSurfaceRef);
 287         } else {
 288             jniThrowException(env, "java/lang/IllegalArgumentException",
 289                     "The surface has been released");
 290             return;
 291         }
 292     }
 293
 294     env->SetIntField(thiz, fields.surface_texture, (int)new_st.get());
 295
 296     // This will fail if the media player has not been initialized yet. This
 297     // can be the case if setDisplay() on MediaPlayer.java has been called
 298     // before setDataSource(). The redundant call to setVideoSurfaceTexture()
 299     // in prepare/prepareAsync covers for this case.
 300     mp->setVideoSurfaceTexture(new_st);
 301 }
 302
 303 static void
 304 android_media_MediaPlayer_setVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface)
 305 {
 306     setVideoSurface(env, thiz, jsurface, true /* mediaPlayerMustBeAlive */);
 307 }
 308
 309 static void
 310 android_media_MediaPlayer_prepare(JNIEnv *env, jobject thiz)
 311 {
 312     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 313     if (mp == NULL ) {
 314         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 315         return;
 316     }
 317
 318     // Handle the case where the display surface was set before the mp was
 319     // initialized. We try again to make it stick.
 320     sp<IGraphicBufferProducer> st = getVideoSurfaceTexture(env, thiz);
 321     mp->setVideoSurfaceTexture(st);
 322
 323     process_media_player_call( env, thiz, mp->prepare(), "java/io/IOException", "Prepare failed." );
 324 }
 325
 326 static void
 327 android_media_MediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)
 328 {
 329     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 330     if (mp == NULL ) {
 331         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 332         return;
 333     }
 334
 335     // Handle the case where the display surface was set before the mp was
 336     // initialized. We try again to make it stick.
 337     sp<IGraphicBufferProducer> st = getVideoSurfaceTexture(env, thiz);
 338     mp->setVideoSurfaceTexture(st);
 339
 340     process_media_player_call( env, thiz, mp->prepareAsync(), "java/io/IOException", "Prepare Async failed." );
 341 }
 342
 343 static void
 344 android_media_MediaPlayer_start(JNIEnv *env, jobject thiz)
 345 {
 346     ALOGV("start");
 347     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 348     if (mp == NULL ) {
 349         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 350         return;
 351     }
 352     process_media_player_call( env, thiz, mp->start(), NULL, NULL );
 353 }
 354
 355 static void
 356 android_media_MediaPlayer_stop(JNIEnv *env, jobject thiz)
 357 {
 358     ALOGV("stop");
 359     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 360     if (mp == NULL ) {
 361         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 362         return;
 363     }
 364     process_media_player_call( env, thiz, mp->stop(), NULL, NULL );
 365 }
 366
 367 static void
 368 android_media_MediaPlayer_pause(JNIEnv *env, jobject thiz)
 369 {
 370     ALOGV("pause");
 371     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 372     if (mp == NULL ) {
 373         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 374         return;
 375     }
 376     process_media_player_call( env, thiz, mp->pause(), NULL, NULL );
 377 }
 378
 379 static jboolean
 380 android_media_MediaPlayer_isPlaying(JNIEnv *env, jobject thiz)
 381 {
 382     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 383     if (mp == NULL ) {
 384         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 385         return false;
 386     }
 387     const jboolean is_playing = mp->isPlaying();
 388
 389     ALOGV("isPlaying: %d", is_playing);
 390     return is_playing;
 391 }
 392
 393 static void
 394 android_media_MediaPlayer_seekTo(JNIEnv *env, jobject thiz, int msec)
 395 {
 396     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 397     if (mp == NULL ) {
 398         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 399         return;
 400     }
 401     ALOGV("seekTo: %d(msec)", msec);
 402     process_media_player_call( env, thiz, mp->seekTo(msec), NULL, NULL );
 403 }
 404
 405 static int
 406 android_media_MediaPlayer_getVideoWidth(JNIEnv *env, jobject thiz)
 407 {
 408     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 409     if (mp == NULL ) {
 410         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 411         return 0;
 412     }
 413     int w;
 414     if (0 != mp->getVideoWidth(&w)) {
 415         ALOGE("getVideoWidth failed");
 416         w = 0;
 417     }
 418     ALOGV("getVideoWidth: %d", w);
 419     return w;
 420 }
 421
 422 static int
 423 android_media_MediaPlayer_getVideoHeight(JNIEnv *env, jobject thiz)
 424 {
 425     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 426     if (mp == NULL ) {
 427         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 428         return 0;
 429     }
 430     int h;
 431     if (0 != mp->getVideoHeight(&h)) {
 432         ALOGE("getVideoHeight failed");
 433         h = 0;
 434     }
 435     ALOGV("getVideoHeight: %d", h);
 436     return h;
 437 }
 438
 439
 440 static int
 441 android_media_MediaPlayer_getCurrentPosition(JNIEnv *env, jobject thiz)
 442 {
 443     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 444     if (mp == NULL ) {
 445         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 446         return 0;
 447     }
 448     int msec;
 449     process_media_player_call( env, thiz, mp->getCurrentPosition(&msec), NULL, NULL );
 450     ALOGV("getCurrentPosition: %d (msec)", msec);
 451     return msec;
 452 }
 453
 454 static int
 455 android_media_MediaPlayer_getDuration(JNIEnv *env, jobject thiz)
 456 {
 457     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 458     if (mp == NULL ) {
 459         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 460         return 0;
 461     }
 462     int msec;
 463     process_media_player_call( env, thiz, mp->getDuration(&msec), NULL, NULL );
 464     ALOGV("getDuration: %d (msec)", msec);
 465     return msec;
 466 }
 467
 468 static void
 469 android_media_MediaPlayer_reset(JNIEnv *env, jobject thiz)
 470 {
 471     ALOGV("reset");
 472     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 473     if (mp == NULL ) {
 474         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 475         return;
 476     }
 477     process_media_player_call( env, thiz, mp->reset(), NULL, NULL );
 478 }
 479
 480 static void
 481 android_media_MediaPlayer_setAudioStreamType(JNIEnv *env, jobject thiz, int streamtype)
 482 {
 483     ALOGV("setAudioStreamType: %d", streamtype);
 484     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 485     if (mp == NULL ) {
 486         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 487         return;
 488     }
 489     process_media_player_call( env, thiz, mp->setAudioStreamType((audio_stream_type_t) streamtype) , NULL, NULL );
 490 }
 491
 492 static void
 493 android_media_MediaPlayer_setLooping(JNIEnv *env, jobject thiz, jboolean looping)
 494 {
 495     ALOGV("setLooping: %d", looping);
 496     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 497     if (mp == NULL ) {
 498         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 499         return;
 500     }
 501     process_media_player_call( env, thiz, mp->setLooping(looping), NULL, NULL );
 502 }
 503
 504 static jboolean
 505 android_media_MediaPlayer_isLooping(JNIEnv *env, jobject thiz)
 506 {
 507     ALOGV("isLooping");
 508     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 509     if (mp == NULL ) {
 510         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 511         return false;
 512     }
 513     return mp->isLooping();
 514 }
 515
 516 static void
 517 android_media_MediaPlayer_setVolume(JNIEnv *env, jobject thiz, float leftVolume, float rightVolume)
 518 {
 519     ALOGV("setVolume: left %f  right %f", leftVolume, rightVolume);
 520     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 521     if (mp == NULL ) {
 522         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 523         return;
 524     }
 525     process_media_player_call( env, thiz, mp->setVolume(leftVolume, rightVolume), NULL, NULL );
 526 }
 527
 528 // FIXME: deprecated
 529 static jobject
 530 android_media_MediaPlayer_getFrameAt(JNIEnv *env, jobject thiz, jint msec)
 531 {
 532     return NULL;
 533 }
 534
 535
 536 // Sends the request and reply parcels to the media player via the
 537 // binder interface.
 538 static jint
 539 android_media_MediaPlayer_invoke(JNIEnv *env, jobject thiz,
 540                                  jobject java_request, jobject java_reply)
 541 {
 542     sp<MediaPlayer> media_player = getMediaPlayer(env, thiz);
 543     if (media_player == NULL ) {
 544         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 545         return UNKNOWN_ERROR;
 546     }
 547
 548     Parcel *request = parcelForJavaObject(env, java_request);
 549     Parcel *reply = parcelForJavaObject(env, java_reply);
 550
 551     // Don't use process_media_player_call which use the async loop to
 552     // report errors, instead returns the status.
 553     return media_player->invoke(*request, reply);
 554 }
 555
 556 // Sends the new filter to the client.
 557 static jint
 558 android_media_MediaPlayer_setMetadataFilter(JNIEnv *env, jobject thiz, jobject request)
 559 {
 560     sp<MediaPlayer> media_player = getMediaPlayer(env, thiz);
 561     if (media_player == NULL ) {
 562         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 563         return UNKNOWN_ERROR;
 564     }
 565
 566     Parcel *filter = parcelForJavaObject(env, request);
 567
 568     if (filter == NULL ) {
 569         jniThrowException(env, "java/lang/RuntimeException", "Filter is null");
 570         return UNKNOWN_ERROR;
 571     }
 572
 573     return media_player->setMetadataFilter(*filter);
 574 }
 575
 576 static jboolean
 577 android_media_MediaPlayer_getMetadata(JNIEnv *env, jobject thiz, jboolean update_only,
 578                                       jboolean apply_filter, jobject reply)
 579 {
 580     sp<MediaPlayer> media_player = getMediaPlayer(env, thiz);
 581     if (media_player == NULL ) {
 582         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 583         return false;
 584     }
 585
 586     Parcel *metadata = parcelForJavaObject(env, reply);
 587
 588     if (metadata == NULL ) {
 589         jniThrowException(env, "java/lang/RuntimeException", "Reply parcel is null");
 590         return false;
 591     }
 592
 593     metadata->freeData();
 594     // On return metadata is positioned at the beginning of the
 595     // metadata. Note however that the parcel actually starts with the
 596     // return code so you should not rewind the parcel using
 597     // setDataPosition(0).
 598     return media_player->getMetadata(update_only, apply_filter, metadata) == OK;
 599 }
 600
 601 // This function gets some field IDs, which in turn causes class initialization.
 602 // It is called from a static block in MediaPlayer, which won't run until the
 603 // first time an instance of this class is used.
 604 static void
 605 android_media_MediaPlayer_native_init(JNIEnv *env)
 606 {
 607     jclass clazz;
 608
 609     clazz = env->FindClass("android/media/MediaPlayer");
 610     if (clazz == NULL) {
 611         return;
 612     }
 613
 614     fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
 615     if (fields.context == NULL) {
 616         return;
 617     }
 618
 619     fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
 620                                                "(Ljava/lang/Object;IIILjava/lang/Object;)V");
 621     if (fields.post_event == NULL) {
 622         return;
 623     }
 624
 625     fields.surface_texture = env->GetFieldID(clazz, "mNativeSurfaceTexture", "I");
 626     if (fields.surface_texture == NULL) {
 627         return;
 628     }
 629
 630     clazz = env->FindClass("android/net/ProxyProperties");
 631     if (clazz == NULL) {
 632         return;
 633     }
 634
 635     fields.proxyConfigGetHost =
 636         env->GetMethodID(clazz, "getHost", "()Ljava/lang/String;");
 637
 638     fields.proxyConfigGetPort =
 639         env->GetMethodID(clazz, "getPort", "()I");
 640
 641     fields.proxyConfigGetExclusionList =
 642         env->GetMethodID(clazz, "getExclusionList", "()Ljava/lang/String;");
 643 }
 644
 645 static void
 646 android_media_MediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
 647 {
 648     ALOGV("native_setup");
 649     sp<MediaPlayer> mp = new MediaPlayer();
 650     if (mp == NULL) {
 651         jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
 652         return;
 653     }
 654
 655     // create new listener and give it to MediaPlayer
 656     sp<JNIMediaPlayerListener> listener = new JNIMediaPlayerListener(env, thiz, weak_this);
 657     mp->setListener(listener);
 658
 659     // Stow our new C++ MediaPlayer in an opaque field in the Java object.
 660     setMediaPlayer(env, thiz, mp);
 661 }
 662
 663 static void
 664 android_media_MediaPlayer_release(JNIEnv *env, jobject thiz)
 665 {
 666     ALOGV("release");
 667     decVideoSurfaceRef(env, thiz);
 668     sp<MediaPlayer> mp = setMediaPlayer(env, thiz, 0);
 669     if (mp != NULL) {
 670         // this prevents native callbacks after the object is released
 671         mp->setListener(0);
 672         mp->disconnect();
 673     }
 674 }
 675
 676 static void
 677 android_media_MediaPlayer_native_finalize(JNIEnv *env, jobject thiz)
 678 {
 679     ALOGV("native_finalize");
 680     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 681     if (mp != NULL) {
 682         ALOGW("MediaPlayer finalized without being released");
 683     }
 684     android_media_MediaPlayer_release(env, thiz);
 685 }
 686
 687 static void android_media_MediaPlayer_set_audio_session_id(JNIEnv *env,  jobject thiz, jint sessionId) {
 688     ALOGV("set_session_id(): %d", sessionId);
 689     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 690     if (mp == NULL ) {
 691         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 692         return;
 693     }
 694     process_media_player_call( env, thiz, mp->setAudioSessionId(sessionId), NULL, NULL );
 695 }
 696
 697 static jint android_media_MediaPlayer_get_audio_session_id(JNIEnv *env,  jobject thiz) {
 698     ALOGV("get_session_id()");
 699     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 700     if (mp == NULL ) {
 701         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 702         return 0;
 703     }
 704
 705     return mp->getAudioSessionId();
 706 }
 707
 708 static void
 709 android_media_MediaPlayer_setAuxEffectSendLevel(JNIEnv *env, jobject thiz, jfloat level)
 710 {
 711     ALOGV("setAuxEffectSendLevel: level %f", level);
 712     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 713     if (mp == NULL ) {
 714         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 715         return;
 716     }
 717     process_media_player_call( env, thiz, mp->setAuxEffectSendLevel(level), NULL, NULL );
 718 }
 719
 720 static void android_media_MediaPlayer_attachAuxEffect(JNIEnv *env,  jobject thiz, jint effectId) {
 721     ALOGV("attachAuxEffect(): %d", effectId);
 722     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 723     if (mp == NULL ) {
 724         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 725         return;
 726     }
 727     process_media_player_call( env, thiz, mp->attachAuxEffect(effectId), NULL, NULL );
 728 }
 729
 730 static jint
 731 android_media_MediaPlayer_pullBatteryData(JNIEnv *env, jobject thiz, jobject java_reply)
 732 {
 733     sp<IBinder> binder = defaultServiceManager()->getService(String16("media.player"));
 734     sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);
 735     if (service.get() == NULL) {
 736         jniThrowException(env, "java/lang/RuntimeException", "cannot get MediaPlayerService");
 737         return UNKNOWN_ERROR;
 738     }
 739
 740     Parcel *reply = parcelForJavaObject(env, java_reply);
 741
 742     return service->pullBatteryData(reply);
 743 }
 744
 745 static jint
 746 android_media_MediaPlayer_setRetransmitEndpoint(JNIEnv *env, jobject thiz,
 747                                                 jstring addrString, jint port) {
 748     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 749     if (mp == NULL ) {
 750         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 751         return INVALID_OPERATION;
 752     }
 753
 754     const char *cAddrString = NULL;
 755
 756     if (NULL != addrString) {
 757         cAddrString = env->GetStringUTFChars(addrString, NULL);
 758         if (cAddrString == NULL) {  // Out of memory
 759             return NO_MEMORY;
 760         }
 761     }
 762     ALOGV("setRetransmitEndpoint: %s:%d",
 763             cAddrString ? cAddrString : "(null)", port);
 764
 765     status_t ret;
 766     if (cAddrString && (port > 0xFFFF)) {
 767         ret = BAD_VALUE;
 768     } else {
 769         ret = mp->setRetransmitEndpoint(cAddrString,
 770                 static_cast<uint16_t>(port));
 771     }
 772
 773     if (NULL != addrString) {
 774         env->ReleaseStringUTFChars(addrString, cAddrString);
 775     }
 776
 777     if (ret == INVALID_OPERATION ) {
 778         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 779     }
 780
 781     return ret;
 782 }
 783
 784 static jboolean
 785 android_media_MediaPlayer_setParameter(JNIEnv *env, jobject thiz, jint key, jobject java_request)
 786 {
 787     ALOGV("setParameter: key %d", key);
 788     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 789     if (mp == NULL ) {
 790         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 791         return false;
 792     }
 793
 794     Parcel *request = parcelForJavaObject(env, java_request);
 795     status_t err = mp->setParameter(key, *request);
 796     if (err == OK) {
 797         return true;
 798     } else {
 799         return false;
 800     }
 801 }
 802
 803 static void
 804 android_media_MediaPlayer_getParameter(JNIEnv *env, jobject thiz, jint key, jobject java_reply)
 805 {
 806     ALOGV("getParameter: key %d", key);
 807     sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
 808     if (mp == NULL ) {
 809         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 810         return;
 811     }
 812
 813     Parcel *reply = parcelForJavaObject(env, java_reply);
 814     process_media_player_call(env, thiz, mp->getParameter(key, reply), NULL, NULL );
 815 }
 816
 817 static void
 818 android_media_MediaPlayer_setNextMediaPlayer(JNIEnv *env, jobject thiz, jobject java_player)
 819 {
 820     ALOGV("setNextMediaPlayer");
 821     sp<MediaPlayer> thisplayer = getMediaPlayer(env, thiz);
 822     if (thisplayer == NULL) {
 823         jniThrowException(env, "java/lang/IllegalStateException", "This player not initialized");
 824         return;
 825     }
 826     sp<MediaPlayer> nextplayer = (java_player == NULL) ? NULL : getMediaPlayer(env, java_player);
 827     if (nextplayer == NULL && java_player != NULL) {
 828         jniThrowException(env, "java/lang/IllegalStateException", "That player not initialized");
 829         return;
 830     }
 831
 832     if (nextplayer == thisplayer) {
 833         jniThrowException(env, "java/lang/IllegalArgumentException", "Next player can't be self");
 834         return;
 835     }
 836     // tie the two players together
 837     process_media_player_call(
 838             env, thiz, thisplayer->setNextMediaPlayer(nextplayer),
 839             "java/lang/IllegalArgumentException",
 840             "setNextMediaPlayer failed." );
 841     ;
 842 }
 843
 844 static void
 845 android_media_MediaPlayer_updateProxyConfig(
 846         JNIEnv *env, jobject thiz, jobject proxyProps)
 847 {
 848     ALOGV("updateProxyConfig");
 849     sp<MediaPlayer> thisplayer = getMediaPlayer(env, thiz);
 850     if (thisplayer == NULL) {
 851         return;
 852     }
 853
 854     if (proxyProps == NULL) {
 855         thisplayer->updateProxyConfig(
 856                 NULL /* host */, 0 /* port */, NULL /* exclusionList */);
 857     } else {
 858         jstring hostObj = (jstring)env->CallObjectMethod(
 859                 proxyProps, fields.proxyConfigGetHost);
 860
 861         const char *host = env->GetStringUTFChars(hostObj, NULL);
 862
 863         int port = env->CallIntMethod(proxyProps, fields.proxyConfigGetPort);
 864
 865         jstring exclusionListObj = (jstring)env->CallObjectMethod(
 866                 proxyProps, fields.proxyConfigGetExclusionList);
 867
 868         const char *exclusionList =
 869             env->GetStringUTFChars(exclusionListObj, NULL);
 870
 871         if (host != NULL && exclusionListObj != NULL) {
 872             thisplayer->updateProxyConfig(host, port, exclusionList);
 873         }
 874
 875         if (exclusionList != NULL) {
 876             env->ReleaseStringUTFChars(exclusionListObj, exclusionList);
 877             exclusionList = NULL;
 878         }
 879
 880         if (host != NULL) {
 881             env->ReleaseStringUTFChars(hostObj, host);
 882             host = NULL;
 883         }
 884     }
 885 }
 886
 887 // ----------------------------------------------------------------------------
 888
 889 static JNINativeMethod gMethods[] = {
 890     {
 891         "_setDataSource",
 892         "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V",
 893         (void *)android_media_MediaPlayer_setDataSourceAndHeaders
 894     },
 895
 896     {"_setDataSource",       "(Ljava/io/FileDescriptor;JJ)V",    (void *)android_media_MediaPlayer_setDataSourceFD},
 897     {"_setVideoSurface",    "(Landroid/view/Surface;)V",        (void *)android_media_MediaPlayer_setVideoSurface},
 898     {"prepare",             "()V",                              (void *)android_media_MediaPlayer_prepare},
 899     {"prepareAsync",        "()V",                              (void *)android_media_MediaPlayer_prepareAsync},
 900     {"_start",              "()V",                              (void *)android_media_MediaPlayer_start},
 901     {"_stop",               "()V",                              (void *)android_media_MediaPlayer_stop},
 902     {"getVideoWidth",       "()I",                              (void *)android_media_MediaPlayer_getVideoWidth},
 903     {"getVideoHeight",      "()I",                              (void *)android_media_MediaPlayer_getVideoHeight},
 904     {"seekTo",              "(I)V",                             (void *)android_media_MediaPlayer_seekTo},
 905     {"_pause",              "()V",                              (void *)android_media_MediaPlayer_pause},
 906     {"isPlaying",           "()Z",                              (void *)android_media_MediaPlayer_isPlaying},
 907     {"getCurrentPosition",  "()I",                              (void *)android_media_MediaPlayer_getCurrentPosition},
 908     {"getDuration",         "()I",                              (void *)android_media_MediaPlayer_getDuration},
 909     {"_release",            "()V",                              (void *)android_media_MediaPlayer_release},
 910     {"_reset",              "()V",                              (void *)android_media_MediaPlayer_reset},
 911     {"setAudioStreamType",  "(I)V",                             (void *)android_media_MediaPlayer_setAudioStreamType},
 912     {"setLooping",          "(Z)V",                             (void *)android_media_MediaPlayer_setLooping},
 913     {"isLooping",           "()Z",                              (void *)android_media_MediaPlayer_isLooping},
 914     {"setVolume",           "(FF)V",                            (void *)android_media_MediaPlayer_setVolume},
 915     {"getFrameAt",          "(I)Landroid/graphics/Bitmap;",     (void *)android_media_MediaPlayer_getFrameAt},
 916     {"native_invoke",       "(Landroid/os/Parcel;Landroid/os/Parcel;)I",(void *)android_media_MediaPlayer_invoke},
 917     {"native_setMetadataFilter", "(Landroid/os/Parcel;)I",      (void *)android_media_MediaPlayer_setMetadataFilter},
 918     {"native_getMetadata", "(ZZLandroid/os/Parcel;)Z",          (void *)android_media_MediaPlayer_getMetadata},
 919     {"native_init",         "()V",                              (void *)android_media_MediaPlayer_native_init},
 920     {"native_setup",        "(Ljava/lang/Object;)V",            (void *)android_media_MediaPlayer_native_setup},
 921     {"native_finalize",     "()V",                              (void *)android_media_MediaPlayer_native_finalize},
 922     {"getAudioSessionId",   "()I",                              (void *)android_media_MediaPlayer_get_audio_session_id},
 923     {"setAudioSessionId",   "(I)V",                             (void *)android_media_MediaPlayer_set_audio_session_id},
 924     {"setAuxEffectSendLevel", "(F)V",                           (void *)android_media_MediaPlayer_setAuxEffectSendLevel},
 925     {"attachAuxEffect",     "(I)V",                             (void *)android_media_MediaPlayer_attachAuxEffect},
 926     {"native_pullBatteryData", "(Landroid/os/Parcel;)I",        (void *)android_media_MediaPlayer_pullBatteryData},
 927     {"setParameter",        "(ILandroid/os/Parcel;)Z",          (void *)android_media_MediaPlayer_setParameter},
 928     {"getParameter",        "(ILandroid/os/Parcel;)V",          (void *)android_media_MediaPlayer_getParameter},
 929     {"native_setRetransmitEndpoint", "(Ljava/lang/String;I)I",  (void *)android_media_MediaPlayer_setRetransmitEndpoint},
 930     {"setNextMediaPlayer",  "(Landroid/media/MediaPlayer;)V",   (void *)android_media_MediaPlayer_setNextMediaPlayer},
 931     {"updateProxyConfig", "(Landroid/net/ProxyProperties;)V", (void *)android_media_MediaPlayer_updateProxyConfig},
 932 };
 933
 934 static const char* const kClassPathName = "android/media/MediaPlayer";
 935
 936 // This function only registers the native methods
 937 static int register_android_media_MediaPlayer(JNIEnv *env)
 938 {
 939     return AndroidRuntime::registerNativeMethods(env,
 940                 "android/media/MediaPlayer", gMethods, NELEM(gMethods));
 941 }
 942
 943 extern int register_android_media_Crypto(JNIEnv *env);
 944 extern int register_android_media_Drm(JNIEnv *env);
 945 extern int register_android_media_MediaCodec(JNIEnv *env);
 946 extern int register_android_media_MediaExtractor(JNIEnv *env);
 947 extern int register_android_media_MediaCodecList(JNIEnv *env);
 948 extern int register_android_media_MediaMetadataRetriever(JNIEnv *env);
 949 extern int register_android_media_MediaMuxer(JNIEnv *env);
 950 extern int register_android_media_MediaRecorder(JNIEnv *env);
 951 extern int register_android_media_MediaScanner(JNIEnv *env);
 952 extern int register_android_media_ResampleInputStream(JNIEnv *env);
 953 extern int register_android_media_MediaProfiles(JNIEnv *env);
 954 extern int register_android_media_AmrInputStream(JNIEnv *env);
 955 extern int register_android_mtp_MtpDatabase(JNIEnv *env);
 956 extern int register_android_mtp_MtpDevice(JNIEnv *env);
 957 extern int register_android_mtp_MtpServer(JNIEnv *env);
 958
 959 jint JNI_OnLoad(JavaVM* vm, void* reserved)
 960 {
 961     JNIEnv* env = NULL;
 962     jint result = -1;
 963
 964     if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
 965         ALOGE("ERROR: GetEnv failed\n");
 966         goto bail;
 967     }
 968     assert(env != NULL);
 969
 970     if (register_android_media_MediaPlayer(env) < 0) {
 971         ALOGE("ERROR: MediaPlayer native registration failed\n");
 972         goto bail;
 973     }
 974
 975     if (register_android_media_MediaRecorder(env) < 0) {
 976         ALOGE("ERROR: MediaRecorder native registration failed\n");
 977         goto bail;
 978     }
 979
 980     if (register_android_media_MediaScanner(env) < 0) {
 981         ALOGE("ERROR: MediaScanner native registration failed\n");
 982         goto bail;
 983     }
 984
 985     if (register_android_media_MediaMetadataRetriever(env) < 0) {
 986         ALOGE("ERROR: MediaMetadataRetriever native registration failed\n");
 987         goto bail;
 988     }
 989
 990     if (register_android_media_AmrInputStream(env) < 0) {
 991         ALOGE("ERROR: AmrInputStream native registration failed\n");
 992         goto bail;
 993     }
 994
 995     if (register_android_media_ResampleInputStream(env) < 0) {
 996         ALOGE("ERROR: ResampleInputStream native registration failed\n");
 997         goto bail;
 998     }
 999
1000     if (register_android_media_MediaProfiles(env) < 0) {
1001         ALOGE("ERROR: MediaProfiles native registration failed");
1002         goto bail;
1003     }
1004
1005     if (register_android_mtp_MtpDatabase(env) < 0) {
1006         ALOGE("ERROR: MtpDatabase native registration failed");
1007         goto bail;
1008     }
1009
1010     if (register_android_mtp_MtpDevice(env) < 0) {
1011         ALOGE("ERROR: MtpDevice native registration failed");
1012         goto bail;
1013     }
1014
1015     if (register_android_mtp_MtpServer(env) < 0) {
1016         ALOGE("ERROR: MtpServer native registration failed");
1017         goto bail;
1018     }
1019
1020     if (register_android_media_MediaCodec(env) < 0) {
1021         ALOGE("ERROR: MediaCodec native registration failed");
1022         goto bail;
1023     }
1024
1025     if (register_android_media_MediaExtractor(env) < 0) {
1026         ALOGE("ERROR: MediaCodec native registration failed");
1027         goto bail;
1028     }
1029
1030     if (register_android_media_MediaMuxer(env) < 0) {
1031         ALOGE("ERROR: MediaMuxer native registration failed");
1032         goto bail;
1033     }
1034
1035     if (register_android_media_MediaCodecList(env) < 0) {
1036         ALOGE("ERROR: MediaCodec native registration failed");
1037         goto bail;
1038     }
1039
1040     if (register_android_media_Crypto(env) < 0) {
1041         ALOGE("ERROR: MediaCodec native registration failed");
1042         goto bail;
1043     }
1044
1045     if (register_android_media_Drm(env) < 0) {
1046         ALOGE("ERROR: MediaDrm native registration failed");
1047         goto bail;
1048     }
1049
1050     /* success -- return valid version number */
1051     result = JNI_VERSION_1_4;
1052
1053 bail:
1054     return result;
1055 }
1056
1057 // KTHXBYE