Merge pull request #80 from apavlenko/android-samples-refactor

modules/java/CMakeLists.txt

@@ -237,7 +237,7 @@ if(ANDROID)
     set(lib_target_files ${ANDROID_LIB_PROJECT_FILES})
     ocv_list_add_prefix(lib_target_files "${OpenCV_BINARY_DIR}/")
 
-    android_get_compatible_target(lib_target_sdk_target ${ANDROID_NATIVE_API_LEVEL} ${ANDROID_SDK_TARGET})
+    android_get_compatible_target(lib_target_sdk_target ${ANDROID_NATIVE_API_LEVEL} ${ANDROID_SDK_TARGET} 11)
 
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/android_lib/${ANDROID_MANIFEST_FILE}"  "${CMAKE_CURRENT_BINARY_DIR}/${ANDROID_MANIFEST_FILE}")
 

modules/java/generator/src/java/android+JavaCameraView.java

+package org.opencv.android;
+
+import java.io.IOException;
+import java.util.List;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.graphics.ImageFormat;
+import android.graphics.SurfaceTexture;
+import android.hardware.Camera;
+import android.hardware.Camera.PreviewCallback;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.SurfaceHolder;
+
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.highgui.Highgui;
+import org.opencv.imgproc.Imgproc;
+
+/**
+ * This class is an implementation of the Bridge View between OpenCv and JAVA Camera.
+ * This class relays on the functionality available in base class and only implements
+ * required functions:
+ * connectCamera - opens Java camera and sets the PreviewCallback to be delivered.
+ * disconnectCamera - closes the camera and stops preview.
+ * When frame is delivered via callback from Camera - it processed via OpenCV to be
+ * converted to RGBA32 and then passed to the external callback for modifications if required.
+ */
+public class JavaCameraView extends CameraBridgeViewBase implements PreviewCallback {
+
+    private static final int MAGIC_TEXTURE_ID = 10;
+    private static final String TAG = "JavaCameraView";
+
+    private Mat mBaseMat;
+    private byte mBuffer[];
+
+    private Thread mThread;
+    private boolean mStopThread;
+
+    public static class JavaCameraSizeAccessor implements ListItemAccessor {
+
+        public int getWidth(Object obj) {
+            Camera.Size size = (Camera.Size) obj;
+            return size.width;
+        }
+
+        public int getHeight(Object obj) {
+            Camera.Size size = (Camera.Size) obj;
+            return size.height;
+        }
+    }
+
+    private Camera mCamera;
+
+    public JavaCameraView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        Log.d(TAG, "Java camera view ctor");
+    }
+
+    @TargetApi(11)
+    protected boolean initializeCamera(int width, int height) {
+        Log.d(TAG, "Initialize java camera");
+        synchronized (this) {
+            mCamera = null;
+
+            Log.d(TAG, "Trying to open camera with old open()");
+            try {
+                mCamera = Camera.open();
+            }
+            catch (Exception e){
+                Log.e(TAG, "Camera is not available (in use or does not exist): " + e.getLocalizedMessage());
+            }
+
+            if(mCamera == null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
+                boolean connected = false;
+                for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
+                    Log.d(TAG, "Trying to open camera with new open(" + Integer.valueOf(camIdx) + ")");
+                    try {
+                        mCamera = Camera.open(camIdx);
+                        connected = true;
+                    } catch (RuntimeException e) {
+                        Log.e(TAG, "Camera #" + camIdx + "failed to open: " + e.getLocalizedMessage());
+                    }
+                    if (connected) break;
+                }
+            }
+
+            if (mCamera == null)
+                return false;
+
+            /* Now set camera parameters */
+            try {
+                Camera.Parameters params = mCamera.getParameters();
+                Log.d(TAG, "getSupportedPreviewSizes()");
+                List<android.hardware.Camera.Size> sizes = params.getSupportedPreviewSizes();
+
+                /* Select the size that fits surface considering maximum size allowed */
+                Size frameSize = calculateCameraFrameSize(sizes, new JavaCameraSizeAccessor(), width, height);
+
+                params.setPreviewFormat(ImageFormat.NV21);
+                params.setPreviewSize((int)frameSize.width, (int)frameSize.height);
+
+                List<String> FocusModes = params.getSupportedFocusModes();
+                if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO))
+                {
+                    params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
+                }
+
+                mCamera.setParameters(params);
+                params = mCamera.getParameters();
+
+                mFrameWidth = params.getPreviewSize().width;
+                mFrameHeight = params.getPreviewSize().height;
+
+                int size = mFrameWidth * mFrameHeight;
+                size  = size * ImageFormat.getBitsPerPixel(params.getPreviewFormat()) / 8;
+                mBuffer = new byte[size];
+
+                mCamera.addCallbackBuffer(mBuffer);
+                mCamera.setPreviewCallbackWithBuffer(this);
+
+                mBaseMat = new Mat(mFrameHeight + (mFrameHeight/2), mFrameWidth, CvType.CV_8UC1);
+
+                AllocateCache();
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+                    SurfaceTexture tex = new SurfaceTexture(MAGIC_TEXTURE_ID);
+                    getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
+                    mCamera.setPreviewTexture(tex);
+                } else
+                   mCamera.setPreviewDisplay(null);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            /* Finally we are ready to start the preview */
+            Log.d(TAG, "startPreview");
+            mCamera.startPreview();
+        }
+
+        return true;
+    }
+
+    protected void releaseCamera() {
+        synchronized (this) {
+            mCamera.stopPreview();
+            mCamera.release();
+            mCamera = null;
+        }
+    }
+
+    @Override
+    protected boolean connectCamera(int width, int height) {
+
+        /* 1. We need to instantiate camera
+         * 2. We need to start thread which will be getting frames
+         */
+        /* First step - initialize camera connection */
+        Log.d(TAG, "Connecting to camera");
+        if (!initializeCamera(getWidth(), getHeight()))
+            return false;
+
+        /* now we can start update thread */
+        Log.d(TAG, "Starting processing thread");
+        mStopThread = false;
+        mThread = new Thread(new CameraWorker());
+        mThread.start();
+
+        return true;
+    }
+
+    protected void disconnectCamera() {
+        /* 1. We need to stop thread which updating the frames
+         * 2. Stop camera and release it
+         */
+        Log.d(TAG, "Disconnecting from camera");
+        try {
+            mStopThread = true;
+            Log.d(TAG, "Notify thread");
+            synchronized (this) {
+                this.notify();
+            }
+            Log.d(TAG, "Wating for thread");
+            mThread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            mThread =  null;
+        }
+
+        /* Now release camera */
+        releaseCamera();
+    }
+
+    public void onPreviewFrame(byte[] frame, Camera arg1) {
+        Log.i(TAG, "Preview Frame received. Need to create MAT and deliver it to clients");
+        Log.i(TAG, "Frame size  is " + frame.length);
+        synchronized (this)
+        {
+            mBaseMat.put(0, 0, frame);
+            this.notify();
+        }
+        if (mCamera != null)
+            mCamera.addCallbackBuffer(mBuffer);
+    }
+
+    private class CameraWorker implements Runnable {
+
+        public void run() {
+            do {
+                synchronized (JavaCameraView.this) {
+                    try {
+                        JavaCameraView.this.wait();
+                    } catch (InterruptedException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                    }
+                }
+
+                if (!mStopThread) {
+                    Mat frameMat = new Mat();
+                    switch (mPreviewFormat) {
+                        case Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA:
+                            Imgproc.cvtColor(mBaseMat, frameMat, Imgproc.COLOR_YUV2RGBA_NV21, 4);
+                        break;
+                        case Highgui.CV_CAP_ANDROID_GREY_FRAME:
+                            frameMat = mBaseMat.submat(0, mFrameHeight, 0, mFrameWidth);
+                        break;
+                        default:
+                            Log.e(TAG, "Invalid frame format! Only RGBA and Gray Scale are supported!");
+                    };
+                    deliverAndDrawFrame(frameMat);
+                    frameMat.release();
+                }
+            } while (!mStopThread);
+            Log.d(TAG, "Finish processing thread");
+        }
+    }
+}

modules/java/generator/src/java/android+NativeCameraView.java

+package org.opencv.android;
+
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.highgui.Highgui;
+import org.opencv.highgui.VideoCapture;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Log;
+
+/**
+ * This class is an implementation of a bridge between SurfaceView and native OpenCV camera.
+ * Due to the big amount of work done, by the base class this child is only responsible
+ * for creating camera, destroying camera and delivering frames while camera is enabled
+ */
+public class NativeCameraView extends CameraBridgeViewBase {
+
+    public static final String TAG = "NativeCameraView";
+    private boolean mStopThread;
+    private Thread mThread;
+    private VideoCapture mCamera;
+
+    public NativeCameraView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    protected boolean connectCamera(int width, int height) {
+
+        /* 1. We need to instantiate camera
+         * 2. We need to start thread which will be getting frames
+         */
+        /* First step - initialize camera connection */
+        if (!initializeCamera(getWidth(), getHeight()))
+            return false;
+
+        /* now we can start update thread */
+        mThread = new Thread(new CameraWorker());
+        mThread.start();
+
+        return true;
+    }
+
+    @Override
+    protected void disconnectCamera() {
+        /* 1. We need to stop thread which updating the frames
+         * 2. Stop camera and release it
+         */
+        try {
+            mStopThread = true;
+            mThread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            mThread =  null;
+            mStopThread = false;
+        }
+
+        /* Now release camera */
+        releaseCamera();
+    }
+
+    public static class OpenCvSizeAccessor implements ListItemAccessor {
+
+        public int getWidth(Object obj) {
+            Size size  = (Size)obj;
+            return (int)size.width;
+        }
+
+        public int getHeight(Object obj) {
+            Size size  = (Size)obj;
+            return (int)size.height;
+        }
+
+    }
+
+    private boolean initializeCamera(int width, int height) {
+        synchronized (this) {
+            mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
+
+            if (mCamera == null)
+                return false;
+
+            //TODO: improve error handling
+
+            java.util.List<Size> sizes = mCamera.getSupportedPreviewSizes();
+
+            /* Select the size that fits surface considering maximum size allowed */
+            Size frameSize = calculateCameraFrameSize(sizes, new OpenCvSizeAccessor(), width, height);
+
+            mFrameWidth = (int)frameSize.width;
+            mFrameHeight = (int)frameSize.height;
+
+            AllocateCache();
+
+            mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, frameSize.width);
+            mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, frameSize.height);
+        }
+
+        Log.i(TAG, "Selected camera frame size = (" + mFrameWidth + ", " + mFrameHeight + ")");
+
+        return true;
+    }
+
+    private void releaseCamera() {
+        synchronized (this) {
+            if (mCamera != null) {
+                mCamera.release();
+            }
+        }
+    }
+
+    private class CameraWorker implements Runnable {
+
+        private Mat mRgba = new Mat();
+        private Mat mGray = new Mat();
+
+        public void run() {
+            do {
+                if (!mCamera.grab()) {
+                    Log.e(TAG, "Camera frame grab failed");
+                    break;
+                }
+
+                switch (mPreviewFormat) {
+                    case Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA:
+                    {
+                        mCamera.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+                        deliverAndDrawFrame(mRgba);
+                    } break;
+                    case Highgui.CV_CAP_ANDROID_GREY_FRAME:
+                        mCamera.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+                        deliverAndDrawFrame(mGray);
+                        break;
+                    default:
+                        Log.e(TAG, "Invalid frame format! Only RGBA and Gray Scale are supported!");
+                }
+
+            } while (!mStopThread);
+
+        }
+    }
+
+}

samples/android/15-puzzle/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/15-puzzle/.project

 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>OpenCV Sample - 15-puzzle</name>
+	<name>15-puzzle</name>
 	<comment></comment>
 	<projects>
 	</projects>

samples/android/15-puzzle/.settings/org.eclipse.jdt.core.prefs

-#Wed Jun 29 04:36:40 MSD 2011
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
 org.eclipse.jdt.core.compiler.compliance=1.5

samples/android/15-puzzle/AndroidManifest.xml

-<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="org.opencv.samples.puzzle15"
-          android:versionCode="21"
-          android:versionName="2.1">
-
-    <application android:label="@string/app_name" android:icon="@drawable/icon">
-        <activity android:name="puzzle15Activity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="keyboardHidden|orientation">
+    package="org.opencv.samples.puzzle15"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk android:minSdkVersion="8"/>
+
+    <application
+        android:icon="@drawable/icon"
+        android:label="@string/app_name" >
+
+        <activity
+            android:name=".Puzzle15Activity"
+            android:label="@string/app_name"
+            android:screenOrientation="landscape"
+            android:configChanges="keyboardHidden|orientation" >
+
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
     </application>
 
-    <supports-screens android:resizeable="true"
-                      android:smallScreens="true"
-                      android:normalScreens="true"
-                      android:largeScreens="true"
-                      android:anyDensity="true" />
-
-    <uses-sdk android:minSdkVersion="8" />
-
     <uses-permission android:name="android.permission.CAMERA"/>
 
     <uses-feature android:name="android.hardware.camera" android:required="false"/>

samples/android/15-puzzle/res/layout/activity_puzzle15.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/puzzle_activity_surface_view" />
+
+</LinearLayout>

samples/android/15-puzzle/res/menu/activity_puzzle15.xml

+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:id="@+id/menu_start_new_game"
+        android:title="@string/menu_start_new_game"
+        android:orderInCategory="100" />
+    <item android:id="@+id/menu_toggle_tile_numbers" android:title="@string/menu_toggle_tile_numbers"></item>
+</menu>

