Merge branch 4.x

modules/java/android_sdk/CMakeLists.txt

@@ -27,12 +27,19 @@ if(ANDROID_SDK_COMPATIBLE_TARGET)
   set(ANDROID_SDK_COMPATIBLE_TARGET "${ANDROID_SDK_COMPATIBLE_TARGET}" CACHE INTERNAL "")
 endif()
 string(REGEX REPLACE "android-" "" android_sdk_target_num ${ANDROID_SDK_COMPATIBLE_TARGET})
+
 if( (ANDROID_SDK_TARGET AND ANDROID_SDK_TARGET LESS 21) OR (android_sdk_target_num LESS 21) )
   message(STATUS "[OpenCV for Android SDK]: A new OpenGL Camera Bridge (CameraGLSurfaceView, CameraGLRendererBase, CameraRenderer, Camera2Renderer) is disabled, because ANDROID_SDK_TARGET (${android_sdk_target_num}) < 21")
 else()
   ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android-21/java" "${java_src_dir}")
 endif()
 
+if( (ANDROID_SDK_TARGET AND ANDROID_SDK_TARGET LESS 24) OR (android_sdk_target_num LESS 24) )
+  message(STATUS "[OpenCV for Android SDK]: An experiemntal Native Camera is disabled, because ANDROID_SDK_TARGET (${android_sdk_target_num}) < 24")
+else()
+  ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android-24/java" "${java_src_dir}")
+endif()
+
 # copy boilerplate
 file(GLOB_RECURSE seed_project_files_rel RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/" "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/*")
 list(REMOVE_ITEM seed_project_files_rel "${ANDROID_MANIFEST_FILE}")
@@ -113,6 +120,7 @@ else()  # gradle build
 #TODO: INSTALL ONLY
 ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android/java" "${java_src_dir}")
 ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android-21/java" "${java_src_dir}")
+ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android-24/java" "${java_src_dir}")
 
 # copy boilerplate
 set(__base_dir "${CMAKE_CURRENT_SOURCE_DIR}/android_gradle_lib/")

modules/java/android_sdk/android_gradle_lib/build.gradle

@@ -5,6 +5,7 @@ def openCVersionName = "@OPENCV_VERSION@"
 def openCVersionCode = ((@OPENCV_VERSION_MAJOR@ * 100 + @OPENCV_VERSION_MINOR@) * 100 + @OPENCV_VERSION_PATCH@) * 10 + 0
 
 android {
+    @OPENCV_ANDROID_NAMESPACE_DECLARATION@
     compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
 
     defaultConfig {

modules/java/android_sdk/build.gradle.in

@@ -49,7 +49,7 @@
 // - avoid using of "OpenCVLoader.initAsync()" approach - it is deprecated
 //   It may load library with different version (from OpenCV Android Manager, which is installed separatelly on device)
 //
-// - use "System.loadLibrary("opencv_java4")" or "OpenCVLoader.initDebug()"
+// - use "System.loadLibrary("opencv_java5")" or "OpenCVLoader.initDebug()"
 //   TODO: Add accurate API to load OpenCV native library
 //
 //
@@ -89,6 +89,7 @@
 //
 
 apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
 @KOTLIN_PLUGIN_DECLARATION@
 
 def openCVersionName = "@OPENCV_VERSION@"
@@ -137,6 +138,17 @@ android {
         }
     }
 
+    buildFeatures {
+        aidl true
+        prefabPublishing true
+        buildConfig true
+    }
+    prefab {
+        opencv_jni_shared {
+            headers "native/jni/include"
+        }
+    }
+
     sourceSets {
         main {
             jniLibs.srcDirs = ['native/libs']
@@ -147,6 +159,13 @@ android {
         }
     }
 
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
+
     externalNativeBuild {
         cmake {
             path (project.projectDir.toString() + '/libcxx_helper/CMakeLists.txt')
@@ -154,5 +173,25 @@ android {
     }
 }
 
+publishing {
+    publications {
+        release(MavenPublication) {
+            groupId = 'org.opencv'
+            artifactId = 'opencv'
+            version = '@OPENCV_VERSION_PLAIN@'
+
+            afterEvaluate {
+               from components.release
+           }
+        }
+    }
+    repositories {
+        maven {
+            name = 'myrepo'
+            url = "${project.buildDir}/repo"
+        }
+    }
+}
+
 dependencies {
 }

modules/java/android_sdk/libcxx_helper/CMakeLists.txt

@@ -1,4 +1,6 @@
 cmake_minimum_required(VERSION 3.6)
 
+project(opencv_jni_shared)
+
 # dummy target to bring libc++_shared.so into packages
 add_library(opencv_jni_shared STATIC dummy.cpp)

modules/java/generator/android-21/java/org/opencv/android/JavaCamera2View.java

@@ -45,6 +45,7 @@ public class JavaCamera2View extends CameraBridgeViewBase {
 
     protected ImageReader mImageReader;
     protected int mPreviewFormat = ImageFormat.YUV_420_888;
+    protected int mRequestTemplate = CameraDevice.TEMPLATE_PREVIEW;
 
     protected CameraDevice mCameraDevice;
     protected CameraCaptureSession mCaptureSession;
@@ -155,6 +156,35 @@ public class JavaCamera2View extends CameraBridgeViewBase {
 
     };
 
+    protected CameraCaptureSession.StateCallback allocateSessionStateCallback() {
+        return new CameraCaptureSession.StateCallback() {
+            @Override
+            public void onConfigured(CameraCaptureSession cameraCaptureSession) {
+                Log.i(LOGTAG, "createCaptureSession::onConfigured");
+                if (null == mCameraDevice) {
+                    return; // camera is already closed
+                }
+                mCaptureSession = cameraCaptureSession;
+                try {
+                    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
+                            CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+                    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
+                            CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
+
+                    mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler);
+                    Log.i(LOGTAG, "CameraPreviewSession has been started");
+                } catch (Exception e) {
+                    Log.e(LOGTAG, "createCaptureSession failed", e);
+                }
+            }
+
+            @Override
+            public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
+                Log.e(LOGTAG, "createCameraPreviewSession failed");
+            }
+        };
+    }
+
     private void createCameraPreviewSession() {
         final int w = mPreviewSize.getWidth(), h = mPreviewSize.getHeight();
         Log.i(LOGTAG, "createCameraPreviewSession(" + w + "x" + h + ")");
@@ -191,38 +221,11 @@ public class JavaCamera2View extends CameraBridgeViewBase {
             }, mBackgroundHandler);
             Surface surface = mImageReader.getSurface();
 
-            mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
+            mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(mRequestTemplate);
             mPreviewRequestBuilder.addTarget(surface);
 
             mCameraDevice.createCaptureSession(Arrays.asList(surface),
-                new CameraCaptureSession.StateCallback() {
-                    @Override
-                    public void onConfigured(CameraCaptureSession cameraCaptureSession) {
-                        Log.i(LOGTAG, "createCaptureSession::onConfigured");
-                        if (null == mCameraDevice) {
-                            return; // camera is already closed
-                        }
-                        mCaptureSession = cameraCaptureSession;
-                        try {
-                            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
-                                    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
-                            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
-                                    CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
-
-                            mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler);
-                            Log.i(LOGTAG, "CameraPreviewSession has been started");
-                        } catch (Exception e) {
-                            Log.e(LOGTAG, "createCaptureSession failed", e);
-                        }
-                    }
-
-                    @Override
-                    public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
-                        Log.e(LOGTAG, "createCameraPreviewSession failed");
-                    }
-                },
-                null
-            );
+                                               allocateSessionStateCallback(), null);
         } catch (CameraAccessException e) {
             Log.e(LOGTAG, "createCameraPreviewSession", e);
         }
@@ -321,6 +324,10 @@ public class JavaCamera2View extends CameraBridgeViewBase {
                 }
                 createCameraPreviewSession();
             }
+
+            if (mFpsMeter != null) {
+                mFpsMeter.setResolution(mFrameWidth, mFrameHeight);
+            }
         } catch (RuntimeException e) {
             throw new RuntimeException("Interrupted while setCameraPreviewSize.", e);
         }

modules/java/generator/android-24/java/org/opencv/android/NativeCameraView.java

@@ -0,0 +1,191 @@
+package org.opencv.android;
+
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+
+import org.opencv.imgproc.Imgproc;
+
+import org.opencv.videoio.Videoio;
+import org.opencv.videoio.VideoCapture;
+import org.opencv.videoio.VideoWriter;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ViewGroup.LayoutParams;
+
+/**
+ * This class is an implementation of a bridge between SurfaceView and OpenCV VideoCapture.
+ * The class  is experimental implementation and not recoomended for production usage.
+ */
+public class NativeCameraView extends CameraBridgeViewBase {
+
+    public static final String TAG = "NativeCameraView";
+    private boolean mStopThread;
+    private Thread mThread;
+
+    protected VideoCapture mCamera;
+    protected NativeCameraFrame mFrame;
+
+    public NativeCameraView(Context context, int cameraId) {
+        super(context, cameraId);
+    }
+
+    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(width, height))
+            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
+         */
+        if (mThread != null) {
+            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) {
+
+            if (mCameraIndex == -1) {
+                Log.d(TAG, "Try to open default camera");
+                mCamera = new VideoCapture(0, Videoio.CAP_ANDROID);
+            } else {
+                Log.d(TAG, "Try to open camera with index " + mCameraIndex);
+                mCamera = new VideoCapture(mCameraIndex, Videoio.CAP_ANDROID);
+            }
+
+            if (mCamera == null)
+                return false;
+
+            if (mCamera.isOpened() == false)
+                return false;
+
+            mFrame = new NativeCameraFrame(mCamera);
+
+            mCamera.set(Videoio.CAP_PROP_FRAME_WIDTH, width);
+            mCamera.set(Videoio.CAP_PROP_FRAME_HEIGHT, height);
+
+            mFrameWidth = (int)mCamera.get(Videoio.CAP_PROP_FRAME_WIDTH);
+            mFrameHeight = (int)mCamera.get(Videoio.CAP_PROP_FRAME_HEIGHT);
+
+            if ((getLayoutParams().width == LayoutParams.MATCH_PARENT) && (getLayoutParams().height == LayoutParams.MATCH_PARENT))
+                mScale = Math.min(((float)height)/mFrameHeight, ((float)width)/mFrameWidth);
+            else
+                mScale = 0;
+
+            if (mFpsMeter != null) {
+                mFpsMeter.setResolution(mFrameWidth, mFrameHeight);
+            }
+
+            AllocateCache();
+        }
+
+        Log.i(TAG, "Selected camera frame size = (" + mFrameWidth + ", " + mFrameHeight + ")");
+
+        return true;
+    }
+
+    private void releaseCamera() {
+        synchronized (this) {
+            if (mFrame != null) mFrame.release();
+            if (mCamera != null) mCamera.release();
+        }
+    }
+
+    private static class NativeCameraFrame implements CvCameraViewFrame {
+
+        @Override
+        public Mat rgba() {
+            mCapture.set(Videoio.CAP_PROP_FOURCC, VideoWriter.fourcc('R','G','B','3'));
+            mCapture.retrieve(mBgr);
+            Log.d(TAG, "Retrived frame with size " + mBgr.cols() + "x" + mBgr.rows() + " and channels: " + mBgr.channels());
+            Imgproc.cvtColor(mBgr, mRgba, Imgproc.COLOR_RGB2RGBA);
+            return mRgba;
+        }
+
+        @Override
+        public Mat gray() {
+            mCapture.set(Videoio.CAP_PROP_FOURCC, VideoWriter.fourcc('G','R','E','Y'));
+            mCapture.retrieve(mGray);
+            Log.d(TAG, "Retrived frame with size " + mGray.cols() + "x" + mGray.rows() + " and channels: " + mGray.channels());
+            return mGray;
+        }
+
+        public NativeCameraFrame(VideoCapture capture) {
+            mCapture = capture;
+            mGray = new Mat();
+            mRgba = new Mat();
+            mBgr = new Mat();
+        }
+
+        public void release() {
+            if (mGray != null) mGray.release();
+            if (mRgba != null) mRgba.release();
+            if (mBgr != null) mBgr.release();
+        }
+
+        private VideoCapture mCapture;
+        private Mat mRgba;
+        private Mat mGray;
+        private Mat mBgr;
+    };
+
+    private class CameraWorker implements Runnable {
+
+        public void run() {
+            do {
+                if (!mCamera.grab()) {
+                    Log.e(TAG, "Camera frame grab failed");
+                    break;
+                }
+
+                deliverAndDrawFrame(mFrame);
+            } while (!mStopThread);
+        }
+    }
+
+}

