Sou muito novo em todo esse suporte e no Android Studio. Consegui converter meu projeto Android para gradle usando a opção de exportação.

Mas estou procurando alguma documentação ou ponto de partida para integrar a compilação NDK ao processo de compilação gradle.

Se possível, também preciso de algum tipo de estágio "depois" que copie os binários de construção (arquivos .so) no diretório de ativos.

Lançamos uma primeira versão da integração como uma prévia no 1.3: http://tools.android.com/tech-docs/android-ndk-preview

A integração permanecerá uma visualização mesmo depois que a 1.3 se tornar final. Nenhum ETA atual sobre quando será final (a partir de 10/07/2015).

Mais informações aqui: http://tools.android.com/tech-docs/android-ndk-preview

ATUALIZAÇÃO: O Android Studio com suporte a NDK já está disponível: http://tools.android.com/tech-docs/android-ndk-preview

Para criar com um script, a solução gradle abaixo deve funcionar:

Estou usando meu script de construção e adicionado ao meu arquivo (parece funcionar 0.8+): isso parece ser equivalente à solução abaixo (mas parece melhor no arquivo gradle):

 android {
    sourceSets {
        main {
            jniLibs.srcDirs = ['native-libs']
            jni.srcDirs = [] //disable automatic ndk-build
        }
    }
 }

Infelizmente, a compilação não falha se o diretório não estiver presente ou não contiver .soarquivos.

Com a atualização do Android Studio para 1.0, o suporte à cadeia de ferramentas NDK melhorou imensamente ( nota: leia minhas atualizações na parte inferior desta postagem para ver o uso com o novo plugin experimental Gradle e o Android Studio 1.5 ).

O Android Studio e o NDK estão integrados o suficiente para que você apenas precise criar um bloco ndk {} no build.gradle do seu módulo e defina seus arquivos de origem no diretório (module) / src / main / jni - e você feito!

Chega de ndk-build a partir da linha de comando.

Eu escrevi tudo sobre isso no meu blog aqui: http://www.sureshjoshi.com/mobile/android-ndk-in-android-studio-with-swig/

Os pontos salientes são:

Há duas coisas que você precisa saber aqui. Por padrão, se você possui bibliotecas externas que deseja carregar no aplicativo Android, elas são procuradas no (módulo) / src / main / jniLibs por padrão. Você pode alterar isso usando a configuração sourceSets.main.jniLibs.srcDirs no build.gradle do seu módulo. Você precisará de um subdiretório com bibliotecas para cada arquitetura segmentada (por exemplo, x86, arm, mips, arm64-v8a, etc ...)

O código que você deseja compilar por padrão pela cadeia de ferramentas NDK estará localizado em (módulo) / src / main / jni e, da mesma forma que acima, você pode alterá-lo definindo sourceSets.main.jni.srcDirs no build.gradle do seu módulo

e coloque isso no build.gradle do seu módulo:

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
}

Esse é o processo de compilação do código C ++, a partir daí você precisa carregá-lo e criar wrappers - mas, a julgar pela sua pergunta, você já sabe como fazer tudo isso, para que eu não volte a usar o hash.

Além disso, coloquei um repositório Github deste exemplo aqui: http://github.com/sureshjoshi/android-ndk-swig-example

ATUALIZAÇÃO: 14 de junho de 2015

Quando o Android Studio 1.3 for lançado, deve haver um suporte melhor ao C ++ por meio do plug-in JetBrains CLion. Atualmente, estou no pressuposto de que isso permitirá o desenvolvimento de Java e C ++ no Android Studio; no entanto, acho que ainda precisamos usar a seção Gradle NDK, como afirmei acima. Além disso, acho que ainda haverá a necessidade de gravar arquivos wrapper Java <-> C ++, a menos que o CLion os faça automaticamente.

ATUALIZAÇÃO: 5 de janeiro de 2016

Atualizei meu blog e o repositório do Github (no ramo de desenvolvimento) para usar o Android Studio 1.5 com o mais recente plugin experimental Gradle (0.6.0-alpha3).

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

A compilação Gradle para a seção NDK agora se parece com isso:

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
}

Além disso, surpreendentemente, o Android Studio possui preenchimento automático para C ++ - wrappers gerados em Java usando a palavra-chave 'native':

No entanto, não é totalmente otimista ... Se você estiver usando o SWIG para quebrar uma biblioteca para gerar automaticamente o código e, em seguida, tentar usar a geração automática de palavras-chave nativas, ele colocará o código no lugar errado no seu swig _wrap .cxx ... Então você precisa movê-lo para o bloco "extern C":