samples/android/15-puzzle/res/values/strings.xml

-<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <string name="app_name">OCV 15 Puzzle</string>
-</resources>
+    <string name="menu_toggle_tile_numbers">Show/hide tile numbers</string>
+    <string name="menu_start_new_game">Start new game</string>
+
+</resources>
\ No newline at end of file

samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Activity.java

+package org.opencv.samples.puzzle15;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Mat;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
+import org.opencv.android.JavaCameraView;
+
+import android.os.Bundle;
+import android.app.Activity;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.Window;
+import android.view.View;
+
+public class Puzzle15Activity extends Activity implements CvCameraViewListener, View.OnTouchListener {
+
+    private static final String TAG = "Sample::Puzzle15::Activity";
+
+    private JavaCameraView mOpenCvCameraView;
+    private Puzzle15Processor mPuzzle15;
+
+    private int mGameWidth;
+    private int mGameHeight;
+
+    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
+
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+
+                    /* Now enable camera view to start receiving frames */
+                    mOpenCvCameraView.setOnTouchListener(Puzzle15Activity.this);
+                    mOpenCvCameraView.enableView();
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+
+        setContentView(R.layout.activity_puzzle15);
+
+        mOpenCvCameraView = (JavaCameraView) findViewById(R.id.puzzle_activity_surface_view);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+        mPuzzle15 = new Puzzle15Processor();
+        mPuzzle15.prepareNewGame();
+    }
+
+    @Override
+    public void onPause()
+    {
+        mOpenCvCameraView.disableView();
+        super.onPause();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mLoaderCallback);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.activity_puzzle15, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item.getItemId() == R.id.menu_start_new_game) {
+            /* We need to start new game */
+            mPuzzle15.prepareNewGame();
+        } else if (item.getItemId() == R.id.menu_toggle_tile_numbers) {
+            /* We need to enable or disable drawing of the tile numbers */
+            mPuzzle15.toggleTileNumbers();
+        }
+        return true;
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        mGameWidth = width;
+        mGameHeight = height;
+        mPuzzle15.prepareGameSize(width, height);
+    }
+
+    public void onCameraViewStopped() {
+    }
+
+    public Mat onCameraFrame(Mat inputFrame) {
+        return mPuzzle15.puzzleFrame(inputFrame);
+    }
+
+    public boolean onTouch(View view, MotionEvent event) {
+        int xpos, ypos;
+
+        xpos = (view.getWidth() - mGameWidth) / 2;
+        xpos = (int)event.getX() - xpos;
+
+        ypos = (view.getHeight() - mGameHeight) / 2;
+        ypos = (int)event.getY() - ypos;
+
+        if (xpos >=0 && xpos <= mGameWidth && ypos >=0  && ypos <= mGameHeight) {
+            /* click is inside the picture. Deliver this event to processor */
+            mPuzzle15.deliverTouchEvent(xpos, ypos);
+        }
+
+        return false;
+    }
+}

samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Processor.java

+package org.opencv.samples.puzzle15;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.core.Point;
+
+import android.util.Log;
+
+
+/**
+ * This class is a controller for puzzle game.
+ * It converts the image from Camera into the shuffled image
+ */
+public class Puzzle15Processor {
+
+    private static final int GRID_SIZE = 4;
+    private static final int GRID_AREA = GRID_SIZE * GRID_SIZE;
+    private static final int GRID_EMPTY_INDEX = GRID_AREA - 1;
+    private static final String TAG = "Puzzle15Processor";
+
+    private int[]   mIndexes;
+    private int[]   mTextWidths;
+    private int[]   mTextHeights;
+
+    private Mat mRgba15;
+
+    private Mat[] mCells;
+    private Mat[] mCells15;
+    private boolean mShowTileNumbers = true;
+
+    public Puzzle15Processor() {
+        mTextWidths = new int[GRID_AREA];
+        mTextHeights = new int[GRID_AREA];
+
+        mIndexes = new int [GRID_AREA];
+
+        for (int i = 0; i < GRID_AREA; i++)
+            mIndexes[i] = i;
+    }
+
+    /* this method is intended to make processor prepared for a new game */
+    public synchronized void prepareNewGame() {
+        do {
+            shuffle(mIndexes);
+        } while (!isPuzzleSolvable());
+    }
+
+    /* This method is to make the processor know the size of the frames that
+     * will be delivered via puzzleFrame.
+     * If the frames will be different size - then the result is unpredictable
+     */
+    public synchronized void prepareGameSize(int width, int height) {
+        mRgba15 = new Mat(height, width, CvType.CV_8UC4);
+
+        mCells = new Mat[GRID_AREA];
+        mCells15 = new Mat[GRID_AREA];
+
+        for (int i = 0; i < GRID_SIZE; i++) {
+            for (int j = 0; j < GRID_SIZE; j++) {
+                int k = i * GRID_SIZE + j;
+                mCells15[k] = mRgba15.submat(i * height / GRID_SIZE, (i + 1) * height / GRID_SIZE, j * width / GRID_SIZE, (j + 1) * width / GRID_SIZE);
+            }
+        }
+
+        for (int i = 0; i < GRID_AREA; i++) {
+            Size s = Core.getTextSize(Integer.toString(i + 1), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, 2, null);
+            mTextHeights[i] = (int) s.height;
+            mTextWidths[i] = (int) s.width;
+        }
+    }
+
+    /* this method to be called from the outside. it processes the frame and shuffles
+     * the tiles as specified by mIndexes array
+     */
+    public synchronized Mat puzzleFrame(Mat inputPicture) {
+        int rows = inputPicture.rows();
+        int cols = inputPicture.cols();
+
+        rows = rows - rows%4;
+        cols = cols - cols%4;
+
+        for (int i = 0; i < GRID_SIZE; i++) {
+            for (int j = 0; j < GRID_SIZE; j++) {
+                int k = i * GRID_SIZE + j;
+                mCells[k] = inputPicture.submat(i * inputPicture.rows() / GRID_SIZE, (i + 1) * inputPicture.rows() / GRID_SIZE, j * inputPicture.cols()/ GRID_SIZE, (j + 1) * inputPicture.cols() / GRID_SIZE);
+            }
+        }
+
+        rows = rows - rows%4;
+        cols = cols - cols%4;
+
+        // copy shuffled tiles
+        for (int i = 0; i < GRID_AREA; i++) {
+            int idx = mIndexes[i];
+            if (idx == GRID_EMPTY_INDEX)
+                mCells15[i].setTo(new Scalar(0x33, 0x33, 0x33, 0xFF));
+            else {
+                mCells[idx].copyTo(mCells15[i]);
+                if (mShowTileNumbers) {
+                    Core.putText(mCells15[i], Integer.toString(1 + idx), new Point((cols / GRID_SIZE - mTextWidths[idx]) / 2,
+                            (rows / GRID_SIZE + mTextHeights[idx]) / 2), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, new Scalar(255, 0, 0, 255), 2);
+                }
+            }
+        }
+
+        drawGrid(cols, rows, mRgba15);
+
+        return mRgba15;
+    }
+
+    public void toggleTileNumbers() {
+        mShowTileNumbers = !mShowTileNumbers;
+    }
+
+    public void deliverTouchEvent(int x, int y) {
+        int rows = mRgba15.rows();
+        int cols = mRgba15.cols();
+
+        int row = (int) Math.floor(y * GRID_SIZE / rows);
+        int col = (int) Math.floor(x * GRID_SIZE / cols);
+
+        if (row < 0 || row >= GRID_SIZE || col < 0 || col >= GRID_SIZE) {
+            Log.e(TAG, "It is not expected to get touch event outside of picture");
+            return ;
+        }
+
+        int idx = row * GRID_SIZE + col;
+        int idxtoswap = -1;
+
+        // left
+        if (idxtoswap < 0 && col > 0)
+            if (mIndexes[idx - 1] == GRID_EMPTY_INDEX)
+                idxtoswap = idx - 1;
+        // right
+        if (idxtoswap < 0 && col < GRID_SIZE - 1)
+            if (mIndexes[idx + 1] == GRID_EMPTY_INDEX)
+                idxtoswap = idx + 1;
+        // top
+        if (idxtoswap < 0 && row > 0)
+            if (mIndexes[idx - GRID_SIZE] == GRID_EMPTY_INDEX)
+                idxtoswap = idx - GRID_SIZE;
+        // bottom
+        if (idxtoswap < 0 && row < GRID_SIZE - 1)
+            if (mIndexes[idx + GRID_SIZE] == GRID_EMPTY_INDEX)
+                idxtoswap = idx + GRID_SIZE;
+
+        // swap
+        if (idxtoswap >= 0) {
+            synchronized (this) {
+                int touched = mIndexes[idx];
+                mIndexes[idx] = mIndexes[idxtoswap];
+                mIndexes[idxtoswap] = touched;
+            }
+        }
+    }
+
+    private void drawGrid(int cols, int rows, Mat drawMat) {
+        for (int i = 1; i < GRID_SIZE; i++) {
+            Core.line(drawMat, new Point(0, i * rows / GRID_SIZE), new Point(cols, i * rows / GRID_SIZE), new Scalar(0, 255, 0, 255), 3);
+            Core.line(drawMat, new Point(i * cols / GRID_SIZE, 0), new Point(i * cols / GRID_SIZE, rows), new Scalar(0, 255, 0, 255), 3);
+        }
+    }
+
+    private static void shuffle(int[] array) {
+        for (int i = array.length; i > 1; i--) {
+            int temp = array[i - 1];
+            int randIx = (int) (Math.random() * i);
+            array[i - 1] = array[randIx];
+            array[randIx] = temp;
+        }
+    }
+
+    private boolean isPuzzleSolvable() {
+
+        int sum = 0;
+        for (int i = 0; i < GRID_AREA; i++) {
+            if (mIndexes[i] == GRID_EMPTY_INDEX)
+                sum += (i / GRID_SIZE) + 1;
+            else {
+                int smaller = 0;
+                for (int j = i + 1; j < GRID_AREA; j++) {
+                    if (mIndexes[j] < mIndexes[i])
+                        smaller++;
+                }
+                sum += smaller;
+            }
+        }
+        return sum % 2 == 0;
+    }
+}

samples/android/15-puzzle/src/org/opencv/samples/puzzle15/SampleCvViewBase.java

-package org.opencv.samples.puzzle15;
-
-import java.util.List;
-
-import org.opencv.core.Size;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.highgui.Highgui;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.util.Log;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
-    private static final String TAG = "OCVSample::BaseView";
-
-    private SurfaceHolder       mHolder;
-    private VideoCapture        mCamera;
-
-    public SampleCvViewBase(Context context) {
-        super(context);
-        mHolder = getHolder();
-        mHolder.addCallback(this);
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    public synchronized boolean openCamera() {
-        Log.i(TAG, "Opening Camera");
-        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
-        if (!mCamera.isOpened()) {
-            releaseCamera();
-            Log.e(TAG, "Can't open native camera");
-            return false;
-        }
-        return true;
-    }
-
-    public synchronized void releaseCamera() {
-        Log.i(TAG, "Releasing Camera");
-        if (mCamera != null) {
-                mCamera.release();
-                mCamera = null;
-        }
-    }
-
-    public synchronized void setupCamera(int width, int height) {
-        if (mCamera != null && mCamera.isOpened()) {
-            Log.i(TAG, "Setup Camera - " + width + "x" + height);
-            List<Size> sizes = mCamera.getSupportedPreviewSizes();
-            int mFrameWidth = width;
-            int mFrameHeight = height;
-
-            // selecting optimal camera preview size
-            {
-                double minDiff = Double.MAX_VALUE;
-                for (Size size : sizes) {
-                    if (Math.abs(size.height - height) < minDiff) {
-                        mFrameWidth = (int) size.width;
-                        mFrameHeight = (int) size.height;
-                        minDiff = Math.abs(size.height - height);
-                    }
-                }
-            }
-
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
-        }
-    }
-
-    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
-        Log.i(TAG, "called surfaceChanged");
-        setupCamera(width, height);
-    }
-
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        (new Thread(this)).start();
-    }
-
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceDestroyed");
-    }
-
-    protected abstract Bitmap processFrame(VideoCapture capture);
-
-    public void run() {
-        Log.i(TAG, "Started processing thread");
-        while (true) {
-            Bitmap bmp = null;
-
-            synchronized (this) {
-                if (mCamera == null)
-                    break;
-
-                if (!mCamera.grab()) {
-                    Log.e(TAG, "mCamera.grab() failed");
-                    break;
-                }
-
-                bmp = processFrame(mCamera);
-            }
-
-            if (bmp != null) {
-                Canvas canvas = mHolder.lockCanvas();
-                if (canvas != null) {
-                    canvas.drawColor(0, android.graphics.PorterDuff.Mode.CLEAR);
-                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
-                    mHolder.unlockCanvasAndPost(canvas);
-                }
-                bmp.recycle();
-            }
-        }
-        Log.i(TAG, "Finished processing thread");
-    }
-}
\ No newline at end of file

samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15Activity.java

