AndroidStudio中通过CMake使用NDK并编译自定义库和添加预编译库

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.4.1)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

add_library( # Sets the name of the library.
    native-lib

    # Sets the library as a shared library.
    SHARED

    # Provides a relative path to your source file(s).
    src/main/cpp/native-lib.cpp )

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
    log-lib

    # Specifies the name of the NDK library that
    # you want CMake to locate.
    log )

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
      native-lib

      # Links the target library to the log library
      # included in the NDK.
      ${log-lib} )

include_directories([AFTER|BEFORE] [SYSTEM] dir1 [dir2 ...])

#include "add.h"
int add(int a,int b) {
 return a + b;
}
add.h
#ifndef OPENCVTEST_ADD_H
#define OPENCVTEST_ADD_H
int add(int a,int b);
#endif //OPENCVTEST_ADD_H

cmake_minimum_required(VERSION 3.4.1)
add_library(add SHARED
   src/main/cpp/add.cpp)
set(distribution_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../distribution)
set_target_properties(add PROPERTIES
      LIBRARY_OUTPUT_DIRECTORY
      ${distribution_DIR}/libs/${ANDROID_ABI})
target_include_directories(add
       PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp)
       
add_custom_command(TARGET add POST_BUILD
     COMMAND "${CMAKE_COMMAND}" -E
     copy "${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/add.h"
     "${distribution_DIR}/include/mathlib/add.h"
#     **** the following 2 lines are for potential future debug purpose ****
#     COMMAND "${CMAKE_COMMAND}" -E
#     remove_directory "${CMAKE_CURRENT_BINARY_DIR}"
     COMMENT "Copying gmath to output directory")

externalNativeBuild {
   cmake {
    arguments '-DANDROID_PLATFORM=android-19',
      '-DANDROID_TOOLCHAIN=clang', '-DANDROID_STL=gnustl_static'
    targets 'add'
   }
  }

externalNativeBuild {
  cmake {
   path 'CMakeLists.txt'
  }
 }

#include 
#include 
#include "mathlib/add.h"

extern "C"
JNIEXPORT jstring

