20cb94eeb5
MediaPlayer.java has 3 new methods: * newRequest creates a Parcel that can be used to send data to the native player using invoke. * invoke issues synchronous calls to the native player using opaque parcels for the request and reply. IMediaPlayer.h has 1 new abstract method: * invoke The Midi and Vorbis players have a stub for these. So far only PV makes use of that new feature. To avoid any copy overhead, the JNI interface uses Parcel as a java object (no serialization/copy happens at the JNI layer). The remote interface token is inserted when the Parcel is constructed in java. That way the parcel is already routable when it reaches IMediaPlayer.cpp (proxy). No extra copy is needed there.
638 lines
21 KiB
C++
638 lines
21 KiB
C++
/* //device/libs/android_runtime/android_media_MediaPlayer.cpp
|
|
**
|
|
** Copyright 2007, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "MediaPlayer-JNI"
|
|
#include "utils/Log.h"
|
|
|
|
#include <media/mediaplayer.h>
|
|
#include <media/MediaPlayerInterface.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <utils/threads.h>
|
|
#include "jni.h"
|
|
#include "JNIHelp.h"
|
|
#include "android_runtime/AndroidRuntime.h"
|
|
#include "utils/Errors.h" // for status_t
|
|
#include "android_util_Binder.h"
|
|
#include <binder/Parcel.h>
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
using namespace android;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
struct fields_t {
|
|
jfieldID context;
|
|
jfieldID surface;
|
|
/* actually in android.view.Surface XXX */
|
|
jfieldID surface_native;
|
|
|
|
jmethodID post_event;
|
|
};
|
|
static fields_t fields;
|
|
|
|
static Mutex sLock;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ref-counted object for callbacks
|
|
class JNIMediaPlayerListener: public MediaPlayerListener
|
|
{
|
|
public:
|
|
JNIMediaPlayerListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
|
|
~JNIMediaPlayerListener();
|
|
void notify(int msg, int ext1, int ext2);
|
|
private:
|
|
JNIMediaPlayerListener();
|
|
jclass mClass; // Reference to MediaPlayer class
|
|
jobject mObject; // Weak ref to MediaPlayer Java object to call on
|
|
};
|
|
|
|
JNIMediaPlayerListener::JNIMediaPlayerListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
|
|
{
|
|
|
|
// Hold onto the MediaPlayer class for use in calling the static method
|
|
// that posts events to the application thread.
|
|
jclass clazz = env->GetObjectClass(thiz);
|
|
if (clazz == NULL) {
|
|
LOGE("Can't find android/media/MediaPlayer");
|
|
jniThrowException(env, "java/lang/Exception", NULL);
|
|
return;
|
|
}
|
|
mClass = (jclass)env->NewGlobalRef(clazz);
|
|
|
|
// We use a weak reference so the MediaPlayer object can be garbage collected.
|
|
// The reference is only used as a proxy for callbacks.
|
|
mObject = env->NewGlobalRef(weak_thiz);
|
|
}
|
|
|
|
JNIMediaPlayerListener::~JNIMediaPlayerListener()
|
|
{
|
|
// remove global references
|
|
JNIEnv *env = AndroidRuntime::getJNIEnv();
|
|
env->DeleteGlobalRef(mObject);
|
|
env->DeleteGlobalRef(mClass);
|
|
}
|
|
|
|
void JNIMediaPlayerListener::notify(int msg, int ext1, int ext2)
|
|
{
|
|
JNIEnv *env = AndroidRuntime::getJNIEnv();
|
|
env->CallStaticVoidMethod(mClass, fields.post_event, mObject, msg, ext1, ext2, 0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static sp<Surface> get_surface(JNIEnv* env, jobject clazz)
|
|
{
|
|
Surface* const p = (Surface*)env->GetIntField(clazz, fields.surface_native);
|
|
return sp<Surface>(p);
|
|
}
|
|
|
|
static sp<MediaPlayer> getMediaPlayer(JNIEnv* env, jobject thiz)
|
|
{
|
|
Mutex::Autolock l(sLock);
|
|
MediaPlayer* const p = (MediaPlayer*)env->GetIntField(thiz, fields.context);
|
|
return sp<MediaPlayer>(p);
|
|
}
|
|
|
|
static sp<MediaPlayer> setMediaPlayer(JNIEnv* env, jobject thiz, const sp<MediaPlayer>& player)
|
|
{
|
|
Mutex::Autolock l(sLock);
|
|
sp<MediaPlayer> old = (MediaPlayer*)env->GetIntField(thiz, fields.context);
|
|
if (player.get()) {
|
|
player->incStrong(thiz);
|
|
}
|
|
if (old != 0) {
|
|
old->decStrong(thiz);
|
|
}
|
|
env->SetIntField(thiz, fields.context, (int)player.get());
|
|
return old;
|
|
}
|
|
|
|
// If exception is NULL and opStatus is not OK, this method sends an error
|
|
// event to the client application; otherwise, if exception is not NULL and
|
|
// opStatus is not OK, this method throws the given exception to the client
|
|
// application.
|
|
static void process_media_player_call(JNIEnv *env, jobject thiz, status_t opStatus, const char* exception, const char *message)
|
|
{
|
|
if (exception == NULL) { // Don't throw exception. Instead, send an event.
|
|
if (opStatus != (status_t) OK) {
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp != 0) mp->notify(MEDIA_ERROR, opStatus, 0);
|
|
}
|
|
} else { // Throw exception!
|
|
if ( opStatus == (status_t) INVALID_OPERATION ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
} else if ( opStatus != (status_t) OK ) {
|
|
if (strlen(message) > 230) {
|
|
// if the message is too long, don't bother displaying the status code
|
|
jniThrowException( env, exception, message);
|
|
} else {
|
|
char msg[256];
|
|
// append the status code to the message
|
|
sprintf(msg, "%s: status=0x%X", message, opStatus);
|
|
jniThrowException( env, exception, msg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setDataSource(JNIEnv *env, jobject thiz, jstring path)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
|
|
if (path == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
|
|
const char *pathStr = env->GetStringUTFChars(path, NULL);
|
|
if (pathStr == NULL) { // Out of memory
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
LOGV("setDataSource: path %s", pathStr);
|
|
status_t opStatus = mp->setDataSource(pathStr);
|
|
|
|
// Make sure that local ref is released before a potential exception
|
|
env->ReleaseStringUTFChars(path, pathStr);
|
|
process_media_player_call( env, thiz, opStatus, "java/io/IOException", "setDataSource failed." );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
|
|
if (fileDescriptor == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
int fd = getParcelFileDescriptorFD(env, fileDescriptor);
|
|
LOGV("setDataSourceFD: fd %d", fd);
|
|
process_media_player_call( env, thiz, mp->setDataSource(fd, offset, length), "java/io/IOException", "setDataSourceFD failed." );
|
|
}
|
|
|
|
static void setVideoSurface(const sp<MediaPlayer>& mp, JNIEnv *env, jobject thiz)
|
|
{
|
|
jobject surface = env->GetObjectField(thiz, fields.surface);
|
|
if (surface != NULL) {
|
|
const sp<Surface>& native_surface = get_surface(env, surface);
|
|
LOGV("prepare: surface=%p (id=%d)",
|
|
native_surface.get(), native_surface->ID());
|
|
mp->setVideoSurface(native_surface);
|
|
}
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setVideoSurface(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
setVideoSurface(mp, env, thiz);
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_prepare(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
setVideoSurface(mp, env, thiz);
|
|
process_media_player_call( env, thiz, mp->prepare(), "java/io/IOException", "Prepare failed." );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
jobject surface = env->GetObjectField(thiz, fields.surface);
|
|
if (surface != NULL) {
|
|
const sp<Surface>& native_surface = get_surface(env, surface);
|
|
LOGV("prepareAsync: surface=%p (id=%d)",
|
|
native_surface.get(), native_surface->ID());
|
|
mp->setVideoSurface(native_surface);
|
|
}
|
|
process_media_player_call( env, thiz, mp->prepareAsync(), "java/io/IOException", "Prepare Async failed." );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_start(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("start");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->start(), NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_stop(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("stop");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->stop(), NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_pause(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("pause");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->pause(), NULL, NULL );
|
|
}
|
|
|
|
static jboolean
|
|
android_media_MediaPlayer_isPlaying(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return false;
|
|
}
|
|
const jboolean is_playing = mp->isPlaying();
|
|
|
|
LOGV("isPlaying: %d", is_playing);
|
|
return is_playing;
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_seekTo(JNIEnv *env, jobject thiz, int msec)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
LOGV("seekTo: %d(msec)", msec);
|
|
process_media_player_call( env, thiz, mp->seekTo(msec), NULL, NULL );
|
|
}
|
|
|
|
static int
|
|
android_media_MediaPlayer_getVideoWidth(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int w;
|
|
if (0 != mp->getVideoWidth(&w)) {
|
|
LOGE("getVideoWidth failed");
|
|
w = 0;
|
|
}
|
|
LOGV("getVideoWidth: %d", w);
|
|
return w;
|
|
}
|
|
|
|
static int
|
|
android_media_MediaPlayer_getVideoHeight(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int h;
|
|
if (0 != mp->getVideoHeight(&h)) {
|
|
LOGE("getVideoHeight failed");
|
|
h = 0;
|
|
}
|
|
LOGV("getVideoHeight: %d", h);
|
|
return h;
|
|
}
|
|
|
|
|
|
static int
|
|
android_media_MediaPlayer_getCurrentPosition(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int msec;
|
|
process_media_player_call( env, thiz, mp->getCurrentPosition(&msec), NULL, NULL );
|
|
LOGV("getCurrentPosition: %d (msec)", msec);
|
|
return msec;
|
|
}
|
|
|
|
static int
|
|
android_media_MediaPlayer_getDuration(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int msec;
|
|
process_media_player_call( env, thiz, mp->getDuration(&msec), NULL, NULL );
|
|
LOGV("getDuration: %d (msec)", msec);
|
|
return msec;
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_reset(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("reset");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->reset(), NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setAudioStreamType(JNIEnv *env, jobject thiz, int streamtype)
|
|
{
|
|
LOGV("setAudioStreamType: %d", streamtype);
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->setAudioStreamType(streamtype) , NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setLooping(JNIEnv *env, jobject thiz, jboolean looping)
|
|
{
|
|
LOGV("setLooping: %d", looping);
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->setLooping(looping), NULL, NULL );
|
|
}
|
|
|
|
static jboolean
|
|
android_media_MediaPlayer_isLooping(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("isLooping");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return false;
|
|
}
|
|
return mp->isLooping();
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setVolume(JNIEnv *env, jobject thiz, float leftVolume, float rightVolume)
|
|
{
|
|
LOGV("setVolume: left %f right %f", leftVolume, rightVolume);
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->setVolume(leftVolume, rightVolume), NULL, NULL );
|
|
}
|
|
|
|
// FIXME: deprecated
|
|
static jobject
|
|
android_media_MediaPlayer_getFrameAt(JNIEnv *env, jobject thiz, jint msec)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// Sends the request and reply parcels to the media player via the
|
|
// binder interface.
|
|
static jint
|
|
android_media_MediaPlayer_invoke(JNIEnv *env, jobject thiz,
|
|
jobject java_request, jobject java_reply)
|
|
{
|
|
sp<MediaPlayer> media_player = getMediaPlayer(env, thiz);
|
|
if (media_player == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
}
|
|
|
|
|
|
Parcel *request = parcelForJavaObject(env, java_request);
|
|
Parcel *reply = parcelForJavaObject(env, java_reply);
|
|
|
|
const status_t status = media_player->invoke(*request, reply);
|
|
// Don't use process_media_player_call which use the async loop to
|
|
// report errors, instead returns the status.
|
|
return status;
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
|
|
{
|
|
LOGV("native_setup");
|
|
sp<MediaPlayer> mp = new MediaPlayer();
|
|
if (mp == NULL) {
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
|
|
// create new listener and give it to MediaPlayer
|
|
sp<JNIMediaPlayerListener> listener = new JNIMediaPlayerListener(env, thiz, weak_this);
|
|
mp->setListener(listener);
|
|
|
|
// Stow our new C++ MediaPlayer in an opaque field in the Java object.
|
|
setMediaPlayer(env, thiz, mp);
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_release(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("release");
|
|
sp<MediaPlayer> mp = setMediaPlayer(env, thiz, 0);
|
|
if (mp != NULL) {
|
|
// this prevents native callbacks after the object is released
|
|
mp->setListener(0);
|
|
mp->disconnect();
|
|
}
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_native_finalize(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("native_finalize");
|
|
android_media_MediaPlayer_release(env, thiz);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static JNINativeMethod gMethods[] = {
|
|
{"setDataSource", "(Ljava/lang/String;)V", (void *)android_media_MediaPlayer_setDataSource},
|
|
{"setDataSource", "(Ljava/io/FileDescriptor;JJ)V", (void *)android_media_MediaPlayer_setDataSourceFD},
|
|
{"_setVideoSurface", "()V", (void *)android_media_MediaPlayer_setVideoSurface},
|
|
{"prepare", "()V", (void *)android_media_MediaPlayer_prepare},
|
|
{"prepareAsync", "()V", (void *)android_media_MediaPlayer_prepareAsync},
|
|
{"_start", "()V", (void *)android_media_MediaPlayer_start},
|
|
{"_stop", "()V", (void *)android_media_MediaPlayer_stop},
|
|
{"getVideoWidth", "()I", (void *)android_media_MediaPlayer_getVideoWidth},
|
|
{"getVideoHeight", "()I", (void *)android_media_MediaPlayer_getVideoHeight},
|
|
{"seekTo", "(I)V", (void *)android_media_MediaPlayer_seekTo},
|
|
{"_pause", "()V", (void *)android_media_MediaPlayer_pause},
|
|
{"isPlaying", "()Z", (void *)android_media_MediaPlayer_isPlaying},
|
|
{"getCurrentPosition", "()I", (void *)android_media_MediaPlayer_getCurrentPosition},
|
|
{"getDuration", "()I", (void *)android_media_MediaPlayer_getDuration},
|
|
{"_release", "()V", (void *)android_media_MediaPlayer_release},
|
|
{"_reset", "()V", (void *)android_media_MediaPlayer_reset},
|
|
{"setAudioStreamType", "(I)V", (void *)android_media_MediaPlayer_setAudioStreamType},
|
|
{"setLooping", "(Z)V", (void *)android_media_MediaPlayer_setLooping},
|
|
{"isLooping", "()Z", (void *)android_media_MediaPlayer_isLooping},
|
|
{"setVolume", "(FF)V", (void *)android_media_MediaPlayer_setVolume},
|
|
{"getFrameAt", "(I)Landroid/graphics/Bitmap;", (void *)android_media_MediaPlayer_getFrameAt},
|
|
{"native_invoke", "(Landroid/os/Parcel;Landroid/os/Parcel;)I",(void *)android_media_MediaPlayer_invoke},
|
|
{"native_setup", "(Ljava/lang/Object;)V", (void *)android_media_MediaPlayer_native_setup},
|
|
{"native_finalize", "()V", (void *)android_media_MediaPlayer_native_finalize},
|
|
};
|
|
|
|
static const char* const kClassPathName = "android/media/MediaPlayer";
|
|
|
|
static int register_android_media_MediaPlayer(JNIEnv *env)
|
|
{
|
|
jclass clazz;
|
|
|
|
clazz = env->FindClass("android/media/MediaPlayer");
|
|
if (clazz == NULL) {
|
|
LOGE("Can't find android/media/MediaPlayer");
|
|
return -1;
|
|
}
|
|
|
|
fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
|
|
if (fields.context == NULL) {
|
|
LOGE("Can't find MediaPlayer.mNativeContext");
|
|
return -1;
|
|
}
|
|
|
|
fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
|
|
"(Ljava/lang/Object;IIILjava/lang/Object;)V");
|
|
if (fields.post_event == NULL) {
|
|
LOGE("Can't find MediaPlayer.postEventFromNative");
|
|
return -1;
|
|
}
|
|
|
|
fields.surface = env->GetFieldID(clazz, "mSurface", "Landroid/view/Surface;");
|
|
if (fields.surface == NULL) {
|
|
LOGE("Can't find MediaPlayer.mSurface");
|
|
return -1;
|
|
}
|
|
|
|
jclass surface = env->FindClass("android/view/Surface");
|
|
if (surface == NULL) {
|
|
LOGE("Can't find android/view/Surface");
|
|
return -1;
|
|
}
|
|
|
|
fields.surface_native = env->GetFieldID(surface, "mSurface", "I");
|
|
if (fields.surface_native == NULL) {
|
|
LOGE("Can't find Surface fields");
|
|
return -1;
|
|
}
|
|
|
|
return AndroidRuntime::registerNativeMethods(env,
|
|
"android/media/MediaPlayer", gMethods, NELEM(gMethods));
|
|
}
|
|
|
|
extern int register_android_media_MediaRecorder(JNIEnv *env);
|
|
extern int register_android_media_MediaScanner(JNIEnv *env);
|
|
extern int register_android_media_MediaMetadataRetriever(JNIEnv *env);
|
|
extern int register_android_media_AmrInputStream(JNIEnv *env);
|
|
extern int register_android_media_ResampleInputStream(JNIEnv *env);
|
|
|
|
jint JNI_OnLoad(JavaVM* vm, void* reserved)
|
|
{
|
|
JNIEnv* env = NULL;
|
|
jint result = -1;
|
|
|
|
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
|
|
LOGE("ERROR: GetEnv failed\n");
|
|
goto bail;
|
|
}
|
|
assert(env != NULL);
|
|
|
|
if (register_android_media_MediaPlayer(env) < 0) {
|
|
LOGE("ERROR: MediaPlayer native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_MediaRecorder(env) < 0) {
|
|
LOGE("ERROR: MediaRecorder native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_MediaScanner(env) < 0) {
|
|
LOGE("ERROR: MediaScanner native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_MediaMetadataRetriever(env) < 0) {
|
|
LOGE("ERROR: MediaMetadataRetriever native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_AmrInputStream(env) < 0) {
|
|
LOGE("ERROR: AmrInputStream native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_ResampleInputStream(env) < 0) {
|
|
LOGE("ERROR: ResampleInputStream native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
/* success -- return valid version number */
|
|
result = JNI_VERSION_1_4;
|
|
|
|
bail:
|
|
return result;
|
|
}
|
|
|
|
// KTHXBYE
|