android-ndk studio - Android 스튜디오, gradle 및 NDK




r5c 13 (20)

나는이 전체 gradle 및 Android Studio를 지원하는 데있어 매우 새로운 기술입니다. 내 안드로이드 프로젝트를 내보내기 옵션을 사용하여 gradle로 변환 할 수있었습니다.

하지만 NDK 빌드를 gradle 빌드 프로세스에 통합하는 방법에 대한 문서 나 시작점을 찾고 있습니다.

가능하다면 빌드 바이너리 (.so 파일)를 자산 디렉토리에 복사하는 "일종의"단계가 필요합니다.


Answers

유닉스에 있다면 최신 버전 (0.8)이 ndk-build를 추가합니다. 추가 방법은 다음과 같습니다.

android.ndk {
    moduleName "libraw"
}

JNI가 'src / main / jni'아래에있을 것으로 예상된다. 그렇지 않으면 다음과 같이 정의 할 수있다.

sourceSets.main {
    jni.srcDirs = 'path'
}

2008 년 1 월 28 일부터 버전 0.8까지 빌드가 Windows에서 깨 졌으므로 다음을 사용하여 빌드를 비활성화해야합니다.

sourceSets.main {
    jni.srcDirs = [] //disable automatic ndk-build call (currently broken for windows)
}

Android Studio가 1.0으로 업데이트됨에 따라 NDK 툴체인 지원이 크게 향상되었습니다 ( 참고 사항 :이 포스트의 하단에있는 내 업데이트를 읽어 새로운 실험용 Gradle 플러그인 및 Android Studio 1.5 사용법을 확인하십시오 ).

Android Studio와 NDK는 모듈의 build.gradle에서 ndk {} 블록을 만들고 (모듈) / src / main / jni 디렉토리에 소스 파일을 설정하면됩니다. 끝난!

명령 줄에서 ndk-build를 더 이상 사용하지 않습니다.

나는 여기에 내 블로그 게시물에 대한 모든 것을 작성했습니다 : http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/

두드러진 점은 다음과 같습니다.

여기에서 알아야 할 두 가지가 있습니다. 기본적으로 Android 애플리케이션에로드 할 외부 라이브러리가있는 경우 기본적으로 (module) / src / main / jniLibs에서 검색됩니다. 모듈의 build.gradle에서 sourceSets.main.jniLibs.srcDirs를 설정하여이를 변경할 수 있습니다. 타겟 아키텍처마다 라이브러리가있는 서브 디렉토리가 필요합니다 (예 : x86, arm, mips, arm64-v8a 등).

기본적으로 NDK 툴체인에 의해 컴파일되기를 원하는 코드는 (module) / src / main / jni에 있고 위에서와 비슷하게 모듈의 build.gradle에서 sourceSets.main.jni.srcDirs를 설정하여 변경할 수 있습니다

이것을 모듈의 build.gradle에 넣으십시오 :

ndk {
  moduleName "SeePlusPlus" // Name of C++ module (i.e. libSeePlusPlus)
  cFlags "-std=c++11 -fexceptions" // Add provisions to allow C++11 functionality
  stl "gnustl_shared" // Which STL library to use: gnustl or stlport
}

이것이 C ++ 코드를 컴파일하는 과정입니다. 거기에서로드하고 래퍼를 만들어야합니다.하지만 질문을 보면 이미 모든 것을 수행하는 방법을 알고 있으므로 다시 해시하지 않을 것입니다.

또한이 예제의 Github 저장소를 다음과 같이 배치했습니다. http://github.com/sureshjoshi/android-ndk-swig-example

업데이트 : 2015 년 6 월 14 일

Android Studio 1.3이 출시되면 JetBrains CLion 플러그인을 통해 C ++에 대한 지원이 향상됩니다. 저는 현재 이것이 Android Studio 내에서 Java 및 C ++ 개발을 허용 할 것이라는 가정하에 있습니다. 그러나 나는 위에서 언급 한대로 Gradle NDK 섹션을 사용해야 할 것입니다. 또한 CLion이 이러한 작업을 자동으로 수행하지 않는 한 Java <-> C ++ 래퍼 파일을 작성해야 할 필요가 있다고 생각합니다.

