diff --git a/samples/BrowserPlugin/jni/Android.mk b/samples/BrowserPlugin/jni/Android.mk index 3d1c88f42..f296a1d73 100644 --- a/samples/BrowserPlugin/jni/Android.mk +++ b/samples/BrowserPlugin/jni/Android.mk @@ -35,8 +35,10 @@ LOCAL_SRC_FILES := \ background/BackgroundPlugin.cpp \ form/FormPlugin.cpp \ paint/PaintPlugin.cpp \ + hello-jni.cpp \ LOCAL_C_INCLUDES += \ + $(JNI_H_INCLUDE) \ $(LOCAL_PATH) \ $(LOCAL_PATH)/animation \ $(LOCAL_PATH)/audio \ @@ -48,6 +50,9 @@ LOCAL_C_INCLUDES += \ external/webkit/WebCore/platform/android/JavaVM \ external/webkit/WebKit/android/plugins +LOCAL_SHARED_LIBRARIES := \ + libnativehelper + LOCAL_SRC_FILES := $(LOCAL_SRC_FILES) LOCAL_CFLAGS += -fvisibility=hidden LOCAL_PRELINK_MODULE:=false diff --git a/samples/BrowserPlugin/jni/hello-jni.cpp b/samples/BrowserPlugin/jni/hello-jni.cpp new file mode 100644 index 000000000..0789b7e18 --- /dev/null +++ b/samples/BrowserPlugin/jni/hello-jni.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2009 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. + * + */ +#include +#include +#include +#include + +#define EXPORT __attribute__((visibility("default"))) + +static jstring stringFromJNI( JNIEnv* env, jobject thiz ) +{ + return env->NewStringUTF("Hello from JNI !"); +} + +/* + * JNI registration. + */ +static JNINativeMethod gJavaSamplePluginStubMethods[] = { + { "nativeStringFromJNI", "()Ljava/lang/String;", (void*) stringFromJNI }, +}; + +EXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) { + + JNIEnv* env = NULL; + + if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) { + return -1; + } + + jniRegisterNativeMethods(env, "com/android/sampleplugin/SamplePluginStub", + gJavaSamplePluginStubMethods, NELEM(gJavaSamplePluginStubMethods)); + + return JNI_VERSION_1_4; +} diff --git a/samples/BrowserPlugin/src/com/android/sampleplugin/SamplePluginStub.java b/samples/BrowserPlugin/src/com/android/sampleplugin/SamplePluginStub.java new file mode 100644 index 000000000..0b474a464 --- /dev/null +++ b/samples/BrowserPlugin/src/com/android/sampleplugin/SamplePluginStub.java @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2009 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. + */ + +package com.android.sampleplugin; + +import android.content.Context; +import android.graphics.PixelFormat; +import android.opengl.GLSurfaceView; +import android.view.View; +import android.view.WindowManager; +import android.view.ViewGroup.LayoutParams; +import android.webkit.PluginStub; +import android.widget.FrameLayout; +import android.widget.MediaController; +import android.widget.VideoView; +import com.android.sampleplugin.graphics.CubeRenderer; + +public class SamplePluginStub extends PluginStub { + + private int npp; + + public SamplePluginStub(int npp) { + super(npp); + this.npp = npp; + } + + public View getEmbeddedView(Context context) { + // TODO Auto-generated method stub + return null; + } + + public View getFullScreenView(Context context) { + + /* TODO make this aware of the plugin instance and get the video file + * from the plugin. + */ + + //needed for jni calls + System.loadLibrary("sampleplugin"); + + FrameLayout layout = new FrameLayout(context); + LayoutParams fp = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); + layout.setLayoutParams(fp); + + VideoView video = new VideoView(context); + LayoutParams vp = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); + layout.setLayoutParams(vp); + + GLSurfaceView gl = new GLSurfaceView(context); + LayoutParams gp = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); + layout.setLayoutParams(gp); + + layout.addView(video); + layout.addView(gl); + + // We want an 8888 pixel format because that's required for a translucent + // window. And we want a depth buffer. + gl.setEGLConfigChooser(8, 8, 8, 8, 16, 0); + // Tell the cube renderer that we want to render a translucent version + // of the cube: + gl.setRenderer(new CubeRenderer(true)); + // Use a surface format with an Alpha channel: + gl.getHolder().setFormat(PixelFormat.TRANSLUCENT); + gl.setWindowType(WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY); + + + video.setVideoPath("/sdcard/test_video.3gp"); + video.setMediaController(new MediaController(context)); + video.requestFocus(); + + return layout; + } + + public native String nativeStringFromJNI(); + +} diff --git a/samples/BrowserPlugin/src/com/android/sampleplugin/graphics/Cube.java b/samples/BrowserPlugin/src/com/android/sampleplugin/graphics/Cube.java new file mode 100644 index 000000000..9ad1410ea --- /dev/null +++ b/samples/BrowserPlugin/src/com/android/sampleplugin/graphics/Cube.java @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2009 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. + */ + +package com.android.sampleplugin.graphics; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; + +import javax.microedition.khronos.opengles.GL10; + +/** + * A vertex shaded cube. + */ +class Cube +{ + public Cube() + { + int one = 0x10000; + int vertices[] = { + -one, -one, -one, + one, -one, -one, + one, one, -one, + -one, one, -one, + -one, -one, one, + one, -one, one, + one, one, one, + -one, one, one, + }; + + int colors[] = { + 0, 0, 0, one, + one, 0, 0, one, + one, one, 0, one, + 0, one, 0, one, + 0, 0, one, one, + one, 0, one, one, + one, one, one, one, + 0, one, one, one, + }; + + byte indices[] = { + 0, 4, 5, 0, 5, 1, + 1, 5, 6, 1, 6, 2, + 2, 6, 7, 2, 7, 3, + 3, 7, 4, 3, 4, 0, + 4, 7, 6, 4, 6, 5, + 3, 0, 1, 3, 1, 2 + }; + + // Buffers to be passed to gl*Pointer() functions + // must be direct, i.e., they must be placed on the + // native heap where the garbage collector cannot + // move them. + // + // Buffers with multi-byte datatypes (e.g., short, int, float) + // must have their byte order set to native order + + ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length*4); + vbb.order(ByteOrder.nativeOrder()); + mVertexBuffer = vbb.asIntBuffer(); + mVertexBuffer.put(vertices); + mVertexBuffer.position(0); + + ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length*4); + cbb.order(ByteOrder.nativeOrder()); + mColorBuffer = cbb.asIntBuffer(); + mColorBuffer.put(colors); + mColorBuffer.position(0); + + mIndexBuffer = ByteBuffer.allocateDirect(indices.length); + mIndexBuffer.put(indices); + mIndexBuffer.position(0); + } + + public void draw(GL10 gl) + { + gl.glFrontFace(gl.GL_CW); + gl.glVertexPointer(3, gl.GL_FIXED, 0, mVertexBuffer); + gl.glColorPointer(4, gl.GL_FIXED, 0, mColorBuffer); + gl.glDrawElements(gl.GL_TRIANGLES, 36, gl.GL_UNSIGNED_BYTE, mIndexBuffer); + } + + private IntBuffer mVertexBuffer; + private IntBuffer mColorBuffer; + private ByteBuffer mIndexBuffer; +} diff --git a/samples/BrowserPlugin/src/com/android/sampleplugin/graphics/CubeRenderer.java b/samples/BrowserPlugin/src/com/android/sampleplugin/graphics/CubeRenderer.java new file mode 100644 index 000000000..246ac15a0 --- /dev/null +++ b/samples/BrowserPlugin/src/com/android/sampleplugin/graphics/CubeRenderer.java @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2009 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. + */ + +package com.android.sampleplugin.graphics; + +import javax.microedition.khronos.egl.EGL10; +import javax.microedition.khronos.egl.EGLConfig; +import javax.microedition.khronos.opengles.GL10; + +import android.opengl.GLSurfaceView; + +/** + * Render a pair of tumbling cubes. + */ + +public class CubeRenderer implements GLSurfaceView.Renderer { + public CubeRenderer(boolean useTranslucentBackground) { + mTranslucentBackground = useTranslucentBackground; + mCube = new Cube(); + } + + public void onDrawFrame(GL10 gl) { + /* + * Usually, the first thing one might want to do is to clear + * the screen. The most efficient way of doing this is to use + * glClear(). + */ + + gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); + + /* + * Now we're ready to draw some 3D objects + */ + + gl.glMatrixMode(GL10.GL_MODELVIEW); + gl.glLoadIdentity(); + gl.glTranslatef(0, 0, -3.0f); + gl.glRotatef(mAngle, 0, 1, 0); + gl.glRotatef(mAngle*0.25f, 1, 0, 0); + + gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); + gl.glEnableClientState(GL10.GL_COLOR_ARRAY); + + mCube.draw(gl); + + gl.glRotatef(mAngle*2.0f, 0, 1, 1); + gl.glTranslatef(0.5f, 0.5f, 0.5f); + + mCube.draw(gl); + + mAngle += 1.2f; + } + + public void onSurfaceChanged(GL10 gl, int width, int height) { + gl.glViewport(0, 0, width, height); + + /* + * Set our projection matrix. This doesn't have to be done + * each time we draw, but usually a new projection needs to + * be set when the viewport is resized. + */ + + float ratio = (float) width / height; + gl.glMatrixMode(GL10.GL_PROJECTION); + gl.glLoadIdentity(); + gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10); + } + + public void onSurfaceCreated(GL10 gl, EGLConfig config) { + /* + * By default, OpenGL enables features that improve quality + * but reduce performance. One might want to tweak that + * especially on software renderer. + */ + gl.glDisable(GL10.GL_DITHER); + + /* + * Some one-time OpenGL initialization can be made here + * probably based on features of this particular context + */ + gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, + GL10.GL_FASTEST); + + if (mTranslucentBackground) { + gl.glClearColor(0,0,0,0); + } else { + gl.glClearColor(1,1,1,1); + } + gl.glEnable(GL10.GL_CULL_FACE); + gl.glShadeModel(GL10.GL_SMOOTH); + gl.glEnable(GL10.GL_DEPTH_TEST); + } + private boolean mTranslucentBackground; + private Cube mCube; + private float mAngle; +}