-package org.opencv.samples.puzzle15;
-
-import org.opencv.android.BaseLoaderCallback;
-import org.opencv.android.LoaderCallbackInterface;
-import org.opencv.android.OpenCVLoader;
-
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
-import android.os.Bundle;
-import android.util.Log;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.Window;
-import android.view.WindowManager;
-
-/** Activity class implements LoaderCallbackInterface to handle OpenCV initialization status **/
-public class puzzle15Activity extends Activity {
-    private static final String TAG             = "OCVSample::Activity";
-
-    private MenuItem            mItemNewGame;
-    private MenuItem            mItemToggleNumbers;
-    private puzzle15View        mView = null;
-
-    private BaseLoaderCallback  mOpenCVCallBack = new BaseLoaderCallback(this) {
-        @Override
-        public void onManagerConnected(int status) {
-            switch (status) {
-                case LoaderCallbackInterface.SUCCESS:
-                {
-                    Log.i(TAG, "OpenCV loaded successfully");
-                    // Create and set View
-                    mView = new puzzle15View(mAppContext);
-                    setContentView(mView);
-
-                    // Check native OpenCV camera
-                    if( !mView.openCamera() ) {
-                        AlertDialog ad = new AlertDialog.Builder(mAppContext).create();
-                        ad.setCancelable(false); // This blocks the 'BACK' button
-                        ad.setMessage("Fatal error: can't open camera!");
-                        ad.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                            public void onClick(DialogInterface dialog, int which) {
-                                dialog.dismiss();
-                                finish();
-                            }
-                        });
-                        ad.show();
-                    }
-                } break;
-
-                /** OpenCV loader cannot start Google Play **/
-                case LoaderCallbackInterface.MARKET_ERROR:
-                {
-                    Log.d(TAG, "Google Play service is not accessible!");
-                    AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
-                    MarketErrorMessage.setTitle("OpenCV Manager");
-                    MarketErrorMessage.setMessage("Google Play service is not accessible!\nTry to install the 'OpenCV Manager' and the appropriate 'OpenCV binary pack' APKs from OpenCV SDK manually via 'adb install' command.");
-                    MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
-                    MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                        public void onClick(DialogInterface dialog, int which) {
-                            finish();
-                        }
-                    });
-                    MarketErrorMessage.show();
-                } break;
-                default:
-                {
-                    super.onManagerConnected(status);
-                } break;
-            }
-        }
-    };
-
-    public puzzle15Activity() {
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    @Override
-    protected void onPause() {
-        Log.i(TAG, "called onPause");
-        if (null != mView)
-            mView.releaseCamera();
-        super.onPause();
-    }
-
-    @Override
-    protected void onResume() {
-        Log.i(TAG, "called onResume");
-        super.onResume();
-
-        Log.i(TAG, "Trying to load OpenCV library");
-        if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mOpenCVCallBack)) {
-            Log.e(TAG, "Cannot connect to OpenCV Manager");
-        }
-    }
-
-    /** Called when the activity is first created. */
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        Log.i(TAG, "called onCreate");
-        super.onCreate(savedInstanceState);
-        requestWindowFeature(Window.FEATURE_NO_TITLE);
-        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
-    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        Log.i(TAG, "called onCreateOptionsMenu");
-        mItemNewGame = menu.add("Start new game");
-        mItemToggleNumbers = menu.add("Show/hide tile numbers");
-        return true;
-    }
-
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
-        if (item == mItemNewGame)
-            mView.startNewGame();
-        else if (item == mItemToggleNumbers)
-            mView.tolggleTileNumbers();
-        return true;
-    }
-}
\ No newline at end of file

samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15View.java

-package org.opencv.samples.puzzle15;
-
-import org.opencv.android.Utils;
-import org.opencv.core.Core;
-import org.opencv.core.Mat;
-import org.opencv.core.Size;
-import org.opencv.core.Point;
-import org.opencv.core.Scalar;
-import org.opencv.highgui.Highgui;
-import org.opencv.highgui.VideoCapture;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.util.Log;
-import android.view.MotionEvent;
-import android.view.SurfaceHolder;
-import android.view.View;
-import android.view.View.OnTouchListener;
-
-public class puzzle15View extends SampleCvViewBase implements OnTouchListener {
-    private static final String TAG = "OCVSample::View";
-
-    private Mat     mRgba;
-    private Mat     mRgba15;
-    private Mat[]   mCells;
-    private Mat[]   mCells15;
-    private int[]   mIndexses;
-    private int[]   mTextWidths;
-    private int[]   mTextHeights;
-    private boolean mShowTileNumbers = true;
-
-    int             gridSize         = 4;
-    int             gridArea         = gridSize * gridSize;
-    int             gridEmptyIdx     = gridArea - 1;
-
-    public puzzle15View(Context context) {
-        super(context);
-        setOnTouchListener(this);
-
-        mTextWidths = new int[gridArea];
-        mTextHeights = new int[gridArea];
-        for (int i = 0; i < gridArea; i++) {
-            Size s = Core.getTextSize(Integer.toString(i + 1), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, 2, null);
-            mTextHeights[i] = (int) s.height;
-            mTextWidths[i] = (int) s.width;
-        }
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    @Override
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        synchronized (this) {
-            // initialize Mat before usage
-            mRgba = new Mat();
-        }
-
-        super.surfaceCreated(holder);
-    }
-
-    public static void shuffle(int[] array) {
-        for (int i = array.length; i > 1; i--) {
-            int temp = array[i - 1];
-            int randIx = (int) (Math.random() * i);
-            array[i - 1] = array[randIx];
-            array[randIx] = temp;
-        }
-    }
-
-    public boolean isPuzzleSolvable() {
-        if (gridSize != 4)
-            return true;
-
-        int sum = 0;
-        for (int i = 0; i < gridArea; i++) {
-            if (mIndexses[i] == gridEmptyIdx)
-                sum += (i / gridSize) + 1;
-            else {
-                int smaller = 0;
-                for (int j = i + 1; j < gridArea; j++) {
-                    if (mIndexses[j] < mIndexses[i])
-                        smaller++;
-                }
-                sum += smaller;
-            }
-        }
-
-        return sum % 2 == 0;
-    }
-
-    private void createPuzzle(int cols, int rows, int type) {
-        mCells = new Mat[gridArea];
-        mCells15 = new Mat[gridArea];
-
-        mRgba15 = new Mat(rows, cols, type);
-        mIndexses = new int[gridArea];
-
-        for (int i = 0; i < gridSize; i++) {
-            for (int j = 0; j < gridSize; j++) {
-                int k = i * gridSize + j;
-                mIndexses[k] = k;
-                mCells[k] = mRgba.submat(i * rows / gridSize, (i + 1) * rows / gridSize, j * cols / gridSize, (j + 1) * cols / gridSize);
-                mCells15[k] = mRgba15.submat(i * rows / gridSize, (i + 1) * rows / gridSize, j * cols / gridSize, (j + 1) * cols / gridSize);
-            }
-        }
-
-        startNewGame();
-    }
-
-    private void drawGrid(int cols, int rows) {
-        for (int i = 1; i < gridSize; i++) {
-            Core.line(mRgba15, new Point(0, i * rows / gridSize), new Point(cols, i * rows / gridSize), new Scalar(0, 255, 0, 255), 3);
-            Core.line(mRgba15, new Point(i * cols / gridSize, 0), new Point(i * cols / gridSize, rows), new Scalar(0, 255, 0, 255), 3);
-        }
-    }
-
-    public synchronized void startNewGame() {
-        do {
-            shuffle(mIndexses);
-        } while (!isPuzzleSolvable());
-    }
-
-    public void tolggleTileNumbers() {
-        mShowTileNumbers = !mShowTileNumbers;
-    }
-
-    @Override
-    protected Bitmap processFrame(VideoCapture capture) {
-        capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
-        int cols = mRgba.cols();
-        int rows = mRgba.rows();
-
-        rows = rows - rows%4;
-        cols = cols - cols%4;
-
-        if (mCells == null)
-            createPuzzle(cols, rows, mRgba.type());
-        else if(mRgba15.cols() != cols || mRgba15.rows() != rows) {
-            releaseMats();
-            createPuzzle(cols, rows, mRgba.type());
-        }
-
-        // copy shuffled tiles
-        for (int i = 0; i < gridArea; i++) {
-            int idx = mIndexses[i];
-            if (idx == gridEmptyIdx)
-                mCells15[i].setTo(new Scalar(0x33, 0x33, 0x33, 0xFF));
-            else {
-                mCells[idx].copyTo(mCells15[i]);
-                if (mShowTileNumbers) {
-                    Core.putText(mCells15[i], Integer.toString(1 + idx), new Point((cols / gridSize - mTextWidths[idx]) / 2,
-                            (rows / gridSize + mTextHeights[idx]) / 2), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, new Scalar(255, 0, 0, 255), 2);
-                }
-            }
-        }
-
-        drawGrid(cols, rows);
-        Bitmap bmp = Bitmap.createBitmap(cols, rows, Bitmap.Config.ARGB_8888);
-        try {
-            Utils.matToBitmap(mRgba15, bmp);
-            return bmp;
-        } catch(Exception e) {
-            Log.e("org.opencv.samples.puzzle15", "Utils.matToBitmap() throws an exception: " + e.getMessage());
-            bmp.recycle();
-            return null;
-        }
-    }
-
-    @Override
-    public void run() {
-        super.run();
-
-        synchronized (this) {
-            releaseMats();
-
-            if (mRgba != null)
-                mRgba.release();
-            mRgba = null;
-        }
-    }
-
-    private void releaseMats() {
-        // Explicitly deallocate Mats
-        if (mCells != null) {
-            for (Mat m : mCells)
-                m.release();
-        }
-        if (mCells15 != null) {
-            for (Mat m : mCells15)
-                m.release();
-        }
-
-        if (mRgba15 != null)
-            mRgba15.release();
-
-        mRgba15 = null;
-        mCells = null;
-        mCells15 = null;
-        mIndexses = null;
-    }
-
-    public boolean onTouch(View v, MotionEvent event) {
-        if(mRgba==null) return false;
-
-        int cols = mRgba.cols();
-        int rows = mRgba.rows();
-        float xoffset = (getWidth() - cols) / 2;
-        float yoffset = (getHeight() - rows) / 2;
-
-        float x = event.getX() - xoffset;
-        float y = event.getY() - yoffset;
-
-        int row = (int) Math.floor(y * gridSize / rows);
-        int col = (int) Math.floor(x * gridSize / cols);
-
-        if (row < 0 || row >= gridSize || col < 0 || col >= gridSize)
-            return false;
-
-        int idx = row * gridSize + col;
-        int idxtoswap = -1;
-
-        // left
-        if (idxtoswap < 0 && col > 0)
-            if (mIndexses[idx - 1] == gridEmptyIdx)
-                idxtoswap = idx - 1;
-        // right
-        if (idxtoswap < 0 && col < gridSize - 1)
-            if (mIndexses[idx + 1] == gridEmptyIdx)
-                idxtoswap = idx + 1;
-        // top
-        if (idxtoswap < 0 && row > 0)
-            if (mIndexses[idx - gridSize] == gridEmptyIdx)
-                idxtoswap = idx - gridSize;
-        // bottom
-        if (idxtoswap < 0 && row < gridSize - 1)
-            if (mIndexses[idx + gridSize] == gridEmptyIdx)
-                idxtoswap = idx + gridSize;
-
-        // swap
-        if (idxtoswap >= 0) {
-            synchronized (this) {
-                int touched = mIndexses[idx];
-                mIndexses[idx] = mIndexses[idxtoswap];
-                mIndexses[idxtoswap] = touched;
-            }
-        }
-
-        return false;// don't need subsequent touch events
-    }
-}

samples/android/color-blob-detection/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/color-blob-detection/res/layout/color_blob_detection_surface_view.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/color_blob_detection_activity_surface_view" />
+
+</LinearLayout>

samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetectionActivity.java

 package org.opencv.samples.colorblobdetect;
 
+import java.util.List;
+
 import org.opencv.android.BaseLoaderCallback;
 import org.opencv.android.LoaderCallbackInterface;
 import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
+import org.opencv.android.JavaCameraView;
+import org.opencv.imgproc.Imgproc;
 
 import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
 import android.os.Bundle;
 import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
 import android.view.Window;
 import android.view.WindowManager;