ATUALIZAÇÃO: 15 de outubro de 2017

Seria negligente se não mencionasse que o Android Studio 2.2 em diante tem essencialmente suporte 'nativo' (sem trocadilhos) para a cadeia de ferramentas NDK via Gradle e CMake. Agora, quando você cria um novo projeto, basta selecionar o suporte ao C ++ e pronto.

Você ainda precisará gerar seu próprio código de camada JNI ou usar a técnica SWIG que mencionei acima, mas o andaime de um projeto C ++ no Android é trivial agora.

As alterações no arquivo CMakeLists (onde você coloca seus arquivos de origem C ++) serão capturadas pelo Android Studio e recompilarão automaticamente todas as bibliotecas associadas.

No Google IO 2015, o Google anunciou a integração completa do NDK no Android Studio 1.3.

Agora está fora de visualização e disponível para todos: https://developer.android.com/studio/projects/add-native-code.html

Resposta antiga: o Gradle liga automaticamente ndk-buildse você tiver um jnidiretório nas fontes do projeto.

Isso está funcionando no Android studio 0.5.9 (canary build).

1. Faça o download do NDK

2. Adicione ANDROID_NDK_HOMEàs variáveis ​​de ambiente ou ndk.dir=/path/to/ndkao seu local.propertiesno seu projeto do Android Studio. Isso permite que o Android studio execute o ndk automaticamente.

3. Faça o download dos projetos de amostra gradle mais recentes para ver um exemplo de projeto ndk. (Eles estão na parte inferior da página). Um bom exemplo de projeto é ndkJniLib.

4. Copie o gradle.builddos projetos de amostra NDK. Será algo parecido com isto. Isso gradle.buildcria um apk diferente para cada arquitetura. Você deve selecionar qual arquitetura deseja usar no build variantspainel.

   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
       }
   
   }

Observe que isso ignorará seus arquivos Android.mk e Application.mk. Como solução alternativa, você pode dizer ao gradle para desativar a chamada atuomatic do ndk-build e especificar o diretório das fontes do ndk manualmente.

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
}

Além disso, você provavelmente desejará chamar o ndk-build em seu script gradle build explicitamente, porque acabou de desativar a chamada automática.

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

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

Eu encontrei "gradle 1.11 com.android.tools.build:gradleAdd.9.+" agora suporta ndk de pré-compilação, basta colocar o * .so no diretório src / main / jniLibs. ao construir o gradle, empacote o ndk no lugar certo.

aqui está o meu projeto

Projeto:
| --src
| - | --main
| - | - | --java
| - | - | --jniLibs
| - | - | - | --armeabi
Arquivos | - | - | - | - | -. so
| --libs
| - | --other.jar

Como Xavier disse, você pode colocar seus pré-compilados em / src / main / jniLibs / se estiver usando o gradle 0.7.2+

retirado de: https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/ctDp9viWaxoJ

A partir de agora (Android Studio v0.8.6), é bastante simples. Aqui estão as etapas para criar um aplicativo do tipo "Olá, mundo":

1. Baixe o NDK do Android e coloque a pasta raiz em algum lugar saudável - no mesmo local da pasta SDK, talvez.

2. Adicione o seguinte ao seu local.properties arquivo: ndk.dir=<path-to-ndk>

3. Adicione o seguinte ao seu arquivo build.gradle dentro do diretório defaultConfig fechamento, logo após a versionNamelinha:ndk { moduleName="hello-world" }

4. Nos módulos do seu aplicativo main diretório , crie uma nova pasta chamada jni.

5. Nessa pasta, crie um arquivo chamado hello-world.c , que você verá abaixo.

6. Veja o Activitycódigo de exemplo abaixo para obter um exemplo de como chamar um método (ou é uma função?) Em 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'])
}

Encontre o código fonte completo de um aplicativo muito semelhante aqui (menos o NDK).

Se você está no unix, a versão mais recente (0.8) adiciona o ndk-build. Veja como adicioná-lo:

android.ndk {
    moduleName "libraw"
}

Ele espera encontrar o JNI em 'src / main / jni', caso contrário, você pode defini-lo com:

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

A partir de 28 de janeiro de 2014, com a versão 0.8, a compilação estava quebrada no Windows, você deve desabilitar a compilação com:

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

Uma solução alternativa elegante é mostrada em https://groups.google.com/d/msg/adt-dev/nQobKd2Gl_8/Z5yWAvCh4h4J .

Basicamente, você cria um jar que contém "lib / armeabi / yourlib.so" e depois inclui o jar na compilação.