업데이트 : 2016 년 1 월 5 일

개발 브랜치에서 내 블로그와 Github 저장소를 업데이트하여 최신 Studio Gradle 플러그인 (0.6.0-alpha3)으로 Android Studio 1.5를 사용했습니다.

http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/ http://github.com/sureshjoshi/android-ndk-swig-example

이제 NDK 섹션의 Gradle 빌드는 다음과 같습니다.

android.ndk {
    moduleName = "SeePlusPlus" // Name of C++ module (i.e. libSeePlusPlus)
    cppFlags.add("-std=c++11") // Add provisions to allow C++11 functionality
    cppFlags.add("-fexceptions")
    stl = "gnustl_shared" // Which STL library to use: gnustl or stlport
}

또한 매우 놀랍게도 Android Studio는 C ++ 용 자동 완성 기능을 제공합니다. 'native'키워드를 사용하는 Java 생성 래퍼 :

그러나 완전히 장미 빛이 아닙니다 ... SWIG를 사용하여 라이브러리를 자동 생성 코드로 생성 한 다음 기본 키워드 자동 생성을 사용하려고하면 코드가 Swig _wrap의 잘못된 위치에 삽입됩니다 .cxx 파일 ... 그래서 그것을 "extern C"블록으로 옮겨야합니다 :

업데이트 : 2017 년 10 월 15 일

안드로이드 스튜디오 2.2 이후에는 Gradle과 CMake를 통해 NDK 툴체인을 기본적으로 '원초적으로'지원한다고 언급하지 않았다면 나는 좌절 할 것입니다. 이제 새로운 프로젝트를 만들 때 C ++ 지원을 선택하면됩니다.

자신 만의 JNI 레이어 코드를 생성하거나 위에서 언급 한 SWIG 기술을 사용해야하지만 Android 프로젝트에서 C ++의 스캐 폴딩은 간단합니다.

CMakeLists 파일 (C ++ 소스 파일을 저장하는 곳)의 변경 사항은 Android Studio에서 선택되며 관련 라이브러리가 자동으로 다시 컴파일됩니다.


Google IO 2015에서 Google은 Android Studio 1.3에 완전한 NDK 통합을 발표했습니다.

미리보기가 없으며 모든 사용자가 사용할 수 있습니다. https://developer.android.com/studio/projects/add-native-code.html

이전 답변 : 프로젝트 소스에 jni 디렉토리가 있으면 Gradle이 자동으로 ndk-build 호출합니다.

이것은 Android 스튜디오 0.5.9 (카나리아 빌드)에서 작동합니다.

  1. NDK 다운로드
  2. 환경 변수에 ANDROID_NDK_HOME 을 추가하거나 Android Studio 프로젝트의 local.propertiesndk.dir=/path/to/ndk 를 추가하십시오. 이것은 Android Studio가 ndk를 자동으로 실행할 수있게합니다.
  3. 최신 gradle 샘플 프로젝트 를 다운로드하여 ndk 프로젝트 의 예를 확인하십시오. (그들은 페이지의 하단에 있습니다). 좋은 샘플 프로젝트는 ndkJniLib 입니다.
  4. gradle.build 를 NDK 샘플 프로젝트에서 복사하십시오. 이런 식으로 보일거야. 이 gradle.build 는 각 아키텍처마다 다른 apk를 만듭니다. build variants 창을 사용하여 원하는 아키텍처를 선택해야합니다.

    apply plugin: 'android'
    
    dependencies {
        compile project(':lib')
    }
    
    android {
        compileSdkVersion 19
        buildToolsVersion "19.0.2"
    
        // This actual the app version code. Giving ourselves 100,000 values [0, 99999]
        defaultConfig.versionCode = 123
    
        flavorDimensions "api", "abi"
    
        productFlavors {
            gingerbread {
                flavorDimension "api"
                minSdkVersion 10
                versionCode = 1
            }
            icecreamSandwich {
                flavorDimension "api"
                minSdkVersion 14
                versionCode = 2
            }
            x86 {
                flavorDimension "abi"
                ndk {
                    abiFilter "x86"
                }
                // this is the flavor part of the version code.
                // It must be higher than the arm one for devices supporting
                // both, as x86 is preferred.
                versionCode = 3
            }
            arm {
                flavorDimension "abi"
                ndk {
                    abiFilter "armeabi-v7a"
                }
                versionCode = 2
            }
            mips {
                flavorDimension "abi"
                ndk {
                    abiFilter "mips"
                }
                versionCode = 1
            }
            fat {
                flavorDimension "abi"
                // fat binary, lowest version code to be
                // the last option
                versionCode = 0
            }
        }
    
        // make per-variant version code
        applicationVariants.all { variant ->
            // get the version code of each flavor
            def apiVersion = variant.productFlavors.get(0).versionCode
            def abiVersion = variant.productFlavors.get(1).versionCode
    
            // set the composite code
            variant.mergedFlavor.versionCode = apiVersion * 1000000 + abiVersion * 100000 + defaultConfig.versionCode
        }
    
    }
    