+import android.view.View.OnTouchListener;
+
+public class ColorBlobDetectionActivity extends Activity implements OnTouchListener, CvCameraViewListener {
+    private static final String  TAG                 = "OCVSample::Activity";
 
-public class ColorBlobDetectionActivity extends Activity {
-    private static final String     TAG         = "OCVSample::Activity";
+    private boolean              mIsColorSelected    = false;
+    private Mat                  mRgba;
+    private Scalar               mBlobColorRgba;
+    private Scalar               mBlobColorHsv;
+    private ColorBlobDetector    mDetector;
+    private Mat                  mSpectrum;
+    private Size                 SPECTRUM_SIZE;
+    private Scalar               CONTOUR_COLOR;
 
-    private ColorBlobDetectionView  mView;
+    private JavaCameraView mOpenCvCameraView;
 
-    private BaseLoaderCallback  mOpenCVCallBack = new BaseLoaderCallback(this) {
+    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
         @Override
         public void onManagerConnected(int status) {
             switch (status) {
                 case LoaderCallbackInterface.SUCCESS:
                 {
                     Log.i(TAG, "OpenCV loaded successfully");
-                    // Create and set View
-                    mView = new ColorBlobDetectionView(mAppContext);
-                    setContentView(mView);
-
-                    // Check native OpenCV camera
-                    if( !mView.openCamera() ) {
-                        AlertDialog ad = new AlertDialog.Builder(mAppContext).create();
-                        ad.setCancelable(false); // This blocks the 'BACK' button
-                        ad.setMessage("Fatal error: can't open camera!");
-                        ad.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                            public void onClick(DialogInterface dialog, int which) {
-                                dialog.dismiss();
-                                finish();
-                            }
-                        });
-                        ad.show();
-                    }
-                } break;
-
-                /** OpenCV loader cannot start Google Play **/
-                case LoaderCallbackInterface.MARKET_ERROR:
-                {
-                    Log.d(TAG, "Google Play service is not accessible!");
-                    AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
-                    MarketErrorMessage.setTitle("OpenCV Manager");
-                    MarketErrorMessage.setMessage("Google Play service is not accessible!\nTry to install the 'OpenCV Manager' and the appropriate 'OpenCV binary pack' APKs from OpenCV SDK manually via 'adb install' command.");
-                    MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
-                    MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                        public void onClick(DialogInterface dialog, int which) {
-                            finish();
-                        }
-                    });
-                    MarketErrorMessage.show();
+                    mOpenCvCameraView.enableView();
+                    mOpenCvCameraView.setOnTouchListener(ColorBlobDetectionActivity.this);
                 } break;
                 default:
                 {
@@ -70,31 +61,124 @@ public class ColorBlobDetectionActivity extends Activity {
         Log.i(TAG, "Instantiated new " + this.getClass());
     }
 
+    /** Called when the activity is first created. */
     @Override
-    protected void onPause() {
-        Log.i(TAG, "called onPause");
-        if (null != mView)
-            mView.releaseCamera();
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.color_blob_detection_surface_view);
+
+        mOpenCvCameraView = (JavaCameraView)findViewById(R.id.color_blob_detection_activity_surface_view);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        mOpenCvCameraView.disableView();
         super.onPause();
     }
 
     @Override
-    protected void onResume() {
-        Log.i(TAG, "called onResume");
+    public void onResume()
+    {
         super.onResume();
+        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mLoaderCallback);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        mOpenCvCameraView.disableView();
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        mRgba = new Mat(height, width, CvType.CV_8UC4);
+        mDetector = new ColorBlobDetector();
+        mSpectrum = new Mat();
+        mBlobColorRgba = new Scalar(255);
+        mBlobColorHsv = new Scalar(255);
+        SPECTRUM_SIZE = new Size(200, 32);
+        CONTOUR_COLOR = new Scalar(255,0,0,255);
+    }
+
+    public void onCameraViewStopped() {
+        mRgba.release();
+    }
+
+    public boolean onTouch(View v, MotionEvent event) {
+        int cols = mRgba.cols();
+        int rows = mRgba.rows();
+
+        int xOffset = (mOpenCvCameraView.getWidth() - cols) / 2;
+        int yOffset = (mOpenCvCameraView.getHeight() - rows) / 2;
+
+        int x = (int)event.getX() - xOffset;
+        int y = (int)event.getY() - yOffset;
+
+        Log.i(TAG, "Touch image coordinates: (" + x + ", " + y + ")");
 
-        Log.i(TAG, "Trying to load OpenCV library");
-        if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mOpenCVCallBack)) {
-            Log.e(TAG, "Cannot connect to OpenCV Manager");
+        if ((x < 0) || (y < 0) || (x > cols) || (y > rows)) return false;
+
+        Rect touchedRect = new Rect();
+
+        touchedRect.x = (x>4) ? x-4 : 0;
+        touchedRect.y = (y>4) ? y-4 : 0;
+
+        touchedRect.width = (x+4 < cols) ? x + 4 - touchedRect.x : cols - touchedRect.x;
+        touchedRect.height = (y+4 < rows) ? y + 4 - touchedRect.y : rows - touchedRect.y;
+
+        Mat touchedRegionRgba = mRgba.submat(touchedRect);
+
+        Mat touchedRegionHsv = new Mat();
+        Imgproc.cvtColor(touchedRegionRgba, touchedRegionHsv, Imgproc.COLOR_RGB2HSV_FULL);
+
+        // Calculate average color of touched region
+        mBlobColorHsv = Core.sumElems(touchedRegionHsv);
+        int pointCount = touchedRect.width*touchedRect.height;
+        for (int i = 0; i < mBlobColorHsv.val.length; i++)
+            mBlobColorHsv.val[i] /= pointCount;
+
+        mBlobColorRgba = converScalarHsv2Rgba(mBlobColorHsv);
+
+        Log.i(TAG, "Touched rgba color: (" + mBlobColorRgba.val[0] + ", " + mBlobColorRgba.val[1] +
+                ", " + mBlobColorRgba.val[2] + ", " + mBlobColorRgba.val[3] + ")");
+
+        mDetector.setHsvColor(mBlobColorHsv);
+
+        Imgproc.resize(mDetector.getSpectrum(), mSpectrum, SPECTRUM_SIZE);
+
+        mIsColorSelected = true;
+
+        return false; // don't need subsequent touch events
+    }
+
+    public Mat onCameraFrame(Mat inputFrame) {
+        inputFrame.copyTo(mRgba);
+
+        if (mIsColorSelected) {
+            mDetector.process(mRgba);
+            List<MatOfPoint> contours = mDetector.getContours();
+            Log.e(TAG, "Contours count: " + contours.size());
+            Imgproc.drawContours(mRgba, contours, -1, CONTOUR_COLOR);
+
+            Mat colorLabel = mRgba.submat(2, 34, 2, 34);
+            colorLabel.setTo(mBlobColorRgba);
+
+            Mat spectrumLabel = mRgba.submat(2, 2 + mSpectrum.rows(), 38, 38 + mSpectrum.cols());
+            mSpectrum.copyTo(spectrumLabel);
         }
+
+        return mRgba;
     }
 
-    /** Called when the activity is first created. */
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        Log.i(TAG, "called onCreate");
-        super.onCreate(savedInstanceState);
-        requestWindowFeature(Window.FEATURE_NO_TITLE);
-        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+    private Scalar converScalarHsv2Rgba(Scalar hsvColor) {
+        Mat pointMatRgba = new Mat();
+        Mat pointMatHsv = new Mat(1, 1, CvType.CV_8UC3, hsvColor);
+        Imgproc.cvtColor(pointMatHsv, pointMatRgba, Imgproc.COLOR_HSV2RGB_FULL, 4);
+
+        return new Scalar(pointMatRgba.get(0, 0));
     }
 }
\ No newline at end of file

samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetectionView.java

-package org.opencv.samples.colorblobdetect;
-
-import java.util.List;
-import org.opencv.android.Utils;
-import org.opencv.core.Core;
-import org.opencv.core.CvType;
-import org.opencv.core.Mat;
-import org.opencv.core.MatOfPoint;
-import org.opencv.core.Rect;
-import org.opencv.core.Scalar;
-import org.opencv.core.Size;
-import org.opencv.highgui.Highgui;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.imgproc.Imgproc;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.util.Log;
-import android.view.MotionEvent;
-import android.view.SurfaceHolder;
-import android.view.View;
-import android.view.View.OnTouchListener;
-
-public class ColorBlobDetectionView extends SampleCvViewBase implements OnTouchListener {
-    private static final String TAG                 = "OCVSample::View";
-
-    private Mat                 mRgba;
-    private boolean             mIsColorSelected    = false;
-    private Scalar              mBlobColorRgba      = new Scalar(255);
-    private Scalar              mBlobColorHsv       = new Scalar(255);
-    private ColorBlobDetector   mDetector           = new ColorBlobDetector();
-    private Mat                 mSpectrum           = new Mat();
-    private static Size         SPECTRUM_SIZE       = new Size(200, 32);
-    private static final Scalar CONTOUR_COLOR       = new Scalar(255,0,0,255);
-
-
-    public ColorBlobDetectionView(Context context) {
-        super(context);
-        setOnTouchListener(this);
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    @Override
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        synchronized (this) {
-            // initialize Mat before usage
-            mRgba = new Mat();
-        }
-
-        super.surfaceCreated(holder);
-    }
-
-    private Scalar converScalarHsv2Rgba(Scalar hsvColor) {
-        Mat pointMatRgba = new Mat();
-        Mat pointMatHsv = new Mat(1, 1, CvType.CV_8UC3, hsvColor);
-        Imgproc.cvtColor(pointMatHsv, pointMatRgba, Imgproc.COLOR_HSV2RGB_FULL, 4);
-
-        return new Scalar(pointMatRgba.get(0, 0));
-    }
-
-    public boolean onTouch(View v, MotionEvent event) {
-        int cols = mRgba.cols();
-        int rows = mRgba.rows();
-
-        int xOffset = (getWidth() - cols) / 2;
-        int yOffset = (getHeight() - rows) / 2;
-
-        int x = (int)event.getX() - xOffset;
-        int y = (int)event.getY() - yOffset;
-
-        Log.i(TAG, "Touch image coordinates: (" + x + ", " + y + ")");
-
-        if ((x < 0) || (y < 0) || (x > cols) || (y > rows)) return false;
-
-        Rect touchedRect = new Rect();
-
-        touchedRect.x = (x>4) ? x-4 : 0;
-        touchedRect.y = (y>4) ? y-4 : 0;
-
-        touchedRect.width = (x+4 < cols) ? x + 4 - touchedRect.x : cols - touchedRect.x;
-        touchedRect.height = (y+4 < rows) ? y + 4 - touchedRect.y : rows - touchedRect.y;
-
-        Mat touchedRegionRgba = mRgba.submat(touchedRect);
-
-        Mat touchedRegionHsv = new Mat();
-        Imgproc.cvtColor(touchedRegionRgba, touchedRegionHsv, Imgproc.COLOR_RGB2HSV_FULL);
-
-        // Calculate average color of touched region
-        mBlobColorHsv = Core.sumElems(touchedRegionHsv);
-        int pointCount = touchedRect.width*touchedRect.height;
-        for (int i = 0; i < mBlobColorHsv.val.length; i++)
-            mBlobColorHsv.val[i] /= pointCount;
-
-        mBlobColorRgba = converScalarHsv2Rgba(mBlobColorHsv);
-
-        Log.i(TAG, "Touched rgba color: (" + mBlobColorRgba.val[0] + ", " + mBlobColorRgba.val[1] +
-                ", " + mBlobColorRgba.val[2] + ", " + mBlobColorRgba.val[3] + ")");
-
-        mDetector.setHsvColor(mBlobColorHsv);
-
-        Imgproc.resize(mDetector.getSpectrum(), mSpectrum, SPECTRUM_SIZE);
-
-        mIsColorSelected = true;
-
-        return false; // don't need subsequent touch events
-    }
-
-    @Override
-    protected Bitmap processFrame(VideoCapture capture) {
-        capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
-
-        Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888);
-
-        if (mIsColorSelected) {
-            mDetector.process(mRgba);
-            List<MatOfPoint> contours = mDetector.getContours();
-            Log.e(TAG, "Contours count: " + contours.size());
-            Imgproc.drawContours(mRgba, contours, -1, CONTOUR_COLOR);
-
-            Mat colorLabel = mRgba.submat(2, 34, 2, 34);
-            colorLabel.setTo(mBlobColorRgba);
-
-            Mat spectrumLabel = mRgba.submat(2, 2 + mSpectrum.rows(), 38, 38 + mSpectrum.cols());
-            mSpectrum.copyTo(spectrumLabel);
-        }
-
-        try {
-            Utils.matToBitmap(mRgba, bmp);
-        } catch(Exception e) {
-            Log.e(TAG, "Utils.matToBitmap() throws an exception: " + e.getMessage());
-            bmp.recycle();
-            bmp = null;
-        }
-
-        return bmp;
-    }
-
-    @Override
-    public void run() {
-        super.run();
-
-        synchronized (this) {
-            // Explicitly deallocate Mats
-            if (mRgba != null)
-                mRgba.release();
-
-            mRgba = null;
-        }
-    }
-}

samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/SampleCvViewBase.java

-package org.opencv.samples.colorblobdetect;
-
-import java.util.List;
-
-import org.opencv.core.Size;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.highgui.Highgui;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.util.Log;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
-    private static final String TAG = "OCVSample::BaseView";
-
-    private SurfaceHolder       mHolder;
-    private VideoCapture        mCamera;
-
-    public SampleCvViewBase(Context context) {
-        super(context);
-        mHolder = getHolder();
-        mHolder.addCallback(this);
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    public synchronized boolean openCamera() {
-        Log.i(TAG, "Opening Camera");
-        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
-        if (!mCamera.isOpened()) {
-            releaseCamera();
-            Log.e(TAG, "Can't open native camera");
-            return false;
-        }
-        return true;
-    }
-
-    public synchronized void releaseCamera() {
-        Log.i(TAG, "Releasing Camera");
-        if (mCamera != null) {
-                mCamera.release();
-                mCamera = null;
-        }
-    }
-
-    public synchronized void setupCamera(int width, int height) {
-        if (mCamera != null && mCamera.isOpened()) {
-            Log.i(TAG, "Setup Camera - " + width + "x" + height);
-            List<Size> sizes = mCamera.getSupportedPreviewSizes();
-            int mFrameWidth = width;
-            int mFrameHeight = height;
-
-            // selecting optimal camera preview size
-            {
-                double minDiff = Double.MAX_VALUE;
-                for (Size size : sizes) {
-                    if (Math.abs(size.height - height) < minDiff) {
-                        mFrameWidth = (int) size.width;
-                        mFrameHeight = (int) size.height;
-                        minDiff = Math.abs(size.height - height);
-                    }
-                }
-            }
-
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
-        }
-    }
-
-    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
-        Log.i(TAG, "called surfaceChanged");
-        setupCamera(width, height);
-    }
-
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        (new Thread(this)).start();
-    }
-
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceDestroyed");
-    }
-
-    protected abstract Bitmap processFrame(VideoCapture capture);
-
-    public void run() {
-        Log.i(TAG, "Started processing thread");
-        while (true) {
-            Bitmap bmp = null;
-
-            synchronized (this) {
-                if (mCamera == null)
-                    break;
-
-                if (!mCamera.grab()) {
-                    Log.e(TAG, "mCamera.grab() failed");
-                    break;
-                }
-
-                bmp = processFrame(mCamera);
-            }
-
-            if (bmp != null) {
-                Canvas canvas = mHolder.lockCanvas();
-                if (canvas != null) {
-                    canvas.drawColor(0, android.graphics.PorterDuff.Mode.CLEAR);
-                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
-                    mHolder.unlockCanvasAndPost(canvas);
-                }
-                bmp.recycle();
-            }
-        }
-        Log.i(TAG, "Finished processing thread");
-    }
-}
\ No newline at end of file