modules/java/generator/android/java/org/opencv/android/AsyncServiceHelper.java

@@ -1,391 +0,0 @@
-package org.opencv.android;
-
-import java.io.File;
-import java.util.StringTokenizer;
-
-import org.opencv.core.Core;
-import org.opencv.engine.OpenCVEngineInterface;
-
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.Intent;
-import android.content.ServiceConnection;
-import android.net.Uri;
-import android.os.IBinder;
-import android.os.RemoteException;
-import android.util.Log;
-
-class AsyncServiceHelper
-{
-    public static boolean initOpenCV(String Version, final Context AppContext,
-            final LoaderCallbackInterface Callback)
-    {
-        AsyncServiceHelper helper = new AsyncServiceHelper(Version, AppContext, Callback);
-        Intent intent = new Intent("org.opencv.engine.BIND");
-        intent.setPackage("org.opencv.engine");
-        if (AppContext.bindService(intent, helper.mServiceConnection, Context.BIND_AUTO_CREATE))
-        {
-            return true;
-        }
-        else
-        {
-            AppContext.unbindService(helper.mServiceConnection);
-            InstallService(AppContext, Callback);
-            return false;
-        }
-    }
-
-    protected AsyncServiceHelper(String Version, Context AppContext, LoaderCallbackInterface Callback)
-    {
-        mOpenCVersion = Version;
-        mUserAppCallback = Callback;
-        mAppContext = AppContext;
-    }
-
-    protected static final String TAG = "OpenCVManager/Helper";
-    protected static final int MINIMUM_ENGINE_VERSION = 2;
-    protected OpenCVEngineInterface mEngineService;
-    protected LoaderCallbackInterface mUserAppCallback;
-    protected String mOpenCVersion;
-    protected Context mAppContext;
-    protected static boolean mServiceInstallationProgress = false;
-    protected static boolean mLibraryInstallationProgress = false;
-
-    protected static boolean InstallServiceQuiet(Context context)
-    {
-        boolean result = true;
-        try
-        {
-            Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(OPEN_CV_SERVICE_URL));
-            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-            context.startActivity(intent);
-        }
-        catch(Exception e)
-        {
-            result = false;
-        }
-
-        return result;
-    }
-
-    protected static void InstallService(final Context AppContext, final LoaderCallbackInterface Callback)
-    {
-        if (!mServiceInstallationProgress)
-        {
-                Log.d(TAG, "Request new service installation");
-                InstallCallbackInterface InstallQuery = new InstallCallbackInterface() {
-                private LoaderCallbackInterface mUserAppCallback = Callback;
-                public String getPackageName()
-                {
-                    return "OpenCV Manager";
-                }
-                public void install() {
-                    Log.d(TAG, "Trying to install OpenCV Manager via Google Play");
-
-                    boolean result = InstallServiceQuiet(AppContext);
-                    if (result)
-                    {
-                        mServiceInstallationProgress = true;
-                        Log.d(TAG, "Package installation started");
-                    }
-                    else
-                    {
-                        Log.d(TAG, "OpenCV package was not installed!");
-                        int Status = LoaderCallbackInterface.MARKET_ERROR;
-                        Log.d(TAG, "Init finished with status " + Status);
-                        Log.d(TAG, "Unbind from service");
-                        Log.d(TAG, "Calling using callback");
-                        mUserAppCallback.onManagerConnected(Status);
-                    }
-                }
-
-                public void cancel()
-                {
-                    Log.d(TAG, "OpenCV library installation was canceled");
-                    int Status = LoaderCallbackInterface.INSTALL_CANCELED;
-                    Log.d(TAG, "Init finished with status " + Status);
-                    Log.d(TAG, "Calling using callback");
-                    mUserAppCallback.onManagerConnected(Status);
-                }
-
-                public void wait_install()
-                {
-                    Log.e(TAG, "Installation was not started! Nothing to wait!");
-                }
-            };
-
-            Callback.onPackageInstall(InstallCallbackInterface.NEW_INSTALLATION, InstallQuery);
-        }
-        else
-        {
-            Log.d(TAG, "Waiting current installation process");
-            InstallCallbackInterface WaitQuery = new InstallCallbackInterface() {
-                private LoaderCallbackInterface mUserAppCallback = Callback;
-                public String getPackageName()
-                {
-                    return "OpenCV Manager";
-                }
-                public void install()
-                {
-                    Log.e(TAG, "Nothing to install we just wait current installation");
-                }
-                public void cancel()
-                {
-                    Log.d(TAG, "Waiting for OpenCV canceled by user");
-                    mServiceInstallationProgress = false;
-                    int Status = LoaderCallbackInterface.INSTALL_CANCELED;
-                    Log.d(TAG, "Init finished with status " + Status);
-                    Log.d(TAG, "Calling using callback");
-                    mUserAppCallback.onManagerConnected(Status);
-                }
-                public void wait_install()
-                {
-                     InstallServiceQuiet(AppContext);
-                }
-            };
-
-            Callback.onPackageInstall(InstallCallbackInterface.INSTALLATION_PROGRESS, WaitQuery);
-        }
-    }
-
-    /**
-     *  URL of OpenCV Manager page on Google Play Market.
-     */
-    protected static final String OPEN_CV_SERVICE_URL = "market://details?id=org.opencv.engine";
-
-    protected ServiceConnection mServiceConnection = new ServiceConnection()
-    {
-        public void onServiceConnected(ComponentName className, IBinder service)
-        {
-            Log.d(TAG, "Service connection created");
-            mEngineService = OpenCVEngineInterface.Stub.asInterface(service);
-            if (null == mEngineService)
-            {
-                Log.d(TAG, "OpenCV Manager Service connection fails. May be service was not installed?");
-                InstallService(mAppContext, mUserAppCallback);
-            }
-            else
-            {
-                mServiceInstallationProgress = false;
-                try
-                {
-                    if (mEngineService.getEngineVersion() < MINIMUM_ENGINE_VERSION)
-                    {
-                        Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION);
-                        Log.d(TAG, "Unbind from service");
-                        mAppContext.unbindService(mServiceConnection);
-                        Log.d(TAG, "Calling using callback");
-                        mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION);
-                        return;
-                    }
-
-                    Log.d(TAG, "Trying to get library path");
-                    String path = mEngineService.getLibPathByVersion(mOpenCVersion);
-                    if ((null == path) || (path.length() == 0))
-                    {
-                        if (!mLibraryInstallationProgress)
-                        {
-                            InstallCallbackInterface InstallQuery = new InstallCallbackInterface() {
-                                public String getPackageName()
-                                {
-                                    return "OpenCV library";
-                                }
-                                public void install() {
-                                    Log.d(TAG, "Trying to install OpenCV lib via Google Play");
-                                    try
-                                    {
-                                        if (mEngineService.installVersion(mOpenCVersion))
-                                        {
-                                            mLibraryInstallationProgress = true;
-                                            Log.d(TAG, "Package installation started");
-                                            Log.d(TAG, "Unbind from service");
-                                            mAppContext.unbindService(mServiceConnection);
-                                        }
-                                        else
-                                        {
-                                            Log.d(TAG, "OpenCV package was not installed!");
-                                            Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.MARKET_ERROR);
-                                            Log.d(TAG, "Unbind from service");
-                                            mAppContext.unbindService(mServiceConnection);
-                                            Log.d(TAG, "Calling using callback");
-                                            mUserAppCallback.onManagerConnected(LoaderCallbackInterface.MARKET_ERROR);
-                                        }
-                                    } catch (RemoteException e) {
-                                        e.printStackTrace();;
-                                        Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INIT_FAILED);
-                                        Log.d(TAG, "Unbind from service");
-                                        mAppContext.unbindService(mServiceConnection);
-                                        Log.d(TAG, "Calling using callback");
-                                        mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INIT_FAILED);
-                                    }
-                                }
-                                public void cancel() {
-                                    Log.d(TAG, "OpenCV library installation was canceled");
-                                    Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INSTALL_CANCELED);
-                                    Log.d(TAG, "Unbind from service");
-                                    mAppContext.unbindService(mServiceConnection);
-                                    Log.d(TAG, "Calling using callback");
-                                    mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INSTALL_CANCELED);
-                                }
-                                public void wait_install() {
-                                    Log.e(TAG, "Installation was not started! Nothing to wait!");
-                                }
-                            };
-
-                            mUserAppCallback.onPackageInstall(InstallCallbackInterface.NEW_INSTALLATION, InstallQuery);
-                        }
-                        else
-                        {
-                            InstallCallbackInterface WaitQuery = new InstallCallbackInterface() {
-                                public String getPackageName()
-                                {
-                                    return "OpenCV library";
-                                }
-
-                                public void install() {
-                                    Log.e(TAG, "Nothing to install we just wait current installation");
-                                }
-                                public void cancel()
-                                {
-                                    Log.d(TAG, "OpenCV library installation was canceled");
-                                    mLibraryInstallationProgress = false;
-                                    Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INSTALL_CANCELED);
-                                    Log.d(TAG, "Unbind from service");
-                                    mAppContext.unbindService(mServiceConnection);
-                                    Log.d(TAG, "Calling using callback");
-                                        mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INSTALL_CANCELED);
-                                }
-                                public void wait_install() {
-                                    Log.d(TAG, "Waiting for current installation");
-                                    try
-                                    {
-                                        if (!mEngineService.installVersion(mOpenCVersion))
-                                        {
-                                            Log.d(TAG, "OpenCV package was not installed!");
-                                            Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.MARKET_ERROR);
-                                            Log.d(TAG, "Calling using callback");
-                                            mUserAppCallback.onManagerConnected(LoaderCallbackInterface.MARKET_ERROR);
-                                        }
-                                        else
-                                        {
-                                            Log.d(TAG, "Waiting for package installation");
-                                        }
-
-                                        Log.d(TAG, "Unbind from service");
-                                        mAppContext.unbindService(mServiceConnection);
-
-                                    } catch (RemoteException e) {
-                                        e.printStackTrace();
-                                        Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INIT_FAILED);
-                                        Log.d(TAG, "Unbind from service");
-                                        mAppContext.unbindService(mServiceConnection);
-                                        Log.d(TAG, "Calling using callback");
-                                        mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INIT_FAILED);
-                                    }
-                               }
-                            };
-
-                            mUserAppCallback.onPackageInstall(InstallCallbackInterface.INSTALLATION_PROGRESS, WaitQuery);
-                        }
-                        return;
-                    }
-                    else
-                    {
-                        Log.d(TAG, "Trying to get library list");
-                        mLibraryInstallationProgress = false;
-                        String libs = mEngineService.getLibraryList(mOpenCVersion);
-                        Log.d(TAG, "Library list: \"" + libs + "\"");
-                        Log.d(TAG, "First attempt to load libs");
-                        int status;
-                        if (initOpenCVLibs(path, libs))
-                        {
-                            Log.d(TAG, "First attempt to load libs is OK");
-                            String eol = System.getProperty("line.separator");
-                            for (String str : Core.getBuildInformation().split(eol))
-                                Log.i(TAG, str);
-
-                            status = LoaderCallbackInterface.SUCCESS;
-                        }
-                        else
-                        {
-                            Log.d(TAG, "First attempt to load libs fails");
-                            status = LoaderCallbackInterface.INIT_FAILED;
-                        }
-
-                        Log.d(TAG, "Init finished with status " + status);
-                        Log.d(TAG, "Unbind from service");
-                        mAppContext.unbindService(mServiceConnection);
-                        Log.d(TAG, "Calling using callback");
-                        mUserAppCallback.onManagerConnected(status);
-                    }
-                }
-                catch (RemoteException e)
-                {
-                    e.printStackTrace();
-                    Log.d(TAG, "Init finished with status " + LoaderCallbackInterface.INIT_FAILED);
-                    Log.d(TAG, "Unbind from service");
-                    mAppContext.unbindService(mServiceConnection);
-                    Log.d(TAG, "Calling using callback");
-                    mUserAppCallback.onManagerConnected(LoaderCallbackInterface.INIT_FAILED);
-                }
-            }
-        }
-
-        public void onServiceDisconnected(ComponentName className)
-        {
-            mEngineService = null;
-        }
-    };
-
-    private boolean loadLibrary(String AbsPath)
-    {
-        boolean result = true;
-
-        Log.d(TAG, "Trying to load library " + AbsPath);
-        try
-        {
-            System.load(AbsPath);
-            Log.d(TAG, "OpenCV libs init was ok!");
-        }
-        catch(UnsatisfiedLinkError e)
-        {
-            Log.d(TAG, "Cannot load library \"" + AbsPath + "\"");
-            e.printStackTrace();
-            result = false;
-        }
-
-        return result;
-    }
-
-    private boolean initOpenCVLibs(String Path, String Libs)
-    {
-        Log.d(TAG, "Trying to init OpenCV libs");
-        if ((null != Path) && (Path.length() != 0))
-        {
-            boolean result = true;
-            if ((null != Libs) && (Libs.length() != 0))
-            {
-                Log.d(TAG, "Trying to load libs by dependency list");
-                StringTokenizer splitter = new StringTokenizer(Libs, ";");
-                while(splitter.hasMoreTokens())
-                {
-                    String AbsLibraryPath = Path + File.separator + splitter.nextToken();
-                    result &= loadLibrary(AbsLibraryPath);
-                }
-            }
-            else
-            {
-                // If the dependencies list is not defined or empty.
-                String AbsLibraryPath = Path + File.separator + "libopencv_java4.so";
-                result = loadLibrary(AbsLibraryPath);
-            }
-
-            return result;
-        }
-        else
-        {
-            Log.d(TAG, "Library path \"" + Path + "\" is empty");
-            return false;
-        }
-    }
-}