Uma boa resposta para automatizar o empacotamento de .soarquivos- prontamente compilados é fornecida em outro thread (fechado) . Para fazer isso funcionar, tive que mudar de linha:

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

para dentro:

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

Sem essa alteração, os .soarquivos não foram encontrados e, portanto, a tarefa de empacotá-los nunca seria executada.

A resposta de @plaisthos quebrou na versão mais recente do gradle, mas ainda há uma maneira de fazê-lo. Crie umnative-libs diretório na raiz do diretório do seu projeto e copie todas as nossas bibliotecas para esse diretório.

Adicione as seguintes linhas ao seu build.gradle. Construa e seja feliz.

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'

Este é o código que eu uso para construir usando o android-ndk da gradle. Para isso, adicione o caminho do diretório ndk em gradle.propertiesie. adicione ndkdir=/home/user/android-ndk-r9de coloque todos os arquivos jni em uma pasta native, src/main/como você pode ver no código postado abaixo. Ele criará jar com bibliotecas nativas que você pode usar normalmente como emSystem.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'

Usei o código a seguir para compilar bibliotecas nativas de caixas de depósito, estou usando o 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)
}

Eu usei ndk.dir=/usr/shareData/android-ndk-r11b // caminho do ndk

no arquivo local.properties no projeto android studio. e inclua esta linha:
android.useDeprecatedNdk=true

no arquivo gradle.properties no projeto android studio.

Mais informações aqui: http://tools.android.com/tech-docs/android-ndk-preview

Para expandir o que Naxos disse (obrigado Naxos por me enviar na direção certa!), Aprendi bastante com os exemplos NDK lançados recentemente e postei uma resposta em uma pergunta semelhante aqui.

Como configurar o NDK com o plugin Android Gradle 0.7

Esta postagem contém detalhes completos sobre como vincular bibliotecas nativas pré-criadas ao seu aplicativo para as várias arquiteturas, além de informações sobre como adicionar suporte NDK diretamente ao script build.gradle. Na maioria das vezes, você não precisa mais trabalhar com o zip e a cópia.

Aqui estão as etapas que eu usei para fazer o NDK funcionar no meu projeto do Android Studio. Usei este tutorial para me ajudar https://software.intel.com/pt-br/videos/using-the-ndk-with-android-studio

Para usar o NDK, você deve adicionar uma linha NDK ao local.properties. Então, sob o seu sdk.dir, adicione

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

Nos meus aplicativos build.gradle, tenho o seguinte código

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

moduleName é o nome que você deseja fornecer ao seu código nativo. Eu acredito que é assim que a biblioteca compartilhada será chamada. O ldLibs permite que eu faça logon no LogCat, stl é o stl que você deseja importar. Existem muitas opções, iguais ao NDK do Eclipse. ( http://www.kandroid.org/ndk/docs/CPLUSPLUS-SUPPORT.html )

cFlags ainda são uma certa quantidade de magia negra para mim. Não encontrei uma boa fonte para todas as opções e o que elas me dão. Pesquise em torno do StackOverflow o que você precisa, é onde eu o encontrei. Eu sei que o c ++ 11 me permite usar o novo padrão do c ++ 11.

Aqui está um exemplo de como eu registro no LogCat a partir do código nativo

__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());

configurar projeto no android studio a partir do eclipse: você precisa importar o projeto eclipse ndk para o android studio sem exportar para gradle e funciona, também é necessário adicionar o caminho do ndk em local.properties , se mostrar erro, adicionar

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

no arquivo build.gradle , crie a pasta e o arquivo jni usando o terminal e execute-o.

Agora que o Android Studio está no canal estável, é bastante simples executar as amostras do Android-ndk . Essas amostras usam o plug-in experimental ndk e são mais recentes do que as vinculadas na documentação online do Android NDK. Depois de saber que eles funcionam, você pode estudar os arquivos build.gradle, local.properties e gradle-wrapper.properties e modificar seu projeto de acordo. A seguir estão as etapas para fazê-los funcionar.

1. Vá para configurações, Aparência e comportamento, Configurações do sistema, SDK do Android, selecione a guia Ferramentas do SDK e verifique a versão 1.0.0 do Android NDK na parte inferior da lista. Isso fará o download do NDK.

2. Aponte para o local do NDK recém-baixado. Observe que ele será colocado no diretório sdk / ndk-bundle. Faça isso selecionando Arquivo, Estrutura do projeto, Local do SDK (à esquerda) e fornecendo um caminho no local Android NDK. Isso adicionará uma entrada ndk ao local.properties semelhante a este:

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