samples/android/face-detection/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/face-detection/res/layout/face_detect_surface_view.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/fd_activity_surface_view" />
+
+</LinearLayout>

samples/android/face-detection/src/org/opencv/samples/fd/FdView.java

-package org.opencv.samples.fd;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-import org.opencv.android.Utils;
-import org.opencv.core.Core;
-import org.opencv.core.Mat;
-import org.opencv.core.MatOfRect;
-import org.opencv.core.Rect;
-import org.opencv.core.Scalar;
-import org.opencv.core.Size;
-import org.opencv.highgui.Highgui;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.objdetect.CascadeClassifier;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.util.Log;
-import android.view.SurfaceHolder;
-
-class FdView extends SampleCvViewBase {
-    private static final String     TAG                 = "OCVSample::View";
-    private Mat                     mRgba;
-    private Mat                     mGray;
-    private File                    mCascadeFile;
-    private CascadeClassifier       mJavaDetector;
-    private DetectionBasedTracker   mNativeDetector;
-
-    private static final Scalar     FACE_RECT_COLOR     = new Scalar(0, 255, 0, 255);
-
-    public static final int         JAVA_DETECTOR       = 0;
-    public static final int         NATIVE_DETECTOR     = 1;
-
-    private int                     mDetectorType       = JAVA_DETECTOR;
-
-    private float                   mRelativeFaceSize   = 0;
-    private int                     mAbsoluteFaceSize   = 0;
-
-    public void setMinFaceSize(float faceSize) {
-        mRelativeFaceSize = faceSize;
-        mAbsoluteFaceSize = 0;
-    }
-
-    public void setDetectorType(int type) {
-        if (mDetectorType != type) {
-            mDetectorType = type;
-
-            if (type == NATIVE_DETECTOR) {
-                Log.i(TAG, "Detection Based Tracker enabled");
-                mNativeDetector.start();
-            } else {
-                Log.i(TAG, "Cascade detector enabled");
-                mNativeDetector.stop();
-            }
-        }
-    }
-
-    public FdView(Context context) {
-        super(context);
-
-        try {
-            // load cascade file from application resources
-            InputStream is = context.getResources().openRawResource(R.raw.lbpcascade_frontalface);
-            File cascadeDir = context.getDir("cascade", Context.MODE_PRIVATE);
-            mCascadeFile = new File(cascadeDir, "lbpcascade_frontalface.xml");
-            FileOutputStream os = new FileOutputStream(mCascadeFile);
-
-            byte[] buffer = new byte[4096];
-            int bytesRead;
-            while ((bytesRead = is.read(buffer)) != -1) {
-                os.write(buffer, 0, bytesRead);
-            }
-            is.close();
-            os.close();
-
-            mJavaDetector = new CascadeClassifier(mCascadeFile.getAbsolutePath());
-            if (mJavaDetector.empty()) {
-                Log.e(TAG, "Failed to load cascade classifier");
-                mJavaDetector = null;
-            } else
-                Log.i(TAG, "Loaded cascade classifier from " + mCascadeFile.getAbsolutePath());
-
-            mNativeDetector = new DetectionBasedTracker(mCascadeFile.getAbsolutePath(), 0);
-
-            cascadeDir.delete();
-
-        } catch (IOException e) {
-            e.printStackTrace();
-            Log.e(TAG, "Failed to load cascade. Exception thrown: " + e);
-        }
-
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    @Override
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        synchronized (this) {
-            // initialize Mats before usage
-            mGray = new Mat();
-            mRgba = new Mat();
-        }
-
-        super.surfaceCreated(holder);
-    }
-
-    @Override
-    protected Bitmap processFrame(VideoCapture capture) {
-        capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
-        capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
-
-        if (mAbsoluteFaceSize == 0) {
-            int height = mGray.rows();
-            if (Math.round(height * mRelativeFaceSize) > 0) {
-                mAbsoluteFaceSize = Math.round(height * mRelativeFaceSize);
-            }
-            mNativeDetector.setMinFaceSize(mAbsoluteFaceSize);
-        }
-
-        MatOfRect faces = new MatOfRect();
-
-        if (mDetectorType == JAVA_DETECTOR) {
-            if (mJavaDetector != null)
-                mJavaDetector.detectMultiScale(mGray, faces, 1.1, 2, 2, // TODO: objdetect.CV_HAAR_SCALE_IMAGE
-                        new Size(mAbsoluteFaceSize, mAbsoluteFaceSize), new Size());
-        }
-        else if (mDetectorType == NATIVE_DETECTOR) {
-            if (mNativeDetector != null)
-                mNativeDetector.detect(mGray, faces);
-        }
-        else {
-            Log.e(TAG, "Detection method is not selected!");
-        }
-
-        Rect[] facesArray = faces.toArray();
-        for (int i = 0; i < facesArray.length; i++)
-            Core.rectangle(mRgba, facesArray[i].tl(), facesArray[i].br(), FACE_RECT_COLOR, 3);
-
-        Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888);
-
-        try {
-            Utils.matToBitmap(mRgba, bmp);
-        } catch(Exception e) {
-            Log.e(TAG, "Utils.matToBitmap() throws an exception: " + e.getMessage());
-            bmp.recycle();
-            bmp = null;
-        }
-
-        return bmp;
-    }
-
-    @Override
-    public void run() {
-        super.run();
-
-        synchronized (this) {
-            // Explicitly deallocate Mats
-            if (mRgba != null)
-                mRgba.release();
-            if (mGray != null)
-                mGray.release();
-            if (mCascadeFile != null)
-                mCascadeFile.delete();
-            if (mNativeDetector != null)
-                mNativeDetector.release();
-
-            mRgba = null;
-            mGray = null;
-            mCascadeFile = null;
-        }
-    }
-}

samples/android/face-detection/src/org/opencv/samples/fd/SampleCvViewBase.java

-package org.opencv.samples.fd;
-
-import java.util.List;
-
-import org.opencv.core.Size;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.highgui.Highgui;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.util.Log;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
-    private static final String TAG = "OCVSample::BaseView";
-
-    private SurfaceHolder       mHolder;
-    private VideoCapture        mCamera;
-    private FpsMeter            mFps;
-
-    public SampleCvViewBase(Context context) {
-        super(context);
-        mHolder = getHolder();
-        mHolder.addCallback(this);
-        mFps = new FpsMeter();
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    public synchronized boolean openCamera() {
-        Log.i(TAG, "Opening Camera");
-        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
-        if (!mCamera.isOpened()) {
-            releaseCamera();
-            Log.e(TAG, "Can't open native camera");
-            return false;
-        }
-        return true;
-    }
-
-    public synchronized void releaseCamera() {
-        Log.i(TAG, "Releasing Camera");
-        if (mCamera != null) {
-                mCamera.release();
-                mCamera = null;
-        }
-    }
-
-    public synchronized void setupCamera(int width, int height) {
-        if (mCamera != null && mCamera.isOpened()) {
-            Log.i(TAG, "Setup Camera - " + width + "x" + height);
-            List<Size> sizes = mCamera.getSupportedPreviewSizes();
-            int mFrameWidth = width;
-            int mFrameHeight = height;
-
-            // selecting optimal camera preview size
-            {
-                double minDiff = Double.MAX_VALUE;
-                for (Size size : sizes) {
-                    if (Math.abs(size.height - height) < minDiff) {
-                        mFrameWidth = (int) size.width;
-                        mFrameHeight = (int) size.height;
-                        minDiff = Math.abs(size.height - height);
-                    }
-                }
-            }
-
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
-        }
-    }
-
-    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
-        Log.i(TAG, "called surfaceChanged");
-        setupCamera(width, height);
-    }
-
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        (new Thread(this)).start();
-    }
-
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceDestroyed");
-    }
-    protected abstract Bitmap processFrame(VideoCapture capture);
-
-    public void run() {
-        Log.i(TAG, "Started processing thread");
-        mFps.init();
-
-        while (true) {
-            Bitmap bmp = null;
-
-            synchronized (this) {
-                if (mCamera == null)
-                    break;
-
-                if (!mCamera.grab()) {
-                    Log.e(TAG, "mCamera.grab() failed");
-                    break;
-                }
-
-                bmp = processFrame(mCamera);
-
-                mFps.measure();
-            }
-
-            if (bmp != null) {
-                Canvas canvas = mHolder.lockCanvas();
-                if (canvas != null) {
-                    canvas.drawColor(0, android.graphics.PorterDuff.Mode.CLEAR);
-                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
-                    mFps.draw(canvas, (canvas.getWidth() - bmp.getWidth()) / 2, 0);
-                    mHolder.unlockCanvasAndPost(canvas);
-                }
-                bmp.recycle();
-            }
-        }
-        Log.i(TAG, "Finished processing thread");
-    }
-}
\ No newline at end of file

samples/android/image-manipulations/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/image-manipulations/res/layout/image_manipulations_surface_view.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/image_manipulations_activity_surface_view" />
+
+</LinearLayout>

samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/SampleCvViewBase.java

-package org.opencv.samples.imagemanipulations;
-
-import java.util.List;
-
-import org.opencv.core.Size;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.highgui.Highgui;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.util.Log;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
-    private static final String TAG = "OCVSample::BaseView";
-
-    private SurfaceHolder       mHolder;
-    private VideoCapture        mCamera;
-    private FpsMeter            mFps;
-
-    public SampleCvViewBase(Context context) {
-        super(context);
-        mHolder = getHolder();
-        mHolder.addCallback(this);
-        mFps = new FpsMeter();
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    public synchronized boolean openCamera() {
-        Log.i(TAG, "Opening Camera");
-        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
-        if (!mCamera.isOpened()) {
-            releaseCamera();
-            Log.e(TAG, "Can't open native camera");
-            return false;
-        }
-        return true;
-    }
-
-    public synchronized void releaseCamera() {
-        Log.i(TAG, "Releasing Camera");
-        if (mCamera != null) {
-                mCamera.release();
-                mCamera = null;
-        }
-    }
-
-    public synchronized void setupCamera(int width, int height) {
-        if (mCamera != null && mCamera.isOpened()) {
-            Log.i(TAG, "Setup Camera - " + width + "x" + height);
-            List<Size> sizes = mCamera.getSupportedPreviewSizes();
-            int mFrameWidth = width;
-            int mFrameHeight = height;
-
-            // selecting optimal camera preview size
-            {
-                double minDiff = Double.MAX_VALUE;
-                for (Size size : sizes) {
-                    if (Math.abs(size.height - height) < minDiff) {
-                        mFrameWidth = (int) size.width;
-                        mFrameHeight = (int) size.height;
-                        minDiff = Math.abs(size.height - height);
-                    }
-                }
-            }
-
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
-        }
-    }
-
-    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
-        Log.i(TAG, "called surfaceChanged");
-        setupCamera(width, height);
-    }
-
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        (new Thread(this)).start();
-    }
-
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceDestroyed");
-    }
-
-    protected abstract Bitmap processFrame(VideoCapture capture);
-
-    public void run() {
-        Log.i(TAG, "Started processing thread");
-        mFps.init();
-
-        while (true) {
-            Bitmap bmp = null;
-
-            synchronized (this) {
-                if (mCamera == null)
-                    break;
-
-                if (!mCamera.grab()) {
-                    Log.e(TAG, "mCamera.grab() failed");
-                    break;
-                }
-
-                bmp = processFrame(mCamera);
-
-                mFps.measure();
-            }
-
-            if (bmp != null) {
-                Canvas canvas = mHolder.lockCanvas();
-                if (canvas != null) {
-                    canvas.drawColor(0, android.graphics.PorterDuff.Mode.CLEAR);
-                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()), null);
-                    mFps.draw(canvas, (canvas.getWidth() - bmp.getWidth()) / 2, 0);
-                    mHolder.unlockCanvasAndPost(canvas);
-                }
-                bmp.recycle();
-            }
-        }
-        Log.i(TAG, "Finished processing thread");
-    }
-}
\ No newline at end of file

samples/android/tutorial-0-androidcamera/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/Sample0Base.java

@@ -5,16 +5,11 @@ import android.app.AlertDialog;
 import android.content.DialogInterface;
 import android.os.Bundle;
 import android.util.Log;
-import android.view.Menu;
-import android.view.MenuItem;
 import android.view.Window;
 
 public class Sample0Base extends Activity {
 
     private static final String TAG = "OCVSample::Activity";
-
-    private MenuItem            mItemPreviewRGBA;
-    private MenuItem            mItemPreviewGray;
     private Sample0View         mView;
 
     public Sample0Base() {
@@ -55,22 +50,4 @@ public class Sample0Base extends Activity {
         mView = new Sample0View(this);
         setContentView(mView);
     }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        Log.i(TAG, "called onCreateOptionsMenu");
-        mItemPreviewRGBA = menu.add("Preview RGBA");
-        mItemPreviewGray = menu.add("Preview GRAY");
-        return true;
-    }
-
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
-        if (item == mItemPreviewRGBA)
-            mView.setViewMode(Sample0View.VIEW_MODE_RGBA);
-        else if (item == mItemPreviewGray)
-            mView.setViewMode(Sample0View.VIEW_MODE_GRAY);
-        return true;
-    }
 }

samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/SampleViewBase.java

@@ -3,6 +3,7 @@ package org.opencv.samples.tutorial0;
 import java.io.IOException;
 import java.util.List;
 
+import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
@@ -43,7 +44,8 @@ public abstract class SampleViewBase extends SurfaceView implements SurfaceHolde
         return mFrameHeight;
     }
 
-    public void setPreview() throws IOException {
+    @TargetApi(11)
+        public void setPreview() throws IOException {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
             mSf = new SurfaceTexture(10);
             mCamera.setPreviewTexture( mSf );

samples/android/tutorial-1-addopencv/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/tutorial-1-addopencv/res/layout/tutorial1_surface_view.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/tutorial1_activity_surface_view" />
+
+</LinearLayout>

samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1Java.java

@@ -3,65 +3,29 @@ package org.opencv.samples.tutorial1;
 import org.opencv.android.BaseLoaderCallback;
 import org.opencv.android.LoaderCallbackInterface;
 import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Mat;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
+import org.opencv.android.JavaCameraView;
 
 import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
 import android.os.Bundle;
 import android.util.Log;
-import android.view.Menu;
-import android.view.MenuItem;
 import android.view.Window;
 import android.view.WindowManager;
 
-public class Sample1Java extends Activity {
+public class Sample1Java extends Activity implements CvCameraViewListener {
     private static final String TAG = "OCVSample::Activity";
 
-    private MenuItem            mItemPreviewRGBA;
-    private MenuItem            mItemPreviewGray;
-    private MenuItem            mItemPreviewCanny;
-    private Sample1View         mView;
+    private JavaCameraView mOpenCvCameraView;
 
-    private BaseLoaderCallback  mOpenCVCallBack = new BaseLoaderCallback(this) {
+    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
         @Override
         public void onManagerConnected(int status) {
             switch (status) {
                 case LoaderCallbackInterface.SUCCESS:
                 {
                     Log.i(TAG, "OpenCV loaded successfully");
-                    // Create and set View
-                    mView = new Sample1View(mAppContext);
-                    setContentView(mView);
-
-                    // Check native OpenCV camera
-                    if( !mView.openCamera() ) {
-                        AlertDialog ad = new AlertDialog.Builder(mAppContext).create();
-                        ad.setCancelable(false); // This blocks the 'BACK' button
-                        ad.setMessage("Fatal error: can't open camera!");
-                        ad.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                            public void onClick(DialogInterface dialog, int which) {
-                                dialog.dismiss();
-                                finish();
-                            }
-                        });
-                        ad.show();
-                    }
-                } break;
-
-                /** OpenCV loader cannot start Google Play **/
-                case LoaderCallbackInterface.MARKET_ERROR:
-                {
-                    Log.d(TAG, "Google Play service is not accessible!");
-                    AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
-                    MarketErrorMessage.setTitle("OpenCV Manager");
-                    MarketErrorMessage.setMessage("Google Play service is not accessible!\nTry to install the 'OpenCV Manager' and the appropriate 'OpenCV binary pack' APKs from OpenCV SDK manually via 'adb install' command.");
-                    MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
-                    MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                        public void onClick(DialogInterface dialog, int which) {
-                            finish();
-                        }
-                    });
-                    MarketErrorMessage.show();
+                    mOpenCvCameraView.enableView();
                 } break;
                 default:
                 {
@@ -75,25 +39,6 @@ public class Sample1Java extends Activity {
         Log.i(TAG, "Instantiated new " + this.getClass());
     }
 
-    @Override
-    protected void onPause() {
-        Log.i(TAG, "called onPause");
-        if (null != mView)
-            mView.releaseCamera();
-        super.onPause();
-    }
-
-    @Override
-    protected void onResume() {
-        Log.i(TAG, "called onResume");
-        super.onResume();
-
-        Log.i(TAG, "Trying to load OpenCV library");
-        if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mOpenCVCallBack)) {
-            Log.e(TAG, "Cannot connect to OpenCV Manager");
-        }
-    }
-
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
@@ -101,27 +46,39 @@ public class Sample1Java extends Activity {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.tutorial1_surface_view);
+
+        mOpenCvCameraView = (JavaCameraView)findViewById(R.id.tutorial1_activity_surface_view);
+        mOpenCvCameraView.setCvCameraViewListener(this);
     }
 
     @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        Log.i(TAG, "called onCreateOptionsMenu");
-        mItemPreviewRGBA = menu.add("Preview RGBA");
-        mItemPreviewGray = menu.add("Preview GRAY");
-        mItemPreviewCanny = menu.add("Canny");
-        return true;
+    public void onPause()
+    {
+        mOpenCvCameraView.disableView();
+        super.onPause();
     }
 
     @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
-        if (item == mItemPreviewRGBA) {
-            mView.setViewMode(Sample1View.VIEW_MODE_RGBA);
-        } else if (item == mItemPreviewGray) {
-            mView.setViewMode(Sample1View.VIEW_MODE_GRAY);
-        } else if (item == mItemPreviewCanny) {
-            mView.setViewMode(Sample1View.VIEW_MODE_CANNY);
-        }
-        return true;
+    public void onResume()
+    {
+        super.onResume();
+        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mLoaderCallback);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        mOpenCvCameraView.disableView();
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+    }
+
+    public void onCameraViewStopped() {
+    }
+
+    public Mat onCameraFrame(Mat inputFrame) {
+        return inputFrame;
     }
 }

samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1View.java

-package org.opencv.samples.tutorial1;
-
-import org.opencv.android.Utils;
-import org.opencv.core.Core;
-import org.opencv.core.CvType;
-import org.opencv.core.Mat;
-import org.opencv.core.Point;
-import org.opencv.core.Scalar;
-import org.opencv.imgproc.Imgproc;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.util.Log;
-
-class Sample1View extends SampleViewBase {
-    private static final String TAG = "OCVSample::View";
-
-    public static final int     VIEW_MODE_RGBA  = 0;
-    public static final int     VIEW_MODE_GRAY  = 1;
-    public static final int     VIEW_MODE_CANNY = 2;
-
-    private Mat                 mYuv;
-    private Mat                 mRgba;
-    private Mat                 mGraySubmat;
-    private Mat                 mIntermediateMat;
-    private Bitmap              mBitmap;
-    private int                 mViewMode;
-
-    public Sample1View(Context context) {
-        super(context);
-        mViewMode = VIEW_MODE_RGBA;
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    @Override
-    protected void onPreviewStarted(int previewWidth, int previewHeight) {
-        Log.i(TAG, "called onPreviewStarted("+previewWidth+", "+previewHeight+")");
-
-        // initialize Mats before usage
-        mYuv = new Mat(getFrameHeight() + getFrameHeight() / 2, getFrameWidth(), CvType.CV_8UC1);
-        mGraySubmat = mYuv.submat(0, getFrameHeight(), 0, getFrameWidth());
-
-        mRgba = new Mat();
-        mIntermediateMat = new Mat();
-
-        mBitmap = Bitmap.createBitmap(previewWidth, previewHeight, Bitmap.Config.ARGB_8888);
-    }
-
-    @Override
-    protected void onPreviewStopped() {
-        Log.i(TAG, "called onPreviewStopped");
-
-        if(mBitmap != null) {
-            mBitmap.recycle();
-            mBitmap = null;
-        }
-
-        synchronized (this) {
-            // Explicitly deallocate Mats
-            if (mYuv != null)
-                mYuv.release();
-            if (mRgba != null)
-                mRgba.release();
-            if (mGraySubmat != null)
-                mGraySubmat.release();
-            if (mIntermediateMat != null)
-                mIntermediateMat.release();
-
-            mYuv = null;
-            mRgba = null;
-            mGraySubmat = null;
-            mIntermediateMat = null;
-        }
-    }
-
-    @Override
-    protected Bitmap processFrame(byte[] data) {
-        mYuv.put(0, 0, data);
-
-        final int viewMode = mViewMode;
-
-        switch (viewMode) {
-        case VIEW_MODE_GRAY:
-            Imgproc.cvtColor(mGraySubmat, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
-            break;
-        case VIEW_MODE_RGBA:
-            Imgproc.cvtColor(mYuv, mRgba, Imgproc.COLOR_YUV420sp2RGB, 4);
-            Core.putText(mRgba, "OpenCV + Android", new Point(10, 100), 3/* CV_FONT_HERSHEY_COMPLEX */, 2, new Scalar(255, 0, 0, 255), 3);
-            break;
-        case VIEW_MODE_CANNY:
-            Imgproc.Canny(mGraySubmat, mIntermediateMat, 80, 100);
-            Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);
-            break;
-        }
-
-        Bitmap bmp = mBitmap;
-
-        try {
-            Utils.matToBitmap(mRgba, bmp);
-        } catch(Exception e) {
-            Log.e("org.opencv.samples.tutorial1", "Utils.matToBitmap() throws an exception: " + e.getMessage());
-            bmp.recycle();
-            bmp = null;
-        }
-        return bmp;
-    }
-
-    public void setViewMode(int viewMode) {
-        Log.i(TAG, "called setViewMode("+viewMode+")");
-        mViewMode = viewMode;
-    }
-
-}

samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/SampleViewBase.java

-package org.opencv.samples.tutorial1;
-
-import java.io.IOException;
-import java.util.List;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.graphics.ImageFormat;
-import android.graphics.SurfaceTexture;
-import android.hardware.Camera;
-import android.hardware.Camera.PreviewCallback;
-import android.os.Build;
-import android.util.Log;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-public abstract class SampleViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
-    private static final String TAG = "OCVSample::BaseView";
-
-    private Camera              mCamera;
-    private SurfaceHolder       mHolder;
-    private int                 mFrameWidth;
-    private int                 mFrameHeight;
-    private byte[]              mFrame;
-    private volatile boolean    mThreadRun;
-    private byte[]              mBuffer;
-    private SurfaceTexture      mSf;
-
-
-    public SampleViewBase(Context context) {
-        super(context);
-        mHolder = getHolder();
-        mHolder.addCallback(this);
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    public int getFrameWidth() {
-        return mFrameWidth;
-    }
-
-    public int getFrameHeight() {
-        return mFrameHeight;
-    }
-
-    public void setPreview() throws IOException {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
-            mSf = new SurfaceTexture(10);
-            mCamera.setPreviewTexture( mSf );
-        }
-        else
-            mCamera.setPreviewDisplay(null);
-    }
-
-    public boolean openCamera() {
-        Log.i(TAG, "Opening Camera");
-        mCamera = null;
-
-        try {
-            mCamera = Camera.open();
-        }
-        catch (Exception e){
-            Log.e(TAG, "Camera is not available (in use or does not exist): " + e.getLocalizedMessage());
-        }
-
-        if(mCamera == null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
-            for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
-                try {
-                    mCamera = Camera.open(camIdx);
-                }
-                catch (RuntimeException e) {
-                    Log.e(TAG, "Camera #" + camIdx + "failed to open: " + e.getLocalizedMessage());
-                }
-            }
-        }
-
-        if(mCamera == null) {
-            Log.e(TAG, "Can't open any camera");
-            return false;
-        }
-
-        mCamera.setPreviewCallbackWithBuffer(new PreviewCallback() {
-            public void onPreviewFrame(byte[] data, Camera camera) {
-                synchronized (SampleViewBase.this) {
-                    System.arraycopy(data, 0, mFrame, 0, data.length);
-                    SampleViewBase.this.notify();
-                }
-                camera.addCallbackBuffer(mBuffer);
-            }
-        });
-
-        return true;
-    }
-
-    public void releaseCamera() {
-        Log.i(TAG, "Releasing Camera");
-        mThreadRun = false;
-        synchronized (this) {
-            if (mCamera != null) {
-                mCamera.stopPreview();
-                mCamera.release();
-                mCamera = null;
-            }
-        }
-        onPreviewStopped();
-    }
-
-    public synchronized void setupCamera(int width, int height) {
-        if (mCamera != null) {
-            Log.i(TAG, "Setup Camera - " + width + "x" + height);
-            Camera.Parameters params = mCamera.getParameters();
-            List<Camera.Size> sizes = params.getSupportedPreviewSizes();
-            mFrameWidth = width;
-            mFrameHeight = height;
-
-            // selecting optimal camera preview size
-            {
-                int  minDiff = Integer.MAX_VALUE;
-                for (Camera.Size size : sizes) {
-                    if (Math.abs(size.height - height) < minDiff) {
-                        mFrameWidth = size.width;
-                        mFrameHeight = size.height;
-                        minDiff = Math.abs(size.height - height);
-                    }
-                }
-            }
-
-            params.setPreviewSize(getFrameWidth(), getFrameHeight());
-
-            List<String> FocusModes = params.getSupportedFocusModes();
-            if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO))
-            {
-                params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
-            }
-
-            mCamera.setParameters(params);
-
-            /* Now allocate the buffer */
-            params = mCamera.getParameters();
-            int size = params.getPreviewSize().width * params.getPreviewSize().height;
-            size  = size * ImageFormat.getBitsPerPixel(params.getPreviewFormat()) / 8;
-            mBuffer = new byte[size];
-            /* The buffer where the current frame will be copied */
-            mFrame = new byte [size];
-            mCamera.addCallbackBuffer(mBuffer);
-
-            /* Notify that the preview is about to be started and deliver preview size */
-            onPreviewStarted(params.getPreviewSize().width, params.getPreviewSize().height);
-
-            try {
-                setPreview();
-            } catch (IOException e) {
-                Log.e(TAG, "mCamera.setPreviewDisplay/setPreviewTexture fails: " + e);
-            }
-
-            /* Now we can start a preview */
-            mCamera.startPreview();
-        }
-    }
-
-    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
-        Log.i(TAG, "called surfaceChanged");
-        // stop preview before making changes
-        try {
-            mCamera.stopPreview();
-        } catch (Exception e){
-          // ignore: tried to stop a non-existent preview
-        }
-
-        // start preview with new settings
-        setupCamera(width, height);
-    }
-
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        (new Thread(this)).start();
-    }
-
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceDestroyed");
-    }
-
-    /* The bitmap returned by this method shall be owned by the child and released in onPreviewStopped() */
-    protected abstract Bitmap processFrame(byte[] data);
-
-    /**
-     * This method is called when the preview process is being started. It is called before the first frame delivered and processFrame is called
-     * It is called with the width and height parameters of the preview process. It can be used to prepare the data needed during the frame processing.
-     * @param previewWidth - the width of the preview frames that will be delivered via processFrame
-     * @param previewHeight - the height of the preview frames that will be delivered via processFrame
-     */
-    protected abstract void onPreviewStarted(int previewWidtd, int previewHeight);
-
-    /**
-     * This method is called when preview is stopped. When this method is called the preview stopped and all the processing of frames already completed.
-     * If the Bitmap object returned via processFrame is cached - it is a good time to recycle it.
-     * Any other resources used during the preview can be released.
-     */
-    protected abstract void onPreviewStopped();
-
-    public void run() {
-        mThreadRun = true;
-        Log.i(TAG, "Started processing thread");
-        while (mThreadRun) {
-            Bitmap bmp = null;
-
-            synchronized (this) {
-                try {
-                    this.wait();
-                    if (!mThreadRun)
-                        break;
-                    bmp = processFrame(mFrame);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-            }
-
-            if (bmp != null) {
-                Canvas canvas = mHolder.lockCanvas();
-                if (canvas != null) {
-                    canvas.drawColor(0, android.graphics.PorterDuff.Mode.CLEAR);
-                    canvas.drawBitmap(bmp, (canvas.getWidth() - getFrameWidth()) / 2, (canvas.getHeight() - getFrameHeight()) / 2, null);
-                    mHolder.unlockCanvasAndPost(canvas);
-                }
-            }
-        }
-        Log.i(TAG, "Finished processing thread");
-    }
-}
\ No newline at end of file