modules/java/generator/android/java/org/opencv/android/BaseLoaderCallback.java

@@ -1,141 +0,0 @@
-package org.opencv.android;
-
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.DialogInterface.OnClickListener;
-import android.util.Log;
-
-/**
- * Basic implementation of LoaderCallbackInterface.
- */
-public abstract class BaseLoaderCallback implements LoaderCallbackInterface {
-
-    public BaseLoaderCallback(Context AppContext) {
-        mAppContext = AppContext;
-    }
-
-    public void onManagerConnected(int status)
-    {
-        switch (status)
-        {
-            /** OpenCV initialization was successful. **/
-            case LoaderCallbackInterface.SUCCESS:
-            {
-                /** Application must override this method to handle successful library initialization. **/
-            } break;
-            /** OpenCV loader can not start Google Play Market. **/
-            case LoaderCallbackInterface.MARKET_ERROR:
-            {
-                Log.e(TAG, "Package installation failed!");
-                AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
-                MarketErrorMessage.setTitle("OpenCV Manager");
-                MarketErrorMessage.setMessage("Package installation failed!");
-                MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
-                MarketErrorMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() {
-                    public void onClick(DialogInterface dialog, int which) {
-                        finish();
-                    }
-                });
-                MarketErrorMessage.show();
-            } break;
-            /** Package installation has been canceled. **/
-            case LoaderCallbackInterface.INSTALL_CANCELED:
-            {
-                Log.d(TAG, "OpenCV library installation was canceled by user");
-                finish();
-            } break;
-            /** Application is incompatible with this version of OpenCV Manager. Possibly, a service update is required. **/
-            case LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION:
-            {
-                Log.d(TAG, "OpenCV Manager Service is uncompatible with this app!");
-                AlertDialog IncomatibilityMessage = new AlertDialog.Builder(mAppContext).create();
-                IncomatibilityMessage.setTitle("OpenCV Manager");
-                IncomatibilityMessage.setMessage("OpenCV Manager service is incompatible with this app. Try to update it via Google Play.");
-                IncomatibilityMessage.setCancelable(false); // This blocks the 'BACK' button
-                IncomatibilityMessage.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() {
-                    public void onClick(DialogInterface dialog, int which) {
-                        finish();
-                    }
-                });
-                IncomatibilityMessage.show();
-            } break;
-            /** Other status, i.e. INIT_FAILED. **/
-            default:
-            {
-                Log.e(TAG, "OpenCV loading failed!");
-                AlertDialog InitFailedDialog = new AlertDialog.Builder(mAppContext).create();
-                InitFailedDialog.setTitle("OpenCV error");
-                InitFailedDialog.setMessage("OpenCV was not initialised correctly. Application will be shut down");
-                InitFailedDialog.setCancelable(false); // This blocks the 'BACK' button
-                InitFailedDialog.setButton(AlertDialog.BUTTON_POSITIVE, "OK", new OnClickListener() {
-
-                    public void onClick(DialogInterface dialog, int which) {
-                        finish();
-                    }
-                });
-
-                InitFailedDialog.show();
-            } break;
-        }
-    }
-
-    public void onPackageInstall(final int operation, final InstallCallbackInterface callback)
-    {
-        switch (operation)
-        {
-            case InstallCallbackInterface.NEW_INSTALLATION:
-            {
-                AlertDialog InstallMessage = new AlertDialog.Builder(mAppContext).create();
-                InstallMessage.setTitle("Package not found");
-                InstallMessage.setMessage(callback.getPackageName() + " package was not found! Try to install it?");
-                InstallMessage.setCancelable(false); // This blocks the 'BACK' button
-                InstallMessage.setButton(AlertDialog.BUTTON_POSITIVE, "Yes", new OnClickListener()
-                {
-                    public void onClick(DialogInterface dialog, int which)
-                    {
-                        callback.install();
-                    }
-                });
-
-                InstallMessage.setButton(AlertDialog.BUTTON_NEGATIVE, "No", new OnClickListener() {
-
-                    public void onClick(DialogInterface dialog, int which)
-                    {
-                        callback.cancel();
-                    }
-                });
-
-                InstallMessage.show();
-            } break;
-            case InstallCallbackInterface.INSTALLATION_PROGRESS:
-            {
-                AlertDialog WaitMessage = new AlertDialog.Builder(mAppContext).create();
-                WaitMessage.setTitle("OpenCV is not ready");
-                WaitMessage.setMessage("Installation is in progress. Wait or exit?");
-                WaitMessage.setCancelable(false); // This blocks the 'BACK' button
-                WaitMessage.setButton(AlertDialog.BUTTON_POSITIVE, "Wait", new OnClickListener() {
-                    public void onClick(DialogInterface dialog, int which) {
-                        callback.wait_install();
-                    }
-                });
-                WaitMessage.setButton(AlertDialog.BUTTON_NEGATIVE, "Exit", new OnClickListener() {
-                    public void onClick(DialogInterface dialog, int which) {
-                        callback.cancel();
-                    }
-                });
-
-                WaitMessage.show();
-            } break;
-        }
-    }
-
-    void finish()
-    {
-        ((Activity) mAppContext).finish();
-    }
-
-    protected Context mAppContext;
-    private final static String TAG = "OCV/BaseLoaderCallback";
-}