이렇게하면 Android.mk 및 Application.mk 파일이 무시됩니다. 이 문제를 해결하기 위해 gradle이 atuomatic ndk-build 호출을 사용하지 않도록 설정 한 다음 ndk 소스의 디렉토리를 수동으로 지정할 수 있습니다.

sourceSets.main {
    jniLibs.srcDir 'src/main/libs' // use the jni .so compiled from the manual ndk-build command
    jni.srcDirs = [] //disable automatic ndk-build call
}

또한, 자동 호출을 비활성화 했으므로 gradled build 스크립트에서 ndk-build를 명시 적으로 호출 할 수 있습니다.

task ndkBuild(type: Exec) {
   commandLine 'ndk-build', '-C', file('src/main/jni').absolutePath
}

tasks.withType(JavaCompile) {
    compileTask -> compileTask.dependsOn ndkBuild
}

쉽게 컴파일 된 .so 의 패키징을 자동화하는 좋은 대답은 다른 (닫힌) 스레드에서 제공 됩니다. 그 일을하기 위해서 나는 그 라인을 바꾸어야했다 :

from fileTree(dir: 'libs', include: '**/*.so')

으로:

from fileTree(dir: 'src/main/libs', include: '**/*.so') 

이 변경이 없으면 .so 파일을 찾을 수 없으므로 패키징 작업이 실행되지 않습니다.


현재 (Android Studio v0.8.6) 아주 간단합니다. 다음은 "Hello world"유형 앱을 만드는 단계입니다.

  1. Android NDK를 다운로드하고 루트 폴더를 SDK 폴더와 같은 위치에 정돈하십시오.

  2. 다음을 local.properties 파일에 추가하십시오. ndk.dir=<path-to-ndk>

  3. versionName 행 다음에 defaultConfig 클로저의 build.gradle 파일에 다음을 추가하십시오. ndk { moduleName="hello-world" }

  4. 앱 모듈의 main 디렉토리에 jni 라는 새 폴더를 만듭니다.

  5. 이 폴더에서 hello-world.c 라는 파일을 만듭니다. 아래에서 볼 수 있습니다.

  6. hello-world.c 에서 메소드를 호출하는 방법에 대한 예는 아래의 예제 코드를 참조하십시오 (또는 함수입니까?).

hello-world.c

#include <string.h>
#include <jni.h>

jstring
Java_me_mattlogan_ndktest_MainActivity_stringFromJNI(JNIEnv* env, jobject thiz)
{
    return (*env)->NewStringUTF(env, "Hello world!");
}

MainActivity.java

public class MainActivity extends Activity {

    static {
        System.loadLibrary("hello-world");
    }

    public native String stringFromJNI();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        String testString = stringFromJNI();

        TextView mainText = (TextView) findViewById(R.id.main_text);
        mainText.setText(testString);
    }
}

build.gradle

apply plugin: 'com.android.application'

