Come costruire una libreria Android con Android Studio e Gradle?

Sto cercando di migrare un progetto da Eclipse ma nulla che ho provato sta funzionando. In Eclipse ho 3 progetti (2 progetti di app Android e 1 progetto di libreria Android). I 2 progetti di app dipendono dal progetto di libreria. Quando eseguo l'esportazione gradle ottengo 3 progetti che non funzionano. Sono aperto a ristrutturare il progetto ma non ho trovato alcuna documentazione su come farlo.

C'è un modo per far lavorare insieme i 3 progetti che le esportazioni di Eclipse? Sto meglio ristrutturando le cose e, in caso affermativo, c'è documentazione per come farlo?

Aggiornare

Ho caricato l'intero progetto su GitHub https://github.com/respectTheCode/android-studio-library-example

Aggiornamento 1

Sulla base dei suggerimenti di Padma Kumar questo è quello che ho provato.

1. Crea un nuovo progetto chiamato MyApp
2. Fare clic File > New Module, scegliere Android Librarye denominarloMyLib
3. Clic Build > Make Project

La compilazione non riesce con questo errore

Module "MyLib" was fully rebuilt due to project configuration/dependencies changes
Compilation completed with 1 error and 0 warnings in 19 sec
1 error
0 warnings
/.../MyApp/MyLib/build/bundles/debug/AndroidManifest.xml
Gradle: <manifest> does not have package attribute.

Ho quindi aggiunto un packageattributo al manifest rendendolo

<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.mylib" >

Dopo la costruzione ottengo questo errore

Module "MyApp" was fully rebuilt due to project configuration/dependencies changes
Compilation completed with 2 errors and 0 warnings in 13 sec
2 errors
0 warnings
/.../MyApp/MyLib/src/main/java/com/example/mylib/MainActivity.java
Gradle: package R does not exist
Gradle: package R does not exist

L'aggiunta di dipendenza non sembra avere alcun impatto sull'errore. Continuando dall'alto

1. Clic File > Project Structure > Modules > MyApp-MyApp
2. Passa alla Dependenciesscheda
3. Fare clic + > Module Dependencye selezionareMyLib
4. Clicca ApplyeOK
5. Clic Build > Make Project

Aggiornamento 2

Sulla base dei suggerimenti di Ethan, qui è dove arriviamo

Il 2 sotto-progetto build.gradlesembra avere tutte le parti corrette e l'unica differenza è che la seguente linea di plugin è la MyApp/build.gradle.

buildscript {
    repositories {
        maven { url 'http://repo1.maven.org/maven2' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.4'
    }
}
apply plugin: 'android'

dependencies {
    compile files('libs/android-support-v4.jar')
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 7
        targetSdkVersion 16
    }
}

Il progetto di root build.gradleera vuoto, quindi ho aggiunto i due progetti in questo modo

dependencies {
    compile project(":MyLib")
    compile project(":MyApp")
}

Ora ricevo questo errore durante la costruzione

Gradle:
FAILURE: Build failed with an exception.
* Where:
Build file '/Users/kevin/GitHub/AppPress/MyApp/build.gradle' line: 2
* What went wrong:
A problem occurred evaluating root project 'MyApp'.
> Could not find method compile() for arguments [project ':MyLib'] on root project 'MyApp'.
* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.

Aggiornamento 3

Grazie mille Ethan per aver risolto questo.

1. Aggiungi compile project(':SubProjects:MyLib')aMyLib/build.gradle
2. Rimuovere compile files('libs/android-support-v4.jar')dalMyLib/build.gradle
3. Chiudi il progetto e importa il progetto radice dal gradle

Aggiornamento 4

A partire da 0.1.2 ora puoi includere compile "com.android.support:support-v4:13.0.0"invece di compile files('libs/android-support-v4.jar'). Dal momento che proviene da mavin ora puoi includerlo senza problemi in più progetti.

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'com.android.tools.build:gradle:0.4.2'
    }
}