modules/java/generator/android/java/org/opencv/android/FpsMeter.java

@@ -54,6 +54,7 @@ public class FpsMeter {
     }
 
     public void setResolution(int width, int height) {
+        Log.d(TAG, "FpsMeter.setResolution " + Integer.valueOf(mWidth) + "x" + Integer.valueOf(mHeight));
         mWidth = width;
         mHeight = height;
     }

modules/java/generator/android/java/org/opencv/android/InstallCallbackInterface.java

@@ -1,34 +0,0 @@
-package org.opencv.android;
-
-/**
- * Installation callback interface.
- */
-public interface InstallCallbackInterface
-{
-    /**
-     * New package installation is required.
-     */
-    static final int NEW_INSTALLATION = 0;
-    /**
-     * Current package installation is in progress.
-     */
-    static final int INSTALLATION_PROGRESS = 1;
-
-    /**
-     * Target package name.
-     * @return Return target package name.
-     */
-    public String getPackageName();
-    /**
-     * Installation is approved.
-     */
-    public void install();
-    /**
-     * Installation is canceled.
-     */
-    public void cancel();
-    /**
-     * Wait for package installation.
-     */
-    public void wait_install();
-};

modules/java/generator/android/java/org/opencv/android/LoaderCallbackInterface.java

@@ -1,40 +0,0 @@
-package org.opencv.android;
-
-/**
- * Interface for callback object in case of asynchronous initialization of OpenCV.
- */
-public interface LoaderCallbackInterface
-{
-    /**
-     * OpenCV initialization finished successfully.
-     */
-    static final int SUCCESS = 0;
-    /**
-     * Google Play Market cannot be invoked.
-     */
-    static final int MARKET_ERROR = 2;
-    /**
-     * OpenCV library installation has been canceled by the user.
-     */
-    static final int INSTALL_CANCELED = 3;
-    /**
-     * This version of OpenCV Manager Service is incompatible with the app. Possibly, a service update is required.
-     */
-    static final int INCOMPATIBLE_MANAGER_VERSION = 4;
-    /**
-     * OpenCV library initialization has failed.
-     */
-    static final int INIT_FAILED = 0xff;
-
-    /**
-     * Callback method, called after OpenCV library initialization.
-     * @param status status of initialization (see initialization status constants).
-     */
-    public void onManagerConnected(int status);
-
-    /**
-     * Callback method, called in case the package installation is needed.
-     * @param callback answer object with approve and cancel methods and the package description.
-     */
-    public void onPackageInstall(final int operation, InstallCallbackInterface callback);
-};