android {
    compileSdkVersion 20
    buildToolsVersion "20.0.0"

    defaultConfig {
        applicationId "me.mattlogan.ndktest"
        minSdkVersion 15
        targetSdkVersion 20
        versionCode 1
        versionName "1.0"

        ndk {
            moduleName "hello-world"
        }
    }
    buildTypes {
        release {
            runProguard false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

비슷한 앱의 전체 소스 코드를 여기서 찾으십시오 (NDK 제외).


"gradle 1.11 com.android.tools.build : gradle : 9..+"가 pre-build ndk를 지원합니다. src / main / jniLibs 디렉토리에 * .so를 넣을 수 있습니다. gradle을 구축하면 ndk가 올바른 위치에 패키징됩니다.

여기 내 프로젝트입니다.

Project:
|--src
|--|--main
|--|--|--java
|--|--|--jniLibs
|--|--|--|--armeabi
|--|--|--|--|--.so files
|--libs
|--|--other.jar

@plaisthos의 대답은 최신 gradle 버전에서 깨졌지만 여전히 할 수있는 방법이 있습니다. 프로젝트 디렉토리의 루트에 native-libs 디렉토리를 만들고 모든 lib 디렉토리를이 디렉토리에 복사하십시오.

build.gradle에 다음 행을 추가하십시오. 빌드하고 행복하게.

task copyNativeLibs(type: Copy) {
    from(new File(project(':<your project>').getProjectDir(), 'native-libs')) { include '**/*.so' }
    into new File(buildDir, 'native-libs')
}

tasks.withType(Compile) { compileTask -> compileTask.dependsOn copyNativeLibs }

clean.dependsOn 'cleanCopyNativeLibs'

그렇게 성공할 수 있어요!

1.이 경로에 .so 파일을 추가하십시오.

Project:

| --src | - | - | - | - | - | - | - | - | - | --jniLibs | - | - | - | --armeabi | - | - | - | - | -. so 파일

2.이 코드를 gradle.build에 추가하십시오.

android {
splits {
    abi {
        enable true
        reset()
        include 'x86', 'x86_64', 'arm64-v8a', 'armeabi-v7a', 'armeabi'
        universalApk false
    }
}

}

3. System.loadLibrary("yousoname");

  1. 당신에게 좋은 일이라면, 그것은 gradle 1.2.3에서 괜찮습니다.

다음은 Android Studio 프로젝트에서 NDK를 작동시키는 데 사용한 단계입니다. 이 튜토리얼을 사용하여 https://software.intel.com/en-us/videos/using-the-ndk-with-android-studio 를 도와주었습니다.

NDK를 사용하려면 local.properties에 NDK 라인을 추가해야합니다. 그래서 sdk.dir 아래에

ndk.dir=C\:\\MyPathToMyNDK\ndk

내 애플 리케이션 build.gradle에서 나는 다음 코드를 가지고있다.

        ndk {
            moduleName "myLib"
            ldLibs "log"
            stl "gnustl_shared"
            cFlags "-std=c++11 -frtti -fexceptions -pthread"
        }

moduleName은 네이티브 코드에 부여 할 이름입니다. 나는 이것이 공유 라이브러리가 호출 될 것이라고 생각한다. ldLibs를 사용하면 LogCat에 로그 할 수 있습니다. stl은 가져 오려는 stl입니다. 이클립스 NDK와 같은 옵션이 많이 있습니다. ( http://www.kandroid.org/ndk/docs/CPLUSPLUS-SUPPORT.html )

cFlags는 여전히 나를 위해 일정량의 흑 마술입니다. 나는 모든 옵션과 그들이 나에게 줄 수있는 좋은 원천을 찾지 못했다. 주위에서 필요한 모든 것을 검색하십시오. 즉, 내가 찾은 곳입니다. C ++ 11이 새로운 C ++ 11 표준을 사용할 수 있다는 것을 알고 있습니다.

다음은 네이티브 코드에서 LogCat에 로그하는 방법의 예입니다

__android_log_print(ANDROID_LOG_DEBUG, "TestApp", "Adding - String %d has a field name of %s and a value of %s", i, lKeyUTF8.c_str(), lValueUTF8.c_str());

ndk.dir=/usr/shareData/android-ndk-r11b // ndk.dir=/usr/shareData/android-ndk-r11b 경로를 사용했습니다.

android studio 프로젝트의 local.properties 파일에 있습니다. 이 행을 추가하십시오.
android.useDeprecatedNdk=true

android studio 프로젝트의 gradle.properties 파일에 있습니다.

자세한 내용은 http://tools.android.com/tech-docs/android-ndk-preview 참조하십시오.



이클립스에서 안드로이드 스튜디오 에서 프로젝트 구성 : 당신은 gradle에 수출하지 않고 안드로이드 스튜디오로 이클립스 ndk 프로젝트를 가져와야하고 작동합니다, 또한 local.properties 에 ndk의 경로를 추가해야합니다. 오류가 표시되면 추가하십시오.

sourceSets.main {
        jniLibs.srcDir 'src/main/libs' 
        jni.srcDirs = [] //disable automatic ndk-build callenter code here
    }

build.gradle 파일에서 터미널을 사용하여 jni 폴더와 파일을 생성하고 작동시킨다.


이 줄을 app build.gradle 추가하면됩니다.

dependencies {
    ...
    compile fileTree(dir: "$buildDir/native-libs", include: 'native-libs.jar')
}

task nativeLibsToJar(type: Zip, description: 'create a jar archive of the native libs') {
    destinationDir file("$buildDir/native-libs")
    baseName 'native-libs'
    extension 'jar'
    from fileTree(dir: 'libs', include: '**/*.so')
    into 'lib/armeabi/'
}

tasks.withType(JavaCompile) {
    compileTask -> compileTask.dependsOn(nativeLibsToJar)
}

NDK 빌드 및 그라데이션 (기본)

일반적으로 NDK로 빌드하는 것은 Android.mk에 대한 ndkBuild 경로 또는 CMakeLists.txt에 대한 cmake 경로를 올바르게 지정하는 것만 큼 간단합니다. Android Studio의 C / C ++ 지원은 CLion을 기반으로하고 CMake를 프로젝트 형식으로 사용하기 때문에 이전 Android.mk보다 CMake를 권장합니다. 이 경험으로 인해 IDE는 더 큰 프로젝트에서보다 반응이 좋았습니다. 프로젝트에서 컴파일 된 모든 내용이 자동으로 빌드되어 APK로 복사됩니다.

apply plugin: 'com.android.library'

android {
    compileSdkVersion 19
    buildToolsVersion "25.0.2"

    defaultConfig {
        minSdkVersion 19
        targetSdkVersion 19

        ndk {
            abiFilters 'armeabi', 'armeabi-v7a', 'x86'
            // 64-bit support requires an Android API level higher than 19; Namely 21 and higher
            //abiFilters 'armeabi', 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
        }

        externalNativeBuild {
            cmake {
                arguments '-DANDROID_TOOLCHAIN=clang',
                        '-DANDROID_PLATFORM=android-19',
                        '-DANDROID_STL=gnustl_static',
                        '-DANDROID_ARM_NEON=TRUE'

            }
        }
    }

    externalNativeBuild {
        cmake {
            path 'src/main/jni/CMakeLists.txt'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

사전 빌드 된 라이브러리를 프로젝트에 추가하기 (고급)

NDK 빌드의 정적 라이브러리 (.a)는 자동으로 포함되지만 사전 빌드 된 동적 라이브러리 (.so)는 jniLibs 배치해야합니다. 이것은 sourceSets 사용하여 구성 할 수 있지만 표준을 채택해야합니다. 미리 빌드 된 라이브러리를 포함 할 때 build.gradle 에서 추가 명령이 필요하지 않습니다.

jniLibs 의 레이아웃

Android Gradle Plugin 사용자 가이드 에서 구조에 대한 자세한 정보를 확인할 수 있습니다.

|--app:
|--|--build.gradle
|--|--src:
|--|--|--main
|--|--|--|--java
|--|--|--|--jni
|--|--|--|--|--CMakeLists.txt
|--|--|--|--jniLibs
|--|--|--|--|--armeabi
|--|--|--|--|--|--.so Files
|--|--|--|--|--armeabi-v7a
|--|--|--|--|--|--.so Files
|--|--|--|--|--x86
|--|--|--|--|--|--.so Files

그런 다음 결과 APK가 unzip -l myApp.apk 를 사용하여 내용을 나열하는 .so 파일 (일반적으로 build/outputs/apk/ 아래)을 포함 unzip -l myApp.apk 수 있습니다.

공유 라이브러리 구축

NDK에 공유 라이브러리를 구축하는 경우 더 이상 아무것도 할 필요가 없습니다. APK에 올바르게 번들됩니다.


낙소스가 말한 것을 (정확한 방향으로 나를 보내 주신 낙소스에게 감사드립니다!) 확장하기 위해, 나는 최근에 발표 된 NDK 예제에서 꽤 많은 것을 배웠고 비슷한 질문에 답을 올렸습니다.

Android Gradle 플러그인 0.7을 사용하여 NDK를 구성하는 방법

이 포스트는 build.gradle 스크립트에 직접 NDK 지원을 추가하는 방법에 대한 정보뿐만 아니라 다양한 아키텍처를 위해 사전 빌드 된 네이티브 라이브러리를 앱에 연결하는 방법에 대해 자세히 설명합니다. 대부분의 경우 zip 및 복사에 대한 작업을 더 이상 수행하지 않아야합니다.


나는 native dropbox 라이브러리를 컴파일하기 위해 다음 코드를 사용했다. 나는 Android Studio v1.1을 사용하고있다.

task nativeLibsToJar(type: Zip) {
    destinationDir file("$buildDir/native-libs")
    baseName 'native-libs'
    extension 'jar'
    from fileTree(dir: 'src/main/libs', include: '**/*.so')
    into 'lib/'
}

tasks.withType(JavaCompile) {
    compileTask -> compileTask.dependsOn(nativeLibsToJar)
}

이제 Android Studio가 안정 채널에 포함 되었으므로 android-ndk 샘플을 실행하는 것은 매우 간단합니다. 이 샘플은 ndk 실험용 플러그인을 사용하며 Android NDK 온라인 설명서에서 링크 된 것보다 최신 버전입니다. 일단 그들이 작동한다는 것을 알게되면 build.gradle, local.properties 및 gradle-wrapper.properties 파일을 연구하고 이에 따라 프로젝트를 수정할 수 있습니다. 다음은 이들을 작동시키는 단계입니다.

  1. 설정, 모양 및 동작, 시스템 설정, Android SDK로 이동하여 SDK 도구 탭을 선택하고 목록 맨 아래에서 Android NDK 버전 1.0.0을 선택합니다. 그러면 NDK가 다운로드됩니다.

  2. 새로 다운로드 한 NDK의 위치를 ​​가리 킵니다. 이 파일은 sdk / ndk-bundle 디렉토리에 있습니다. 파일, 프로젝트 구조, SDK 위치 (왼쪽)를 선택하고 Android NDK 위치 아래에 경로를 제공하여이를 수행하십시오. 이렇게하면 다음과 비슷한 local.properties에 ndk 항목이 추가됩니다.

    Mac / Linux : ndk.dir = / Android / sdk / ndk-bundle
    Windows : ndk.dir = C : \ Android \ sdk \ ndk-bundle

필자는 gles3gni, 네이티브 코덱 및 빌더를 제외하고 저장소에서 모든 프로젝트를 성공적으로 빌드하고 배포했습니다. 나는 다음을 사용하고있다 :

Android Studio 1.3 빌드 AI-141.2117773
2015 년 7 월 28 일 게시 된 android-ndk 샘플 (위 링크)
SDK 도구 24.3.3
C : \ Android \ sdk \ ndk-bundle에 압축 해제 된 NDK r10e
Gradle 2.5
Gradle 플러그인 0.2.0
Windows 8.1 64 비트


SJoshi (oracle guy)가 가장 완벽한 답변을 가지고 있다고 생각하지만, SWIG 프로젝트는 특별한 경우이고 흥미롭고 유용하지만 표준 SDK ant 기반 프로젝트를 잘 수행 한 프로젝트의 대부분을 일반화하지는 않았습니다 + NDK. 우리 모두는 현재 안드로이드 스튜디오를 가장 많이 사용하고 싶습니다. 또는 이론적으로는 제공 할 수있는 더 CI 친화적 인 모바일 용 툴체인을 만들고 싶습니다.

나는 어딘가에서 빌린 나의 접근 방식을 게시했다. (나는 이것을 찾아 냈지만, 앱 build.gradle에 대한 요지를 게시했다 : https://gist.github.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841 ). 요약하면 다음과 같이하는 것이 좋습니다.

  • 프로젝트를 최신 gradle 빌드로 업그레이드하지 마십시오.
  • 프로젝트 루트에서 com.android.tools.build:gradle:1.5.0을 사용하십시오.
  • 앱 프로젝트에서 com.android.application 사용
  • gradle.properties가 있는지 확인하십시오 : android.useDeprecatedNdk = true (불평하는 경우)
  • 위의 방법을 사용하여 Android.mk 파일을 만드는 데 드는 시간과 노력을 버리지 않아야합니다. 빌드 할 아치 대상을 제어합니다. 그리고이 지침은 이론적으로 특별한 문제없이 Windows에서 빌드 할 수 있어야하는 Windows 사용자에게 친절합니다.

안드로이드에 대한 Gradle은 필자가 생각하기에 난장판이었습니다. 필자는 Maven 컨셉을 빌렸고, 프로젝트에 대한 디렉토리의 독창적 인 구조를 좋아했습니다. 이 NDK 기능은 거의 3 년 이상 "곧"출시 될 예정입니다.


이것은 내가 gradle에서 android-ndk를 사용하여 빌드하는 데 사용하는 코드입니다. 이를 위해 gradle.properties에 ndk 디렉토리 경로를 추가합니다. ndkdir=/home/user/android-ndk-r9d 를 추가하고 아래에 게시 된 코드에서 볼 수 있듯이 모든 jni 파일을 src/main/ 에있는 폴더에 넣으십시오. System.loadLibrary("libraryname"); 처럼 일반적으로 사용할 수있는 기본 라이브러리가있는 jar 파일을 만듭니다 System.loadLibrary("libraryname");

dependencies {
    compile fileTree(dir: "$buildDir/native-libs", include: '*.jar')
}

task ndkBuild(type: Exec) {
    commandLine "$ndkdir/ndk-build", "--directory", "$projectDir/src/main/native", '-j', Runtime.runtime.availableProcessors(),
            "APP_PLATFORM=android-8",
            "APP_BUILD_SCRIPT=$projectDir/src/main/native/Android.mk",
            "NDK_OUT=$buildDir/native/obj",
            "NDK_APP_DST_DIR=$buildDir/native/libs/\$(TARGET_ARCH_ABI)"
}

task nativeLibsToJar(type: Jar, description: 'create a jar with native libs') {
    destinationDir file("$buildDir/native-libs")
    baseName 'native-libs'
    from fileTree(dir: "$buildDir/native/libs", include: '**/*.so')
    into 'lib/'
}

tasks.withType(JavaCompile) {
    compileTask -> compileTask.dependsOn nativeLibsToJar
}

nativeLibsToJar.dependsOn 'ndkBuild'

이것은 Google의 내부 농담 인 것 같습니다. 또한 Chrome 작업 관리자에서도 사용됩니다. 일부 엔지니어가 재미있어한다는 것을 제외하고는 아무런 목적이 없습니다. 네가 원하면 그 목적은 그 자체이다.

  1. Chrome에서 Shift + Esc로 작업 관리자를 엽니 다.
  2. 마우스 오른쪽 버튼을 클릭하여 Goats Teleported 열을 추가합니다.
  3. 경이.

너무 많은 텔레포트 된 염소 에 대한 거대한 Chromium 버그 보고서가 있습니다 .

다음 Chromium 소스 코드 스 니펫HN 의견에서 도난 당합니다.

int TaskManagerModel::GetGoatsTeleported(int index) const {
  int seed = goat_salt_ * (index + 1);
  return (seed >> 16) & 255;
}




android android-ndk gradle android-studio