samples/android/tutorial-2-opencvcamera/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/tutorial-2-opencvcamera/res/layout/tutorial2_surface_view.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.NativeCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/tutorial2_activity_surface_view" />
+
+</LinearLayout>

samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2NativeCamera.java

@@ -3,10 +3,17 @@ package org.opencv.samples.tutorial2;
 import org.opencv.android.BaseLoaderCallback;
 import org.opencv.android.LoaderCallbackInterface;
 import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.android.NativeCameraView;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
+import org.opencv.highgui.Highgui;
+import org.opencv.imgproc.Imgproc;
 
 import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.Menu;
@@ -14,60 +21,30 @@ import android.view.MenuItem;
 import android.view.Window;
 import android.view.WindowManager;
 
-public class Sample2NativeCamera extends Activity {
+public class Sample2NativeCamera extends Activity implements CvCameraViewListener {
     private static final String TAG             = "OCVSample::Activity";
 
     public static final int     VIEW_MODE_RGBA  = 0;
     public static final int     VIEW_MODE_GRAY  = 1;
     public static final int     VIEW_MODE_CANNY = 2;
 
+    private static int           viewMode       = VIEW_MODE_RGBA;
     private MenuItem            mItemPreviewRGBA;
     private MenuItem            mItemPreviewGray;
     private MenuItem            mItemPreviewCanny;
-    private Sample2View         mView;
+    private Mat                 mRgba;
+    private Mat                 mIntermediateMat;
 
-    public static int           viewMode        = VIEW_MODE_RGBA;
+    private NativeCameraView    mOpenCvCameraView;
 
-    private BaseLoaderCallback  mOpenCVCallBack = new BaseLoaderCallback(this) {
+    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
         @Override
         public void onManagerConnected(int status) {
             switch (status) {
                 case LoaderCallbackInterface.SUCCESS:
                 {
                     Log.i(TAG, "OpenCV loaded successfully");
-                    // Create and set View
-                    mView = new Sample2View(mAppContext);
-                    setContentView(mView);
-
-                    // Check native OpenCV camera
-                    if( !mView.openCamera() ) {
-                        AlertDialog ad = new AlertDialog.Builder(mAppContext).create();
-                        ad.setCancelable(false); // This blocks the 'BACK' button
-                        ad.setMessage("Fatal error: can't open camera!");
-                        ad.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                            public void onClick(DialogInterface dialog, int which) {
-                                dialog.dismiss();
-                                finish();
-                            }
-                        });
-                        ad.show();
-                    }
-                } break;
-
-                /** OpenCV loader cannot start Google Play **/
-                case LoaderCallbackInterface.MARKET_ERROR:
-                {
-                    Log.d(TAG, "Google Play service is not accessible!");
-                    AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
-                    MarketErrorMessage.setTitle("OpenCV Manager");
-                    MarketErrorMessage.setMessage("Google Play service is not accessible!\nTry to install the 'OpenCV Manager' and the appropriate 'OpenCV binary pack' APKs from OpenCV SDK manually via 'adb install' command.");
-                    MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
-                    MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                        public void onClick(DialogInterface dialog, int which) {
-                            finish();
-                        }
-                    });
-                    MarketErrorMessage.show();
+                    mOpenCvCameraView.enableView();
                 } break;
                 default:
                 {
@@ -81,32 +58,68 @@ public class Sample2NativeCamera extends Activity {
         Log.i(TAG, "Instantiated new " + this.getClass());
     }
 
+    /** Called when the activity is first created. */
     @Override
-    protected void onPause() {
-        Log.i(TAG, "called onPause");
-        if (null != mView)
-            mView.releaseCamera();
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.tutorial2_surface_view);
+
+        mOpenCvCameraView = (NativeCameraView)findViewById(R.id.tutorial2_activity_surface_view);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        mOpenCvCameraView.disableView();
         super.onPause();
     }
 
     @Override
-    protected void onResume() {
-        Log.i(TAG, "called onResume");
+    public void onResume()
+    {
         super.onResume();
+        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mLoaderCallback);
+    }
 
-        Log.i(TAG, "Trying to load OpenCV library");
-        if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mOpenCVCallBack)) {
-            Log.e(TAG, "Cannot connect to OpenCV Manager");
-        }
+    public void onDestroy() {
+        super.onDestroy();
+        mOpenCvCameraView.disableView();
     }
 
-    /** Called when the activity is first created. */
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        Log.i(TAG, "called onCreate");
-        super.onCreate(savedInstanceState);
-        requestWindowFeature(Window.FEATURE_NO_TITLE);
-        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+    public void onCameraViewStarted(int width, int height) {
+        mRgba = new Mat(height, width, CvType.CV_8UC4);
+        mIntermediateMat = new Mat(height, width, CvType.CV_8UC4);
+    }
+
+    public void onCameraViewStopped() {
+        mRgba.release();
+        mIntermediateMat.release();
+    }
+
+    public Mat onCameraFrame(Mat inputFrame) {
+        switch (Sample2NativeCamera.viewMode) {
+            case Sample2NativeCamera.VIEW_MODE_GRAY:
+            {
+                Imgproc.cvtColor(inputFrame, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
+            } break;
+            case Sample2NativeCamera.VIEW_MODE_RGBA:
+            {
+                inputFrame.copyTo(mRgba);
+                Core.putText(mRgba, "OpenCV+Android", new Point(10, 50), 3, 1, new Scalar(255, 0, 0, 255), 2);
+            } break;
+            case Sample2NativeCamera.VIEW_MODE_CANNY:
+            {
+                Imgproc.Canny(inputFrame, mIntermediateMat, 80, 100);
+                Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);
+            } break;
+        }
+
+        return mRgba;
     }
 
     @Override
@@ -122,11 +135,21 @@ public class Sample2NativeCamera extends Activity {
     public boolean onOptionsItemSelected(MenuItem item) {
         Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
         if (item == mItemPreviewRGBA)
+        {
+            mOpenCvCameraView.SetCaptureFormat(Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
             viewMode = VIEW_MODE_RGBA;
+        }
         else if (item == mItemPreviewGray)
+        {
+            mOpenCvCameraView.SetCaptureFormat(Highgui.CV_CAP_ANDROID_GREY_FRAME);
             viewMode = VIEW_MODE_GRAY;
+        }
         else if (item == mItemPreviewCanny)
+        {
+            mOpenCvCameraView.SetCaptureFormat(Highgui.CV_CAP_ANDROID_GREY_FRAME);
             viewMode = VIEW_MODE_CANNY;
+        }
+
         return true;
     }
 }

samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2View.java

-package org.opencv.samples.tutorial2;
-
-import org.opencv.android.Utils;
-import org.opencv.core.Core;
-import org.opencv.core.Mat;
-import org.opencv.core.Point;
-import org.opencv.core.Scalar;
-import org.opencv.highgui.Highgui;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.imgproc.Imgproc;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.util.Log;
-import android.view.SurfaceHolder;
-
-class Sample2View extends SampleCvViewBase {
-    private static final String TAG = "OCVSample::View";
-
-    private Mat                 mRgba;
-    private Mat                 mGray;
-    private Mat                 mIntermediateMat;
-
-    public Sample2View(Context context) {
-        super(context);
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    @Override
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        synchronized (this) {
-            // initialize Mats before usage
-            mGray = new Mat();
-            mRgba = new Mat();
-            mIntermediateMat = new Mat();
-        }
-
-        super.surfaceCreated(holder);
-    }
-
-    @Override
-    protected Bitmap processFrame(VideoCapture capture) {
-        switch (Sample2NativeCamera.viewMode) {
-        case Sample2NativeCamera.VIEW_MODE_GRAY:
-            capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
-            Imgproc.cvtColor(mGray, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
-            break;
-        case Sample2NativeCamera.VIEW_MODE_RGBA:
-            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
-            Core.putText(mRgba, "OpenCV+Android", new Point(10, 50), 3, 1, new Scalar(255, 0, 0, 255), 2);
-            break;
-        case Sample2NativeCamera.VIEW_MODE_CANNY:
-            capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
-            Imgproc.Canny(mGray, mIntermediateMat, 80, 100);
-            Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);
-            break;
-        }
-
-        Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888);
-
-        try {
-            Utils.matToBitmap(mRgba, bmp);
-            return bmp;
-        } catch(Exception e) {
-            Log.e(TAG, "Utils.matToBitmap() throws an exception: " + e.getMessage());
-            bmp.recycle();
-            return null;
-        }
-    }
-
-    @Override
-    public void run() {
-        super.run();
-
-        synchronized (this) {
-            // Explicitly deallocate Mats
-            if (mRgba != null)
-                mRgba.release();
-            if (mGray != null)
-                mGray.release();
-            if (mIntermediateMat != null)
-                mIntermediateMat.release();
-
-            mRgba = null;
-            mGray = null;
-            mIntermediateMat = null;
-        }
-    }
-}

samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/SampleCvViewBase.java

-package org.opencv.samples.tutorial2;
-
-import java.util.List;
-
-import org.opencv.core.Size;
-import org.opencv.highgui.VideoCapture;
-import org.opencv.highgui.Highgui;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.util.Log;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
-    private static final String TAG = "OCVSample::BaseView";
-
-    private SurfaceHolder       mHolder;
-    private VideoCapture        mCamera;
-
-    public SampleCvViewBase(Context context) {
-        super(context);
-        mHolder = getHolder();
-        mHolder.addCallback(this);
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    public synchronized boolean openCamera() {
-        Log.i(TAG, "Opening Camera");
-        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
-        if (!mCamera.isOpened()) {
-            releaseCamera();
-            Log.e(TAG, "Can't open native camera");
-            return false;
-        }
-        return true;
-    }
-
-    public synchronized void releaseCamera() {
-        Log.i(TAG, "Releasing Camera");
-        if (mCamera != null) {
-                mCamera.release();
-                mCamera = null;
-        }
-    }
-
-    public synchronized void setupCamera(int width, int height) {
-        if (mCamera != null && mCamera.isOpened()) {
-            Log.i(TAG, "Setup Camera - " + width + "x" + height);
-            List<Size> sizes = mCamera.getSupportedPreviewSizes();
-            int mFrameWidth = width;
-            int mFrameHeight = height;
-
-            // selecting optimal camera preview size
-            {
-                double minDiff = Double.MAX_VALUE;
-                for (Size size : sizes) {
-                    if (Math.abs(size.height - height) < minDiff) {
-                        mFrameWidth = (int) size.width;
-                        mFrameHeight = (int) size.height;
-                        minDiff = Math.abs(size.height - height);
-                    }
-                }
-            }
-
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
-            mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
-        }
-    }
-
-    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
-        Log.i(TAG, "called surfaceChanged");
-        setupCamera(width, height);
-    }
-
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceCreated");
-        (new Thread(this)).start();
-    }
-
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.i(TAG, "called surfaceDestroyed");
-    }
-
-    protected abstract Bitmap processFrame(VideoCapture capture);
-
-    public void run() {
-        Log.i(TAG, "Started processing thread");
-        while (true) {
-            Bitmap bmp = null;
-
-            synchronized (this) {
-                if (mCamera == null)
-                    break;
-
-                if (!mCamera.grab()) {
-                    Log.e(TAG, "mCamera.grab() failed");
-                    break;
-                }
-
-                bmp = processFrame(mCamera);
-            }
-
-            if (bmp != null) {
-                Canvas canvas = mHolder.lockCanvas();
-                if (canvas != null) {
-                    canvas.drawColor(0, android.graphics.PorterDuff.Mode.CLEAR);
-                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
-                    mHolder.unlockCanvasAndPost(canvas);
-                }
-                bmp.recycle();
-            }
-        }
-        Log.i(TAG, "Finished processing thread");
-    }
-}
\ No newline at end of file