apply plugin: 'android'

dependencies {
    compile "com.android.support:support-v4:13.0.0"

    compile project(':SubProjects:MyLib')
}

Aggiornamento 5

A partire da 0.1.3 ora c'è un pulsante "Sincronizza progetto" nella barra degli strumenti. È possibile fare clic su questo invece di reimportare il progetto dopo aver apportato modifiche ai .gradlefile.

Nota : questa risposta è una pura risposta Gradle, la utilizzo regolarmente in IntelliJ ma non so come sia l'integrazione con Android Studio. Sono un sostenitore del sapere cosa sta succedendo per me, quindi è così che uso Gradle e Android.

TL; DR esempio completo - https://github.com/ethankhall/driving-time-tracker/

Disclaimer : questo è un progetto a cui sto / stavo lavorando.

Gradle ha una struttura definita (che puoi cambiare, il link in fondo ti dice come) che è molto simile a Maven se l'hai mai usato.

Project Root
+-- src
|   +-- main (your project)
|   |   +-- java (where your java code goes)
|   |   +-- res  (where your res go)
|   |   +-- assets (where your assets go)
|   |   \-- AndroidManifest.xml
|   \-- instrumentTest (test project)
|       \-- java (where your java code goes)
+-- build.gradle
\-- settings.gradle

Se hai un solo progetto, il file settings.gradle non è necessario. Tuttavia, vuoi aggiungere altri progetti, quindi ne abbiamo bisogno.

Ora diamo un'occhiata a quel file build.gradle. Ne avrai bisogno (per aggiungere gli strumenti Android)

build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.3'
    }
}

Ora dobbiamo dire a Gradle di alcune parti di Android. È abbastanza semplice Uno di base (che funziona nella maggior parte dei miei casi) è simile al seguente. Ho un commento in questo blocco, mi permetterà di specificare il nome e il codice della versione durante la generazione dell'APK.

build.gradle

apply plugin: "android"
android {
        compileSdkVersion 17
        /*
        defaultConfig {
            versionCode = 1
            versionName = "0.0.0"
        }
        */
    }

Qualcosa che vorremmo aggiungere, per aiutare chiunque non abbia ancora visto la luce di Gradle, un modo per loro di usare il progetto senza installarlo.

build.gradle

task wrapper(type: org.gradle.api.tasks.wrapper.Wrapper) {
    gradleVersion = '1.4'
}

Quindi ora abbiamo un progetto da costruire. Ora aggiungeremo gli altri. Li metto in una directory, forse lo chiamo deps o sottoprogetti. Non importa, ma dovrai sapere dove lo metti. Per dire a Gradle dove sono i progetti dovrai aggiungerli a settings.gradle.

Struttura delle directory:

Project Root
+-- src (see above)
+-- subProjects (where projects are held)
|   +-- reallyCoolProject1 (your first included project)
|       \-- See project structure for a normal app
|   \-- reallyCoolProject2 (your second included project)
|       \-- See project structure for a normal app
+-- build.gradle
\-- settings.gradle

settings.gradle:

include ':subProjects:reallyCoolProject1'
include ':subProjects:reallyCoolProject2'

L'ultima cosa di cui dovresti essere certo è che subProjects / reallyCoolProject1 / build.gradle ha apply plugin: "android-library"invece di apply plugin: "android".

Come ogni progetto Gradle (e Maven) ora dobbiamo dire al progetto root della sua dipendenza. Questo può includere anche le normali dipendenze Java che desideri.

build.gradle

dependencies{
    compile 'com.fasterxml.jackson.core:jackson-core:2.1.4'
    compile 'com.fasterxml.jackson.core:jackson-databind:2.1.4'
    compile project(":subProjects:reallyCoolProject1")
    compile project(':subProjects:reallyCoolProject2')
}

