auto import from //branches/cupcake/...@125939

12 files changed, 571 insertions, 36 deletions

diff --git a/core/jni/Android.mk b/core/jni/Android.mk
index 2c74ab7..c074b69 100644
--- a/core/jni/Android.mk
+++ b/core/jni/Android.mk
@@ -91,6 +91,7 @@ LOCAL_SRC_FILES:= \
 	android_media_AudioRecord.cpp \
 	android_media_AudioSystem.cpp \
 	android_media_AudioTrack.cpp \
+	android_media_JetPlayer.cpp \
 	android_media_ToneGenerator.cpp \
 	android_hardware_Camera.cpp \
 	android_hardware_SensorManager.cpp \
@@ -116,10 +117,14 @@ LOCAL_SRC_FILES:= \
 LOCAL_C_INCLUDES += \
 	$(JNI_H_INCLUDE) \
 	$(LOCAL_PATH)/android/graphics \
-	$(call include-path-for, bluedroid corecg graphics) \
+	$(call include-path-for, bluedroid) \
 	$(call include-path-for, libhardware)/hardware \
 	$(LOCAL_PATH)/../../include/ui \
 	$(LOCAL_PATH)/../../include/utils \
+	external/skia/include/core \
+	external/skia/include/effects \
+	external/skia/include/images \
+	external/skia/include/utils \
 	external/sqlite/dist \
 	external/sqlite/android \
 	external/expat/lib \
diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp
index f85f7d5..097ffac 100644
--- a/core/jni/AndroidRuntime.cpp
+++ b/core/jni/AndroidRuntime.cpp
@@ -74,6 +74,7 @@ extern int register_android_hardware_SensorManager(JNIEnv *env);
 extern int register_android_media_AudioRecord(JNIEnv *env);
 extern int register_android_media_AudioSystem(JNIEnv *env);
 extern int register_android_media_AudioTrack(JNIEnv *env);
+extern int register_android_media_JetPlayer(JNIEnv *env);
 extern int register_android_media_ToneGenerator(JNIEnv *env);
 
 extern int register_android_message_digest_sha1(JNIEnv *env);
@@ -1073,6 +1074,7 @@ static const RegJNIRec gRegJNI[] = {
     REG_JNI(register_android_media_AudioRecord),
     REG_JNI(register_android_media_AudioSystem),
     REG_JNI(register_android_media_AudioTrack),
+    REG_JNI(register_android_media_JetPlayer),
     REG_JNI(register_android_media_ToneGenerator),
 
     REG_JNI(register_android_opengl_classes),
diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp
index 27a6349..329a695 100644
--- a/core/jni/android/graphics/Bitmap.cpp
+++ b/core/jni/android/graphics/Bitmap.cpp
@@ -1,5 +1,5 @@
 #include "SkBitmap.h"

-#include "SkImageDecoder.h"

+#include "SkImageEncoder.h"

 #include "SkColorPriv.h"

 #include "GraphicsJNI.h"

 #include "SkDither.h"

diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp
index 841fe49..b9e5f67 100644
--- a/core/jni/android/graphics/Canvas.cpp
+++ b/core/jni/android/graphics/Canvas.cpp
@@ -800,7 +800,7 @@ public:
                               jobject bounds) {
         SkRect   r;
         SkIRect ir;
-        bool     result = canvas->getClipBounds(&r);
+        bool     result = canvas->getClipBounds(&r, SkCanvas::kBW_EdgeType);
 
         r.round(&ir);
         (void)GraphicsJNI::irect_to_jrect(ir, env, bounds);
diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp
index eef8bb2..b28eb90 100644
--- a/core/jni/android/graphics/Shader.cpp
+++ b/core/jni/android/graphics/Shader.cpp
@@ -4,7 +4,7 @@
 #include "SkShader.h"
 #include "SkGradientShader.h"
 #include "SkPorterDuff.h"
-#include "SkShaderExtras.h"
+#include "SkComposeShader.h"
 #include "SkTemplates.h"
 #include "SkXfermode.h"
 
diff --git a/core/jni/android/opengl/util.cpp b/core/jni/android/opengl/util.cpp
index 5cd2ceb..a1059e5 100644
--- a/core/jni/android/opengl/util.cpp
+++ b/core/jni/android/opengl/util.cpp
@@ -24,7 +24,7 @@
 
 #include <GLES/gl.h>
 
-#include <graphics/SkBitmap.h>
+#include <core/SkBitmap.h>
 
 #include "android_runtime/AndroidRuntime.h"
 
diff --git a/core/jni/android_hardware_Camera.cpp b/core/jni/android_hardware_Camera.cpp
index 4b126a6..e1ef459 100644
--- a/core/jni/android_hardware_Camera.cpp
+++ b/core/jni/android_hardware_Camera.cpp
@@ -225,6 +225,15 @@ static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz)
     c->stopPreview();
 }
 