modules/java/generator/android/java/org/opencv/android/OpenCVLoader.java.in

@@ -7,102 +7,26 @@ import android.content.Context;
  */
 public class OpenCVLoader
 {
-    /**
-     * OpenCV Library version 2.4.2.
-     */
-    public static final String OPENCV_VERSION_2_4_2 = "2.4.2";
-
-    /**
-     * OpenCV Library version 2.4.3.
-     */
-    public static final String OPENCV_VERSION_2_4_3 = "2.4.3";
-
-    /**
-     * OpenCV Library version 2.4.4.
-     */
-    public static final String OPENCV_VERSION_2_4_4 = "2.4.4";
-
-    /**
-     * OpenCV Library version 2.4.5.
-     */
-    public static final String OPENCV_VERSION_2_4_5 = "2.4.5";
-
-    /**
-     * OpenCV Library version 2.4.6.
-     */
-    public static final String OPENCV_VERSION_2_4_6 = "2.4.6";
-
-    /**
-     * OpenCV Library version 2.4.7.
-     */
-    public static final String OPENCV_VERSION_2_4_7 = "2.4.7";
-
-    /**
-     * OpenCV Library version 2.4.8.
-     */
-    public static final String OPENCV_VERSION_2_4_8 = "2.4.8";
-
-    /**
-     * OpenCV Library version 2.4.9.
-     */
-    public static final String OPENCV_VERSION_2_4_9 = "2.4.9";
-
-    /**
-     * OpenCV Library version 2.4.10.
-     */
-    public static final String OPENCV_VERSION_2_4_10 = "2.4.10";
-
-    /**
-     * OpenCV Library version 2.4.11.
-     */
-    public static final String OPENCV_VERSION_2_4_11 = "2.4.11";
-
-    /**
-     * OpenCV Library version 2.4.12.
-     */
-    public static final String OPENCV_VERSION_2_4_12 = "2.4.12";
-
-    /**
-     * OpenCV Library version 2.4.13.
-     */
-    public static final String OPENCV_VERSION_2_4_13 = "2.4.13";
-
-    /**
-     * OpenCV Library version 3.0.0.
-     */
-    public static final String OPENCV_VERSION_3_0_0 = "3.0.0";
-
-    /**
-     * OpenCV Library version 3.1.0.
-     */
-    public static final String OPENCV_VERSION_3_1_0 = "3.1.0";
-
-    /**
-     * OpenCV Library version 3.2.0.
-     */
-    public static final String OPENCV_VERSION_3_2_0 = "3.2.0";
-
-    /**
-     * OpenCV Library version 3.3.0.
-     */
-    public static final String OPENCV_VERSION_3_3_0 = "3.3.0";
-
-    /**
-     * OpenCV Library version 3.4.0.
-     */
-    public static final String OPENCV_VERSION_3_4_0 = "3.4.0";
-
     /**
      * Current OpenCV Library version
      */
     public static final String OPENCV_VERSION = "@OPENCV_VERSION_MAJOR@.@OPENCV_VERSION_MINOR@.@OPENCV_VERSION_PATCH@";
 
 
+    /**
+     * Synonym for initLocal. Deprecated.
+     */
+    @Deprecated
+    public static boolean initDebug()
+    {
+        return StaticHelper.initOpenCV(false);
+    }
+
     /**
      * Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java").
      * @return Returns true is initialization of OpenCV was successful.
      */
-    public static boolean initDebug()
+    public static boolean initLocal()
     {
         return StaticHelper.initOpenCV(false);
     }
@@ -112,21 +36,9 @@ public class OpenCVLoader
      * @param InitCuda load and initialize CUDA runtime libraries.
      * @return Returns true is initialization of OpenCV was successful.
      */
+    @Deprecated
     public static boolean initDebug(boolean InitCuda)
     {
         return StaticHelper.initOpenCV(InitCuda);
     }
-
-    /**
-     * Loads and initializes OpenCV library using OpenCV Engine service.
-     * @param Version OpenCV library version.
-     * @param AppContext application context for connecting to the service.
-     * @param Callback object, that implements LoaderCallbackInterface for handling the connection status.
-     * @return Returns true if initialization of OpenCV is successful.
-     */
-    public static boolean initAsync(String Version, Context AppContext,
-            LoaderCallbackInterface Callback)
-    {
-        return AsyncServiceHelper.initOpenCV(Version, AppContext, Callback);
-    }
 }