So che sembra un sacco di passaggi, ma sono abbastanza facili una volta che lo fai una o due volte. In questo modo potrai anche costruire su un server CI supponendo che l'SDK Android sia installato lì.

Nota laterale NDK: se stai per utilizzare NDK avrai bisogno di qualcosa di simile al di sotto. Il file build.gradle di esempio è disponibile qui: https://gist.github.com/khernyo/4226923

build.gradle

task copyNativeLibs(type: Copy) {
    from fileTree(dir: 'libs', include: '**/*.so' )  into  'build/native-libs'
}
tasks.withType(Compile) { compileTask -> compileTask.dependsOn copyNativeLibs }

clean.dependsOn 'cleanCopyNativeLibs'

tasks.withType(com.android.build.gradle.tasks.PackageApplication) { pkgTask ->
  pkgTask.jniDir new File('build/native-libs')
}

fonti:

1. http://tools.android.com/tech-docs/new-build-system/user-guide
2. https://gist.github.com/khernyo/4226923
3. https://github.com/ethankhall/driving-time-tracker/

Ho appena avuto problemi molto simili con build / aggiunta gradle di libreria .jar. L'ho fatto funzionare da una combinazione di:

1. Spostare la cartella libs nella radice del progetto (stessa directory di 'src') e aggiungere la libreria a questa cartella nel finder (usando Mac OS X)
2. In Android Studio, fai clic con il pulsante destro del mouse sulla cartella per aggiungerla come libreria
3. Modifica delle dipendenze nel file build.gradle, aggiunta compile fileTree(dir: 'libs', include: '*.jar')}

Ma ancora più importante e fastidioso, solo poche ore dopo averlo fatto funzionare, Android Studio ha appena rilasciato la 0.3.7, che afferma di aver risolto molti problemi di livello come l'aggiunta di librerie .jar

http://tools.android.com/recent

Spero che questo aiuti le persone!

Ecco la mia soluzione per utenti Mac, penso che funzioni anche per Windows:

Prima vai alla barra degli strumenti di Android Studio

Build> Make Project (mentre voi siete online lasciate che scarichi i file) e poi

Genera> Compila modulo "qui viene mostrato il nome della tua app" (ancora online, lascia che i file vengano
scaricati e finiti) e poi

Esegui la tua app che è fatta avvierà il tuo emulatore e configurarlo quindi eseguirlo!

Questo è tutto !!! Buona programmazione ragazzi !!!!!!!

Gradle Build Tools 2.2.0+ - Tutto funziona e basta

Questo è il modo corretto di farlo

Nel tentativo di evitare sperimentali e sinceramente stufo dell'NDK e di tutti i suoi hacker, sono felice che il 2.2.x degli strumenti di costruzione di Gradle sia uscito e ora funzioni. La chiave è l' argomento del percorso di externalNativeBuildpuntamento e in ndkBuildcorrispondenza di Android.mko cambia ndkBuildin cmakee punta l'argomento del percorso in uno CMakeLists.txtscript di compilazione.

android {
    compileSdkVersion 19
    buildToolsVersion "25.0.2"

    defaultConfig {
        minSdkVersion 19
        targetSdkVersion 19

        ndk {
            abiFilters 'armeabi', 'armeabi-v7a', 'x86'
        }

        externalNativeBuild {
            cmake {
                cppFlags '-std=c++11'
                arguments '-DANDROID_TOOLCHAIN=clang',
                        '-DANDROID_PLATFORM=android-19',
                        '-DANDROID_STL=gnustl_static',
                        '-DANDROID_ARM_NEON=TRUE',
                        '-DANDROID_CPP_FEATURES=exceptions rtti'
            }
        }
    }

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

Per ulteriori dettagli controlla la pagina di Google sull'aggiunta di codice nativo .

Dopo che questo è stato impostato correttamente, è possibile ./gradlew installDebuge si parte. Dovrai anche essere consapevole del fatto che NDK si sta trasformando in clang poiché gcc è ora deprecato in NDK Android.