JNICALL
Java_com_example_bill_opencvtest_MainActivity_stringFromJNI(
  JNIEnv *env,
  jobject /* this */) {
 std::string hello = "Hello from C++ From Android openCVTest";
 return env->NewStringUTF(hello.c_str());
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_example_bill_opencvtest_MainActivity_addFromCpp(JNIEnv *env, jobject instance, jint a,
               jint b) {

 // TODO
 return add(a,b);
}

set(distribution_DIR ${CMAKE_SOURCE_DIR}/../distribution)
include_directories(${distribution_DIR}/include)
add_library(lib_add SHARED IMPORTED)
set_target_properties(lib_add PROPERTIES IMPORTED_LOCATION
      ${distribution_DIR}/libs/${ANDROID_ABI}/libadd.so)
add_library( # Sets the name of the library.
    native-math

    # Sets the library as a shared library.
    SHARED

    # Provides a relative path to your source file(s).
    src/main/cpp/native-math.cpp )

find_library( # Sets the name of the path variable.
    log-lib

    # Specifies the name of the NDK library that
    # you want CMake to locate.
    log )
set_target_properties(native-math PROPERTIES
      LIBRARY_OUTPUT_DIRECTORY
      ${distribution_DIR}/libs/${ANDROID_ABI})
target_link_libraries( # Specifies the target library.
      native-math
      android
      log
      lib_add
      # Links the target library to the log library
      # included in the NDK.
      ${log-lib} )

externalNativeBuild {
   cmake {
    arguments '-DANDROID_PLATFORM=android-19',
      '-DANDROID_TOOLCHAIN=clang', '-DANDROID_STL=gnustl_static'
   }
  }
  ndk {
   //abiFilters 'armeabi-v7a','x86_64'
  }

static {
  System.loadLibrary("native-math");
 }
 /**
  * A native method that is implemented by the 'native-lib' native library,
  * which is packaged with this application.
  */
 public native String stringFromJNI();

 public native int addFromCpp(int a, int b);

super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  // Example of a call to a native method
  TextView tv = (TextView) findViewById(R.id.sample_text);
  tv.setText(stringFromJNI() + "____" + addFromCpp(2,88));

set(libs "${CMAKE_SOURCE_DIR}/src/main/jniLibs")
include_directories(${distribution_DIR}/include)
# set add lib
add_library(libopencv_java3 SHARED IMPORTED )
set_target_properties(libopencv_java3 PROPERTIES
 IMPORTED_LOCATION "${libs}/${ANDROID_ABI}/libopencv_java3.so")
add_library( # Sets the name of the library.
    native-opencv

    # Sets the library as a shared library.
    SHARED

    # Provides a relative path to your source file(s).
    src/main/cpp/native-opencv.cpp )
set_target_properties(native-opencv PROPERTIES
      LIBRARY_OUTPUT_DIRECTORY
      ${distribution_DIR}/libs/${ANDROID_ABI})
target_link_libraries( # Specifies the target library.
      native-opencv
      android
      log
      libopencv_java3
      # Links the target library to the log library
      # included in the NDK.
      ${log-lib} )

//
// Created by bill on 2018/1/13.
//
#include 
#include 
#include 

using namespace cv;
using namespace std;

extern "C"
JNIEXPORT void JNICALL
Java_com_example_bill_opencvtest_MainActivity_nativeProcessFrame(JNIEnv *env, jobject instance,
  jlong addrGray, jlong addrRGBA) {
// TODO
 Mat& gray = *(Mat *) addrGray;
 Mat& rgba = *(Mat *) addrRGBA;
 vector v;

 Ptr orb = ORB::create();
 orb->detect(gray, v, cv::Mat());

 for (int i = 0; i < v.size(); ++i) {
  const KeyPoint& kp = v[i];
  circle(rgba, Point(kp.pt.x, kp.pt.y), 10, Scalar(255,0,0,255));
 }
}

static {
  System.loadLibrary("native-opencv");
  System.loadLibrary("native-math");
 }
 /**
  * A native method that is implemented by the 'native-lib' native library,
  * which is packaged with this application.
  */
 public native String stringFromJNI();

 public native int addFromCpp(int a, int b);
 private native void nativeProcessFrame(long addrGray, long addrRGBA);

package com.example.bill.opencvtest;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.WindowManager;
import android.widget.TextView;

import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.CvType;
import org.opencv.core.Mat;

public class MainActivity extends Activity implements CameraBridgeViewBase.CvCameraViewListener2{
 static {
  System.loadLibrary("native-opencv");
  System.loadLibrary("native-math");
 }
 /**
  * A native method that is implemented by the 'native-lib' native library,
  * which is packaged with this application.
  */
 public native String stringFromJNI();

 public native int addFromCpp(int a, int b);
 private native void nativeProcessFrame(long addrGray, long addrRGBA);

 private static final String TAG = "MainActivity";

 private Mat rgba;
 private Mat gray;
 private CameraBridgeViewBase mOpenCvCameraView;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  // Example of a call to a native method
  TextView tv = (TextView) findViewById(R.id.sample_text);
  tv.setText(stringFromJNI() + "____" + addFromCpp(2,88));
  getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

  mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.activity_camera_view);
  mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
  mOpenCvCameraView.setCvCameraViewListener(this);
 }

 @Override
 public void onPause() {
  super.onPause();
  if (mOpenCvCameraView != null){
   mOpenCvCameraView.disableView();
  }
 }

 @Override
 public void onResume()
 {
  super.onResume();
  if (!OpenCVLoader.initDebug()) {
   Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
  } else {
   Log.d(TAG, "OpenCV library found inside package. Using it!");
   mOpenCvCameraView.enableView();
  }
 }

 public void onDestroy() {
  super.onDestroy();
  if (mOpenCvCameraView != null){
   mOpenCvCameraView.disableView();
  }
 }

 public void onCameraViewStarted(int width, int height){
  rgba = new Mat(height, width, CvType.CV_8UC4);
  gray = new Mat(height, width, CvType.CV_8UC1);
 }

 public void onCameraViewStopped() {
  rgba.release();
  gray.release();
 }

 public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame){
  rgba = inputFrame.rgba();
  gray = inputFrame.gray();
  nativeProcessFrame(gray.getNativeObjAddr(), rgba.getNativeObjAddr());
  return rgba;
 }
}

<?xml version="1.0" encoding="utf-8"?>


 
 

<?xml version="1.0" encoding="utf-8"?>