samples/android/tutorial-3-native/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/tutorial-3-native/jni/jni_part.cpp

@@ -8,28 +8,16 @@ using namespace std;
 using namespace cv;
 
 extern "C" {
-JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial3_Sample3View_FindFeatures(JNIEnv* env, jobject, jint width, jint height, jbyteArray yuv, jintArray bgra)
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial3_Sample3Native_FindFeatures(JNIEnv*, jobject, jlong addrGray, jlong addrRgba)
 {
-    jbyte* _yuv  = env->GetByteArrayElements(yuv, 0);
-    jint*  _bgra = env->GetIntArrayElements(bgra, 0);
-
-    Mat myuv(height + height/2, width, CV_8UC1, (unsigned char *)_yuv);
-    Mat mbgra(height, width, CV_8UC4, (unsigned char *)_bgra);
-    Mat mgray(height, width, CV_8UC1, (unsigned char *)_yuv);
-
-    //Please make attention about BGRA byte order
-    //ARGB stored in java as int array becomes BGRA at native level
-    cvtColor(myuv, mbgra, CV_YUV420sp2BGR, 4);
-
+    Mat* pMatGr=(Mat*)addrGray;
+    Mat* pMatRgb=(Mat*)addrRgba;
     vector<KeyPoint> v;
 
     FastFeatureDetector detector(50);
-    detector.detect(mgray, v);
+    detector.detect(*pMatGr, v);
     for( size_t i = 0; i < v.size(); i++ )
-        circle(mbgra, Point(v[i].pt.x, v[i].pt.y), 10, Scalar(0,0,255,255));
-
-    env->ReleaseIntArrayElements(bgra, _bgra, 0);
-    env->ReleaseByteArrayElements(yuv, _yuv, 0);
+        circle(*pMatRgb, Point(v[i].pt.x, v[i].pt.y), 10, Scalar(255,0,0,255));
 }
 
 }

samples/android/tutorial-3-native/res/layout/tutorial3_surface_view.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/tutorial4_activity_surface_view" />
+
+</LinearLayout>

samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3Native.java

@@ -3,21 +3,26 @@ package org.opencv.samples.tutorial3;
 import org.opencv.android.BaseLoaderCallback;
 import org.opencv.android.LoaderCallbackInterface;
 import org.opencv.android.OpenCVLoader;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.android.JavaCameraView;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
+import org.opencv.imgproc.Imgproc;
 
 import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.Window;
 import android.view.WindowManager;
 
-public class Sample3Native extends Activity {
+public class Sample3Native extends Activity implements CvCameraViewListener {
     private static final String TAG = "OCVSample::Activity";
 
-    private Sample3View         mView;
+    private Mat                    mRgba;
+    private Mat                    mGrayMat;
+    private JavaCameraView         mOpenCvCameraView;
 
-    private BaseLoaderCallback  mOpenCVCallBack = new BaseLoaderCallback(this) {
+    private BaseLoaderCallback     mLoaderCallback = new BaseLoaderCallback(this) {
         @Override
         public void onManagerConnected(int status) {
             switch (status) {
@@ -28,37 +33,7 @@ public class Sample3Native extends Activity {
                     // Load native library after(!) OpenCV initialization
                     System.loadLibrary("native_sample");
 
-                    // Create and set View
-                    mView = new Sample3View(mAppContext);
-                    setContentView(mView);
-                    // Check native OpenCV camera
-                    if( !mView.openCamera() ) {
-                        AlertDialog ad = new AlertDialog.Builder(mAppContext).create();
-                        ad.setCancelable(false); // This blocks the 'BACK' button
-                        ad.setMessage("Fatal error: can't open camera!");
-                        ad.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                            public void onClick(DialogInterface dialog, int which) {
-                                dialog.dismiss();
-                                finish();
-                            }
-                        });
-                        ad.show();
-                    }
-                } break;
-                /** OpenCV loader cannot start Google Play **/
-                case LoaderCallbackInterface.MARKET_ERROR:
-                {
-                    Log.d(TAG, "Google Play service is not accessible!");
-                    AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
-                    MarketErrorMessage.setTitle("OpenCV Manager");
-                    MarketErrorMessage.setMessage("Google Play service is not accessible!\nTry to install the 'OpenCV Manager' and the appropriate 'OpenCV binary pack' APKs from OpenCV SDK manually via 'adb install' command.");
-                    MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
-                    MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new DialogInterface.OnClickListener() {
-                        public void onClick(DialogInterface dialog, int which) {
-                            finish();
-                        }
-                    });
-                    MarketErrorMessage.show();
+                    mOpenCvCameraView.enableView();
                 } break;
                 default:
                 {
@@ -72,31 +47,56 @@ public class Sample3Native extends Activity {
         Log.i(TAG, "Instantiated new " + this.getClass());
     }
 
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.tutorial3_surface_view);
+
+        mOpenCvCameraView = (JavaCameraView)findViewById(R.id.tutorial4_activity_surface_view);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
     @Override
-    protected void onPause() {
-        Log.i(TAG, "called onPause");
-        if (null != mView)
-            mView.releaseCamera();
+    public void onPause()
+    {
+        mOpenCvCameraView.disableView();
         super.onPause();
     }
 
     @Override
-    protected void onResume() {
-        Log.i(TAG, "called onResume");
+    public void onResume()
+    {
         super.onResume();
+        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mLoaderCallback);
+    }
 
-        Log.i(TAG, "Trying to load OpenCV library");
-        if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_2, this, mOpenCVCallBack)) {
-            Log.e(TAG, "Cannot connect to OpenCV Manager");
-        }
+    public void onDestroy() {
+        super.onDestroy();
+        mOpenCvCameraView.disableView();
     }
 
-    /** Called when the activity is first created. */
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        Log.i(TAG, "called onCreate");
-        super.onCreate(savedInstanceState);
-        requestWindowFeature(Window.FEATURE_NO_TITLE);
-        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+    public void onCameraViewStarted(int width, int height) {
+        mRgba = new Mat(height, width, CvType.CV_8UC4);
+        mGrayMat = new Mat(height, width, CvType.CV_8UC1);
+    }
+
+    public void onCameraViewStopped() {
+        mRgba.release();
+        mGrayMat.release();
     }
+
+    public Mat onCameraFrame(Mat inputFrame) {
+        inputFrame.copyTo(mRgba);
+        Imgproc.cvtColor(mRgba, mGrayMat, Imgproc.COLOR_RGBA2GRAY);
+        FindFeatures(mGrayMat.getNativeObjAddr(), mRgba.getNativeObjAddr());
+
+        return mRgba;
+    }
+
+    public native void FindFeatures(long matAddrGr, long matAddrRgba);
 }

samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3View.java

-package org.opencv.samples.tutorial3;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.util.Log;
-
-class Sample3View extends SampleViewBase {
-    private static final String TAG = "OCVSample::View";
-
-    private int                 mFrameSize;
-    private Bitmap              mBitmap;
-    private int[]               mRGBA;
-
-    public Sample3View(Context context) {
-        super(context);
-        Log.i(TAG, "Instantiated new " + this.getClass());
-    }
-
-    @Override
-    protected void onPreviewStarted(int previewWidth, int previewHeight) {
-        Log.i(TAG, "called onPreviewStarted("+previewWidth+", "+previewHeight+")");
-
-        mFrameSize = previewWidth * previewHeight;
-        mRGBA = new int[mFrameSize];
-        mBitmap = Bitmap.createBitmap(previewWidth, previewHeight, Bitmap.Config.ARGB_8888);
-    }
-
-    @Override
-    protected void onPreviewStopped() {
-        if(mBitmap != null) {
-            mBitmap.recycle();
-            mBitmap = null;
-        }
-        mRGBA = null;
-    }
-
-    @Override
-    protected Bitmap processFrame(byte[] data) {
-        int[] rgba = mRGBA;
-
-        FindFeatures(getFrameWidth(), getFrameHeight(), data, rgba);
-
-        Bitmap bmp = mBitmap;
-        bmp.setPixels(rgba, 0/* offset */, getFrameWidth() /* stride */, 0, 0, getFrameWidth(), getFrameHeight());
-        return bmp;
-    }
-
-    public native void FindFeatures(int width, int height, byte yuv[], int[] rgba);
-}

samples/android/tutorial-4-mixed/.classpath

 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="output" path="bin/classes"/>
 </classpath>

samples/android/tutorial-4-mixed/jni/jni_part.cpp

@@ -8,7 +8,7 @@ using namespace std;
 using namespace cv;
 
 extern "C" {
-JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial4_Sample4View_FindFeatures(JNIEnv*, jobject, jlong addrGray, jlong addrRgba)
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial4_Sample4Mixed_FindFeatures(JNIEnv*, jobject, jlong addrGray, jlong addrRgba)
 {
     Mat* pMatGr=(Mat*)addrGray;
     Mat* pMatRgb=(Mat*)addrRgba;

samples/android/tutorial-4-mixed/res/layout/tutorial4_surface_view.xml

+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/tutorial4_activity_surface_view" />
+
+</LinearLayout>

samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/Sample4View.java

-package org.opencv.samples.tutorial4;
-
-import org.opencv.android.Utils;
-import org.opencv.core.CvType;
-import org.opencv.core.Mat;
-import org.opencv.imgproc.Imgproc;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.util.Log;
-
-class Sample4View extends SampleViewBase {
-    private static final String TAG = "OCVSample::View";
-
-    public static final int     VIEW_MODE_RGBA     = 0;
-    public static final int     VIEW_MODE_GRAY     = 1;
-    public static final int     VIEW_MODE_CANNY    = 2;
-    public static final int     VIEW_MODE_FEATURES = 5;
-
-    private Mat                 mYuv;
-    private Mat                 mRgba;
-    private Mat                 mGraySubmat;
-    private Mat                 mIntermediateMat;
-    private Bitmap              mBitmap;
-    private int                 mViewMode;
-
-    public Sample4View(Context context) {
-        super(context);
-    }
-
-    @Override
-    protected void onPreviewStarted(int previewWidth, int previewHeight) {
-        Log.i(TAG, "called onPreviewStarted("+previewWidth+", "+previewHeight+")");
-
-        // initialize Mats before usage
-        mYuv = new Mat(getFrameHeight() + getFrameHeight() / 2, getFrameWidth(), CvType.CV_8UC1);
-        mGraySubmat = mYuv.submat(0, getFrameHeight(), 0, getFrameWidth());
-
-        mRgba = new Mat();
-        mIntermediateMat = new Mat();
-
-        mBitmap = Bitmap.createBitmap(previewWidth, previewHeight, Bitmap.Config.ARGB_8888);
-    }
-
-    @Override
-    protected void onPreviewStopped() {
-        Log.i(TAG, "called onPreviewStopped");
-
-        if (mBitmap != null) {
-            mBitmap.recycle();
-            mBitmap = null;
-        }
-
-        synchronized (this) {
-            // Explicitly deallocate Mats
-            if (mYuv != null)
-                mYuv.release();
-            if (mRgba != null)
-                mRgba.release();
-            if (mGraySubmat != null)
-                mGraySubmat.release();
-            if (mIntermediateMat != null)
-                mIntermediateMat.release();
-
-            mYuv = null;
-            mRgba = null;
-            mGraySubmat = null;
-            mIntermediateMat = null;
-        }
-
-    }
-
-
-    @Override
-    protected Bitmap processFrame(byte[] data) {
-        mYuv.put(0, 0, data);
-
-        final int viewMode = mViewMode;
-
-        switch (viewMode) {
-        case VIEW_MODE_GRAY:
-            Imgproc.cvtColor(mGraySubmat, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
-            break;
-        case VIEW_MODE_RGBA:
-            Imgproc.cvtColor(mYuv, mRgba, Imgproc.COLOR_YUV420sp2RGB, 4);
-            break;
-        case VIEW_MODE_CANNY:
-            Imgproc.Canny(mGraySubmat, mIntermediateMat, 80, 100);
-            Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);
-            break;
-        case VIEW_MODE_FEATURES:
-            Imgproc.cvtColor(mYuv, mRgba, Imgproc.COLOR_YUV420sp2RGB, 4);
-            FindFeatures(mGraySubmat.getNativeObjAddr(), mRgba.getNativeObjAddr());
-            break;
-        }
-
-        Bitmap bmp = mBitmap;
-
-        try {
-            Utils.matToBitmap(mRgba, bmp);
-        } catch(Exception e) {
-            Log.e("org.opencv.samples.puzzle15", "Utils.matToBitmap() throws an exception: " + e.getMessage());
-            bmp.recycle();
-            bmp = null;
-        }
-
-        return bmp;
-    }
-
-    public native void FindFeatures(long matAddrGr, long matAddrRgba);
-
-    public void setViewMode(int viewMode) {
-        Log.i(TAG, "called setViewMode("+viewMode+")");
-        mViewMode = viewMode;
-    }
-}