Eu construí e implantei com êxito todos os projetos no repositório dessa maneira, exceto gles3gni, codec nativo e construtor. Estou usando o seguinte:

Android Studio 1.3 build AI-141.2117773
amostras de android-ndk publicadas em 28 de julho de 2015 (link acima)
SDK Tools 24.3.3
NDK r10e extraído para C: \ Android \ sdk \ ndk-bundle
Gradle 2.5
Plug-in Gradle 0.2.0
Windows 8.1 64 bits

NDK Builds and gradle (basic)

Geralmente, criar com o NDK é tão simples quanto especificar corretamente um caminho ndkBuild para Android.mk ou um caminho cmake para CMakeLists.txt. Eu recomendo o CMake sobre o Android.mk antigo, porque o suporte a C / C ++ do Android Studio é baseado no CLion e usa o CMake como formato de projeto. Na minha experiência, isso tendeu a tornar o IDE mais responsivo em projetos maiores. Tudo o que é compilado no seu projeto será criado e copiado no APK automaticamente.

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'])
}

Adicionando bibliotecas pré-construídas ao projeto (avançado)

As bibliotecas estáticas (.a) na sua compilação NDK serão automaticamente incluídas, mas as bibliotecas dinâmicas pré-criadas (.so) precisarão ser colocadas jniLibs. Isso pode ser configurado usando sourceSets, mas você deve adotar o padrão. Você NÃO PRECISA de nenhum comando adicional nobuild.gradle ao incluir bibliotecas pré-construídas.

O layout de jniLibs

Você pode encontrar mais informações sobre a estrutura no Guia do usuário do Android Gradle Plugin .

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

Em seguida, você pode validar que o APK resultante contém seus arquivos .so, normalmente em build/outputs/apk/, usandounzip -l myApp.apk para listar o conteúdo.

Construindo bibliotecas compartilhadas

Se você estiver criando uma biblioteca compartilhada no NDK, não precisará fazer mais nada. Ele será agrupado corretamente no APK.

Basta adicionar essas linhas ao aplicativo 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)
}

now.I pode carregar o tão sucesso!

1. adicione o arquivo .so a este caminho

Project:

| --src | - | --main | - | - | --java | - | - | --jniLibs | - | - | - | --armeabi | - | - Arquivos | - | - | -. so

2. adicione este código ao gradle.build

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

}

3)System.loadLibrary("yousoname");

4. boa sorte para você, está tudo bem com gradle 1.2.3

1. Se seu projeto foi exportado do eclipse, adicione os códigos abaixo no arquivo gradle:

   android {
      sourceSets{
           main{
              jniLibs.srcDir['libs']  
         }  
       }
   }

2.Se você criar um projeto no Android studio:

crie uma pasta chamada jniLibs em src / main / ， e coloque seus arquivos * .so na pasta jniLibs.

E copie o código como abaixo em seu arquivo gradle:

android {
    sourceSets{  
       main{  
         jniLibs.srcDir['jniLibs']  
      }  
    }
}

Embora eu acredite que SJoshi (oracle guy) tenha a resposta mais completa, o projeto SWIG é um caso especial, interessante e útil, mas não generalizado para a maioria dos projetos que se saíram bem com os projetos baseados em formigas SDK padrão + NDK. Todos nós gostaríamos de estar usando o Android studio agora, provavelmente, ou queremos uma cadeia de ferramentas de construção mais amigável para o IC para dispositivos móveis, que gradle oferece teoricamente.

Publiquei minha abordagem, emprestada de algum lugar (encontrei isso no SO, mas publiquei uma essência para o aplicativo build.gradle: https://gist.github.com/truedat101/c45ff2b69e91d5c8e9c7962d4b96e841 ). Em poucas palavras, recomendo o seguinte:

• Não atualize seu projeto para a versão mais recente do gradle
• Use com.android.tools.build:gradle:1.5.0 na raiz do projeto
• Use com.android.application no seu projeto de aplicativo
• Verifique se o gradle.properties possui: android.useDeprecatedNdk = true (caso esteja reclamando)
• Use a abordagem acima para garantir que suas horas e horas de esforço na criação de arquivos Android.mk não sejam descartadas. Você controla quais alvos são construídos. E essas instruções são gentis com os usuários do Windows, que teoricamente devem poder construir no Windows sem problemas especiais.

Gradle para Android tem sido uma bagunça na minha opinião, por mais que eu goste dos conceitos emprestados e da estrutura de diretórios opinativa de um projeto. Esse recurso NDK está "chegando em breve" há quase três anos ou mais.