+static bool android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz)
+{
+    sp<Camera> c = get_native_camera(env, thiz);
+    if (c == 0)
+        return false;
+
+    return c->previewEnabled();
+}
+
 static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed)
 {
     sp<Camera> c = get_native_camera(env, thiz);
@@ -382,6 +391,22 @@ static void android_hardware_Camera_reconnect(JNIEnv *env, jobject thiz)
     }
 }
 
+static jint android_hardware_Camera_lock(JNIEnv *env, jobject thiz)
+{
+    sp<Camera> c = get_native_camera(env, thiz);
+    if (c == 0)
+        return INVALID_OPERATION;
+    return (jint) c->lock();
+}
+
+static jint android_hardware_Camera_unlock(JNIEnv *env, jobject thiz)
+{
+    sp<Camera> c = get_native_camera(env, thiz);
+    if (c == 0)
+        return INVALID_OPERATION;
+    return (jint) c->lock();
+}
+
 //-------------------------------------------------
 
 static JNINativeMethod camMethods[] = {
@@ -400,6 +425,9 @@ static JNINativeMethod camMethods[] = {
   { "stopPreview",
     "()V",
     (void *)android_hardware_Camera_stopPreview },
+  { "previewEnabled",
+    "()Z",
+    (void *)android_hardware_Camera_previewEnabled },
   { "setHasPreviewCallback",
     "(Z)V",
     (void *)android_hardware_Camera_setHasPreviewCallback },
@@ -418,6 +446,12 @@ static JNINativeMethod camMethods[] = {
   { "reconnect",
     "()V",
     (void*)android_hardware_Camera_reconnect },
+  { "lock",
+    "()I",
+    (void*)android_hardware_Camera_lock },
+  { "unlock",
+    "()I",
+    (void*)android_hardware_Camera_unlock },
 };
 
 struct field {
diff --git a/core/jni/android_media_AudioTrack.cpp b/core/jni/android_media_AudioTrack.cpp
index 4a98fcc..6bbcaee 100644
--- a/core/jni/android_media_AudioTrack.cpp
+++ b/core/jni/android_media_AudioTrack.cpp
@@ -52,6 +52,7 @@ struct fields_t {
     int       STREAM_RING;           //...  stream type constants
     int       STREAM_MUSIC;          //...  stream type constants
     int       STREAM_ALARM;          //...  stream type constants
+    int       STREAM_NOTIFICATION;   //...  stream type constants
     int       MODE_STREAM;           //...  memory mode
     int       MODE_STATIC;           //...  memory mode
     jfieldID  nativeTrackInJavaObj; // stores in Java the native AudioTrack object
@@ -192,6 +193,8 @@ android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_th
         atStreamType = AudioTrack::MUSIC;
     } else if (streamType == javaAudioTrackFields.STREAM_ALARM) {
         atStreamType = AudioTrack::ALARM;
+    } else if (streamType == javaAudioTrackFields.STREAM_NOTIFICATION) {
+        atStreamType = AudioTrack::NOTIFICATION;
     } else {
         LOGE("Error creating AudioTrack: unknown stream type.");
         return AUDIOTRACK_ERROR_SETUP_INVALIDSTREAMTYPE;
@@ -696,22 +699,23 @@ static JNINativeMethod gMethods[] = {
 
 
 // field names found in android/media/AudioTrack.java
-#define JAVA_POSTEVENT_CALLBACK_NAME "postEventFromNative"
-#define JAVA_CONST_PCM16_NAME        "ENCODING_PCM_16BIT"
-#define JAVA_CONST_PCM8_NAME         "ENCODING_PCM_8BIT"
-#define JAVA_CONST_BUFFER_COUNT_NAME "BUFFER_COUNT"
-#define JAVA_CONST_STREAM_VOICE_CALL_NAME "STREAM_VOICE_CALL"
-#define JAVA_CONST_STREAM_SYSTEM_NAME     "STREAM_SYSTEM"
-#define JAVA_CONST_STREAM_RING_NAME       "STREAM_RING"
-#define JAVA_CONST_STREAM_MUSIC_NAME      "STREAM_MUSIC"
-#define JAVA_CONST_STREAM_ALARM_NAME      "STREAM_ALARM"
-#define JAVA_CONST_MODE_STREAM_NAME       "MODE_STREAM"
-#define JAVA_CONST_MODE_STATIC_NAME       "MODE_STATIC"
-#define JAVA_NATIVETRACKINJAVAOBJ_FIELD_NAME "mNativeTrackInJavaObj"
-#define JAVA_JNIDATA_FIELD_NAME              "mJniData"
-
-#define JAVA_AUDIOFORMAT_CLASS_NAME  "android/media/AudioFormat"
-#define JAVA_AUDIOMANAGER_CLASS_NAME "android/media/AudioManager"
+#define JAVA_POSTEVENT_CALLBACK_NAME            "postEventFromNative"
+#define JAVA_CONST_PCM16_NAME                   "ENCODING_PCM_16BIT"
+#define JAVA_CONST_PCM8_NAME                    "ENCODING_PCM_8BIT"
+#define JAVA_CONST_BUFFER_COUNT_NAME            "BUFFER_COUNT"
+#define JAVA_CONST_STREAM_VOICE_CALL_NAME       "STREAM_VOICE_CALL"
+#define JAVA_CONST_STREAM_SYSTEM_NAME           "STREAM_SYSTEM"
+#define JAVA_CONST_STREAM_RING_NAME             "STREAM_RING"
+#define JAVA_CONST_STREAM_MUSIC_NAME            "STREAM_MUSIC"
+#define JAVA_CONST_STREAM_ALARM_NAME            "STREAM_ALARM"
+#define JAVA_CONST_STREAM_NOTIFICATION_NAME     "STREAM_NOTIFICATION"
+#define JAVA_CONST_MODE_STREAM_NAME             "MODE_STREAM"
+#define JAVA_CONST_MODE_STATIC_NAME             "MODE_STATIC"
+#define JAVA_NATIVETRACKINJAVAOBJ_FIELD_NAME    "mNativeTrackInJavaObj"
+#define JAVA_JNIDATA_FIELD_NAME                 "mJniData"
+
+#define JAVA_AUDIOFORMAT_CLASS_NAME             "android/media/AudioFormat"
+#define JAVA_AUDIOMANAGER_CLASS_NAME            "android/media/AudioManager"
 
 // ----------------------------------------------------------------------------
 // preconditions:
@@ -820,7 +824,10 @@ int register_android_media_AudioTrack(JNIEnv *env)
                JAVA_CONST_STREAM_RING_NAME, &(javaAudioTrackFields.STREAM_RING))
           || !android_media_getIntConstantFromClass(env, audioManagerClass,
                JAVA_AUDIOMANAGER_CLASS_NAME, 
-               JAVA_CONST_STREAM_ALARM_NAME, &(javaAudioTrackFields.STREAM_ALARM)) ) {
+               JAVA_CONST_STREAM_ALARM_NAME, &(javaAudioTrackFields.STREAM_ALARM))
+          || !android_media_getIntConstantFromClass(env, audioManagerClass,
+               JAVA_AUDIOMANAGER_CLASS_NAME, 
+               JAVA_CONST_STREAM_NOTIFICATION_NAME, &(javaAudioTrackFields.STREAM_NOTIFICATION)) ) {
        // error log performed in android_media_getIntConstantFromClass()
        return -1;
     }
diff --git a/core/jni/android_media_JetPlayer.cpp b/core/jni/android_media_JetPlayer.cpp
new file mode 100644
index 0000000..994f161
--- /dev/null
+++ b/core/jni/android_media_JetPlayer.cpp
@@ -0,0 +1,485 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+//FIXME: remove log before release
+#define LOG_NDEBUG 0
+#define LOG_TAG "JET_JNI"
+
+
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "jni.h"
+#include "JNIHelp.h"
+#include "android_runtime/AndroidRuntime.h"
+
+#include "utils/Log.h"
+#include "media/JetPlayer.h"
+
+
+using namespace android;
+
+// ----------------------------------------------------------------------------
+static const char* const kClassPathName = "android/media/JetPlayer";
+
+// ----------------------------------------------------------------------------
+struct fields_t {
+    // these fields provide access from C++ to the...
+    jclass    jetClass;              // JetPlayer java class global ref
+    jmethodID postNativeEventInJava; // java method to post events to the Java thread from native
+    jfieldID  nativePlayerInJavaObj; // stores in Java the native JetPlayer object
+};
+
+static fields_t javaJetPlayerFields;
+
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+/*
+ * This function is called from JetPlayer instance's render thread
+ */
+static void
+jetPlayerEventCallback(int what, int arg1=0, int arg2=0, void* javaTarget = NULL)
+{
+    JNIEnv *env = AndroidRuntime::getJNIEnv();
+    if(env) {
+        env->CallStaticVoidMethod(
+            javaJetPlayerFields.jetClass, javaJetPlayerFields.postNativeEventInJava,
+            javaTarget,
+            what, arg1, arg2);
+        if (env->ExceptionCheck()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+        }
+    } else {
+        LOGE("JET jetPlayerEventCallback(): No JNI env for JET event callback, can't post event.");
+        return;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+static jboolean
+android_media_JetPlayer_setup(JNIEnv *env, jobject thiz, jobject weak_this,
+    jint maxTracks, jint trackBufferSize)
+{
+    //LOGV("android_media_JetPlayer_setup(): entering.");
+    JetPlayer* lpJet = new JetPlayer(weak_this, maxTracks, trackBufferSize);
+
+    EAS_RESULT result = lpJet->init();
+
+    if(result==EAS_SUCCESS) {
+        // save our newly created C++ JetPlayer in the "nativePlayerInJavaObj" field 
+        // of the Java object (in mNativePlayerInJavaObj)
+        env->SetIntField(thiz, javaJetPlayerFields.nativePlayerInJavaObj, (int)lpJet);
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_setup(): initialization failed with EAS error code %d", (int)result);
+        delete lpJet;
+        env->SetIntField(weak_this, javaJetPlayerFields.nativePlayerInJavaObj, 0);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static void
+android_media_JetPlayer_finalize(JNIEnv *env, jobject thiz)
+{
+    LOGV("android_media_JetPlayer_finalize(): entering.");
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if(lpJet != NULL) {
+        lpJet->release();
+        delete lpJet;
+    }
+
+    LOGV("android_media_JetPlayer_finalize(): exiting.");
+}
+
+
+// ----------------------------------------------------------------------------
+static void
+android_media_JetPlayer_release(JNIEnv *env, jobject thiz)
+{
+    android_media_JetPlayer_finalize(env, thiz);
+    env->SetIntField(thiz, javaJetPlayerFields.nativePlayerInJavaObj, 0);
+    LOGV("android_media_JetPlayer_release() done");   
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_openFile(JNIEnv *env, jobject thiz, jstring path)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    // set up event callback function
+    lpJet->setEventCallback(jetPlayerEventCallback);
+
+
+    const char *pathStr = env->GetStringUTFChars(path, NULL);
+    if (pathStr == NULL) {  // Out of memory
+        LOGE("android_media_JetPlayer_openFile(): aborting, out of memory");
+        jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
+        return JNI_FALSE;
+    }
+
+    LOGV("android_media_JetPlayer_openFile(): trying to open %s", pathStr );
+    EAS_RESULT result = lpJet->openFile(pathStr);
+    env->ReleaseStringUTFChars(path, pathStr);
+
+    if(result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_openFile(): file successfully opened");
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_openFile(): failed to open file with EAS error %d",
+            (int)result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_closeFile(JNIEnv *env, jobject thiz)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    if( lpJet->closeFile()==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_closeFile(): file successfully closed");
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_closeFile(): failed to close file");
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_play(JNIEnv *env, jobject thiz)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result = lpJet->play();
+    if( result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_play(): play successful");
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_play(): failed to play with EAS error code %ld", 
+            result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_pause(JNIEnv *env, jobject thiz)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result = lpJet->pause();
+    if( result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_pause(): pause successful");
+        return JNI_TRUE;
+    } else {
+        if(result==EAS_ERROR_QUEUE_IS_EMPTY) {
+            LOGV("android_media_JetPlayer_pause(): paused with an empty queue");
+            return JNI_TRUE;
+        } else
+            LOGE("android_media_JetPlayer_pause(): failed to pause with EAS error code %ld",
+                result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_queueSegment(JNIEnv *env, jobject thiz,
+        jint segmentNum, jint libNum, jint repeatCount, jint transpose, jint muteFlags,
+        jbyte userID)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result
+        = lpJet->queueSegment(segmentNum, libNum, repeatCount, transpose, muteFlags, userID);
+    if(result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_queueSegment(): segment successfully queued");
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_queueSegment(): failed with EAS error code %ld",
+            result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_queueSegmentMuteArray(JNIEnv *env, jobject thiz,
+        jint segmentNum, jint libNum, jint repeatCount, jint transpose, jbooleanArray muteArray,
+        jbyte userID)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result=EAS_FAILURE;
+
+    jboolean *muteTracks = NULL;
+    muteTracks = env->GetBooleanArrayElements(muteArray, NULL);
+    if (muteTracks == NULL) {
+        LOGE("android_media_JetPlayer_queueSegment(): failed to read track mute mask.");
+        return JNI_FALSE;
+    }
+
+    EAS_U32 muteMask=0;
+    int maxTracks = lpJet->getMaxTracks();
+    for (jint trackIndex=0; trackIndex<maxTracks; trackIndex++) {
+        if(muteTracks[maxTracks-1-trackIndex]==JNI_TRUE)
+            muteMask = (muteMask << 1) | 0x00000001;
+        else
+            muteMask = muteMask << 1;
+    }
+    //LOGV("android_media_JetPlayer_queueSegmentMuteArray(): FINAL mute mask =0x%08lX", mask);
+
+    result = lpJet->queueSegment(segmentNum, libNum, repeatCount, transpose, muteMask, userID);
+
+    env->ReleaseBooleanArrayElements(muteArray, muteTracks, 0);
+    if(result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_queueSegmentMuteArray(): segment successfully queued");
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_queueSegmentMuteArray(): failed with EAS error code %ld", 
+            result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_setMuteFlags(JNIEnv *env, jobject thiz,
+         jint muteFlags /*unsigned?*/, jboolean bSync)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result;
+    result = lpJet->setMuteFlags(muteFlags, bSync==JNI_TRUE ? true : false);
+    if(result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_setMuteFlags(): mute flags successfully updated");
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_setMuteFlags(): failed with EAS error code %ld", result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_setMuteArray(JNIEnv *env, jobject thiz,
+        jbooleanArray muteArray, jboolean bSync)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result=EAS_FAILURE;
+
+    jboolean *muteTracks = NULL;
+    muteTracks = env->GetBooleanArrayElements(muteArray, NULL);
+    if (muteTracks == NULL) {
+        LOGE("android_media_JetPlayer_setMuteArray(): failed to read track mute mask.");
+        return JNI_FALSE;
+    }
+
+    EAS_U32 muteMask=0;
+    int maxTracks = lpJet->getMaxTracks();
+    for (jint trackIndex=0; trackIndex<maxTracks; trackIndex++) {
+        if(muteTracks[maxTracks-1-trackIndex]==JNI_TRUE)
+            muteMask = (muteMask << 1) | 0x00000001;
+        else
+            muteMask = muteMask << 1;
+    }
+    //LOGV("android_media_JetPlayer_setMuteArray(): FINAL mute mask =0x%08lX", muteMask);
+
+    result = lpJet->setMuteFlags(muteMask, bSync==JNI_TRUE ? true : false);
+
+    env->ReleaseBooleanArrayElements(muteArray, muteTracks, 0);
+    if(result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_setMuteArray(): mute flags successfully updated");
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_setMuteArray(): failed to update mute flags with EAS error code %ld", result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_setMuteFlag(JNIEnv *env, jobject thiz,
+         jint trackId, jboolean muteFlag, jboolean bSync)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result;
+    result = lpJet->setMuteFlag(trackId, 
+        muteFlag==JNI_TRUE ? true : false, bSync==JNI_TRUE ? true : false);
+    if(result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_setMuteFlag(): mute flag successfully updated for track %d", trackId);
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_setMuteFlag(): failed to update mute flag for track %d with EAS error code %ld",
+                trackId, result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+static jboolean
+android_media_JetPlayer_triggerClip(JNIEnv *env, jobject thiz, jint clipId)
+{
+    JetPlayer *lpJet = (JetPlayer *)env->GetIntField(
+        thiz, javaJetPlayerFields.nativePlayerInJavaObj);
+    if (lpJet == NULL ) {
+        jniThrowException(env, "java/lang/IllegalStateException",
+            "Unable to retrieve JetPlayer pointer for openFile()");
+    }
+    
+    EAS_RESULT result;
+    result = lpJet->triggerClip(clipId);
+    if(result==EAS_SUCCESS) {
+        //LOGV("android_media_JetPlayer_triggerClip(): triggerClip successful for clip %d", clipId);
+        return JNI_TRUE;
+    } else {
+        LOGE("android_media_JetPlayer_triggerClip(): triggerClip for clip %d failed with EAS error code %ld",
+                clipId, result);
+        return JNI_FALSE;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+static JNINativeMethod gMethods[] = {
+    // name,               signature,               funcPtr
+    {"native_setup",       "(Ljava/lang/Object;II)Z", (void *)android_media_JetPlayer_setup},
+    {"native_finalize",    "()V",                   (void *)android_media_JetPlayer_finalize},
+    {"native_release",     "()V",                   (void *)android_media_JetPlayer_release},
+    {"native_openJetFile", "(Ljava/lang/String;)Z", (void *)android_media_JetPlayer_openFile},
+    {"native_closeJetFile","()Z",                   (void *)android_media_JetPlayer_closeFile},
+    {"native_playJet",     "()Z",                   (void *)android_media_JetPlayer_play},
+    {"native_pauseJet",    "()Z",                   (void *)android_media_JetPlayer_pause},
+    {"native_queueJetSegment",  
+                           "(IIIIIB)Z",             (void *)android_media_JetPlayer_queueSegment},
+    {"native_queueJetSegmentMuteArray", 
+                           "(IIII[ZB)Z",     (void *)android_media_JetPlayer_queueSegmentMuteArray},
+    {"native_setMuteFlags","(IZ)Z",                 (void *)android_media_JetPlayer_setMuteFlags},
+    {"native_setMuteArray","([ZZ)Z",                (void *)android_media_JetPlayer_setMuteArray},
+    {"native_setMuteFlag", "(IZZ)Z",                (void *)android_media_JetPlayer_setMuteFlag},
+    {"native_triggerClip", "(I)Z",                  (void *)android_media_JetPlayer_triggerClip},
+};
+
+#define JAVA_NATIVEJETPLAYERINJAVAOBJ_FIELD_NAME "mNativePlayerInJavaObj"
+#define JAVA_NATIVEJETPOSTEVENT_CALLBACK_NAME "postEventFromNative"
+
+
+int register_android_media_JetPlayer(JNIEnv *env)
+{
+    jclass jetPlayerClass = NULL;
+    javaJetPlayerFields.jetClass = NULL;
+    javaJetPlayerFields.postNativeEventInJava = NULL;
+    javaJetPlayerFields.nativePlayerInJavaObj = NULL;
+    
+    // Get the JetPlayer java class
+    jetPlayerClass = env->FindClass(kClassPathName);
+    if (jetPlayerClass == NULL) {
+        LOGE("Can't find %s", kClassPathName);
+        return -1;
+    }
+    javaJetPlayerFields.jetClass = (jclass)env->NewGlobalRef(jetPlayerClass);
+
+    // Get the mNativePlayerInJavaObj variable field
+    javaJetPlayerFields.nativePlayerInJavaObj = env->GetFieldID(
+            jetPlayerClass,
+            JAVA_NATIVEJETPLAYERINJAVAOBJ_FIELD_NAME, "I");
+    if (javaJetPlayerFields.nativePlayerInJavaObj == NULL) {
+        LOGE("Can't find AudioTrack.%s", JAVA_NATIVEJETPLAYERINJAVAOBJ_FIELD_NAME);
+        return -1;
+    }
+
+    // Get the callback to post events from this native code to Java
+    javaJetPlayerFields.postNativeEventInJava = env->GetStaticMethodID(javaJetPlayerFields.jetClass,
+            JAVA_NATIVEJETPOSTEVENT_CALLBACK_NAME, "(Ljava/lang/Object;III)V");
+    if (javaJetPlayerFields.postNativeEventInJava == NULL) {
+        LOGE("Can't find Jet.%s", JAVA_NATIVEJETPOSTEVENT_CALLBACK_NAME);
+        return -1;
+    }
+
+    return AndroidRuntime::registerNativeMethods(env,
+            kClassPathName, gMethods, NELEM(gMethods));
+}
diff --git a/core/jni/android_os_Power.cpp b/core/jni/android_os_Power.cpp
index 02a4083..4e70f63 100644
--- a/core/jni/android_os_Power.cpp
+++ b/core/jni/android_os_Power.cpp
@@ -2,19 +2,20 @@
 **
 ** Copyright 2006, 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 
+** 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 
+**     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 
+** 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.
 */
 
+#include "JNIHelp.h"
 #include "jni.h"
 #include "android_runtime/AndroidRuntime.h"
 #include <utils/misc.h>
@@ -100,6 +101,7 @@ static void android_os_Power_reboot(JNIEnv *env, jobject clazz, jstring reason)
                  LINUX_REBOOT_CMD_RESTART2, (char*) chars);
         env->ReleaseStringUTFChars(reason, chars);  // In case it fails.
     }
+    jniThrowIOException(env, errno);
 #endif
 }
 
diff --git a/core/jni/android_view_ViewRoot.cpp b/core/jni/android_view_ViewRoot.cpp
index 843d293..9d62d89 100644
--- a/core/jni/android_view_ViewRoot.cpp
+++ b/core/jni/android_view_ViewRoot.cpp
@@ -17,10 +17,10 @@
 #include <stdio.h>
 #include <assert.h>
 
-#include <graphics/SkCanvas.h>
-#include <graphics/SkDevice.h>
-#include <graphics/SkGLCanvas.h>
-#include <graphics/SkPaint.h>
+#include <core/SkCanvas.h>
+#include <core/SkDevice.h>
+#include <core/SkPaint.h>
+#include <utils/SkGLCanvas.h>
 #include "GraphicsJNI.h"
 
 #include "jni.h"
diff --git a/core/jni/com_google_android_gles_jni_EGLImpl.cpp b/core/jni/com_google_android_gles_jni_EGLImpl.cpp
index a985c24..8bacc74 100644
--- a/core/jni/com_google_android_gles_jni_EGLImpl.cpp
+++ b/core/jni/com_google_android_gles_jni_EGLImpl.cpp
@@ -23,8 +23,8 @@
 
 #include <ui/EGLNativeWindowSurface.h>
 #include <ui/Surface.h>
-#include <graphics/SkBitmap.h>
-#include <graphics/SkPixelRef.h>
+#include <SkBitmap.h>
+#include <SkPixelRef.h>
 
 namespace android {