modules/java/generator/android/java/org/opencv/android/StaticHelper.java

@@ -13,30 +13,10 @@ class StaticHelper {
         String libs = "";
 
         if(InitCuda)
-        {
-            loadLibrary("cudart");
-            loadLibrary("nppc");
-            loadLibrary("nppi");
-            loadLibrary("npps");
-            loadLibrary("cufft");
-            loadLibrary("cublas");
-        }
+            Log.w(TAG, "CUDA support was removed!");
 
-        Log.d(TAG, "Trying to get library list");
-
-        try
-        {
-            System.loadLibrary("opencv_info");
-            libs = getLibraryList();
-        }
-        catch(UnsatisfiedLinkError e)
-        {
-            Log.e(TAG, "OpenCV error: Cannot load info library for OpenCV");
-        }
-
-        Log.d(TAG, "Library list: \"" + libs + "\"");
         Log.d(TAG, "First attempt to load libs");
-        if (initOpenCVLibs(libs))
+        if (loadLibrary("opencv_java5"))
         {
             Log.d(TAG, "First attempt to load libs is OK");
             String eol = System.getProperty("line.separator");
@@ -74,30 +54,6 @@ class StaticHelper {
         return result;
     }
 
-    private static boolean initOpenCVLibs(String Libs)
-    {
-        Log.d(TAG, "Trying to init OpenCV libs");
-
-        boolean result = true;
-
-        if ((null != Libs) && (Libs.length() != 0))
-        {
-            Log.d(TAG, "Trying to load libs by dependency list");
-            StringTokenizer splitter = new StringTokenizer(Libs, ";");
-            while(splitter.hasMoreTokens())
-            {
-                result &= loadLibrary(splitter.nextToken());
-            }
-        }
-        else
-        {
-            // If dependencies list is not defined or empty.
-            result = loadLibrary("opencv_java4");
-        }
-
-        return result;
-    }
-
     private static final String TAG = "OpenCV/StaticHelper";
 
     private static native String getLibraryList();

modules/java/generator/android/java/org/opencv/engine/OpenCVEngineInterface.aidl

@@ -1,33 +0,0 @@
-package org.opencv.engine;
-
-/**
-* Class provides a Java interface for OpenCV Engine Service. It's synchronous with native OpenCVEngine class.
-*/
-interface OpenCVEngineInterface
-{
-    /**
-    * @return Returns service version.
-    */
-    int getEngineVersion();
-
-    /**
-    * Finds an installed OpenCV library.
-    * @param OpenCV version.
-    * @return Returns path to OpenCV native libs or an empty string if OpenCV can not be found.
-    */
-    String getLibPathByVersion(String version);
-
-    /**
-    * Tries to install defined version of OpenCV from Google Play Market.
-    * @param OpenCV version.
-    * @return Returns true if installation was successful or OpenCV package has been already installed.
-    */
-    boolean installVersion(String version);
-
-    /**
-    * Returns list of libraries in loading order, separated by semicolon.
-    * @param OpenCV version.
-    * @return Returns names of OpenCV libraries, separated by semicolon.
-    */
-    String getLibraryList(String version);
-}

modules/java/generator/gen_java.py

@@ -1433,7 +1433,8 @@ if __name__ == "__main__":
     java_base_path = os.path.join(dstdir, 'java'); mkdir_p(java_base_path)
     java_test_base_path = os.path.join(dstdir, 'test'); mkdir_p(java_test_base_path)
 
-    for (subdir, target_subdir) in [('src/java', 'java'), ('android/java', None), ('android-21/java', None)]:
+    for (subdir, target_subdir) in [('src/java', 'java'), ('android/java', None),
+                                    ('android-21/java', None), ('android-24/java', None)]:
         if target_subdir is None:
             target_subdir = subdir
         java_files_dir = os.path.join(SCRIPT_DIR, subdir)