Wie erstelle ich eine Android-Bibliothek mit Android Studio und Gradle?

Ich versuche, ein Projekt von Eclipse zu migrieren, aber nichts, was ich versucht habe, funktioniert. In Eclipse habe ich 3 Projekte (2 Android App-Projekte und 1 Android Library-Projekt). Die 2 App-Projekte hängen vom Bibliotheksprojekt ab. Wenn ich den Gradle-Export mache, bekomme ich 3 Projekte, die nicht funktionieren. Ich bin offen für eine Umstrukturierung des Projekts, habe jedoch keine Dokumentation darüber gefunden, wie dies getan werden sollte.

Gibt es eine Möglichkeit, die drei Projekte, die Eclipse exportiert, zusammenzubringen? Bin ich besser dran, Dinge umzustrukturieren, und wenn ja, ist die Dokumentation dafür, wie dies getan werden soll?

Aktualisieren

Ich habe das gesamte Projekt auf GitHub hochgeladen https://github.com/ RegardTheCode/android- studio- library- example

Update 1

Basierend auf den Vorschlägen von Padma Kumar habe ich dies versucht.

1. Erstellen Sie ein neues Projekt mit dem Namen MyApp
2. Klicken File > New Module, wählen Android Libraryund benennen Sie esMyLib
3. Klicken Build > Make Project

Der Build schlägt mit diesem Fehler fehl

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.

Ich habe dann packagedem Manifest ein Attribut hinzugefügt , das es erstellt

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

Nach dem Erstellen erhalte ich diesen Fehler

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

Das Hinzufügen von Abhängigkeiten scheint keine Auswirkungen auf den Fehler zu haben. Weiter von oben

1. Klicken File > Project Structure > Modules > MyApp-MyApp
2. Wechseln Sie zu DependenciesTab
3. Klicken + > Module Dependencyund auswählenMyLib
4. Klicken Sie auf ApplyundOK
5. Klicken Build > Make Project

Update 2

Basierend auf den Vorschlägen von Ethan bekommen wir hier

Das 2-Teil-Projekt build.gradlescheint alle richtigen Teile zu haben und der einzige Unterschied ist, dass die folgende Plugin-Zeile die ist 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
    }
}

Das Root-Projekt build.gradlewar leer, also habe ich die beiden Projekte wie folgt hinzugefügt

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

Ich bekomme jetzt diesen Fehler beim Bauen

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.

Update 3

Vielen Dank an Ethan für die Lösung.

1. compile project(':SubProjects:MyLib')Zum hinzufügenMyLib/build.gradle
2. compile files('libs/android-support-v4.jar')Aus dem entfernenMyLib/build.gradle
3. Schließen Sie das Projekt und importieren Sie das Stammprojekt aus gradle

Update 4

Ab 0.1.2 können Sie jetzt compile "com.android.support:support-v4:13.0.0"anstelle von einschließen compile files('libs/android-support-v4.jar'). Da es jetzt von mavin kommt, können Sie dies problemlos in mehrere Projekte aufnehmen.

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

Update 5

Ab 0.1.3 gibt es jetzt eine Schaltfläche "Projekt synchronisieren" in der Symbolleiste. Sie können darauf klicken, anstatt Ihr Projekt erneut zu .gradleimportieren, nachdem Sie Änderungen an Dateien vorgenommen haben.

Hinweis : Diese Antwort ist eine reine Gradle-Antwort. Ich verwende sie regelmäßig in IntelliJ, weiß aber nicht, wie die Integration mit Android Studio erfolgt. Ich bin davon überzeugt, dass ich weiß, was für mich los ist. Deshalb verwende ich Gradle und Android.

TL; DR Vollständiges Beispiel - https://github.com/ethankhall/driving-time-tracker/

Haftungsausschluss : Dies ist ein Projekt, an dem ich arbeite.

Gradle hat eine definierte Struktur (die Sie ändern können, Link unten zeigt Ihnen, wie), die Maven sehr ähnlich ist, wenn Sie sie jemals verwendet haben.

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

Wenn Sie nur ein Projekt haben, wird die Datei settings.gradle nicht benötigt. Sie möchten jedoch weitere Projekte hinzufügen, daher benötigen wir diese.

Werfen wir nun einen Blick auf diese build.gradle-Datei. Sie werden dies darin benötigen (um die Android-Tools hinzuzufügen)

build.gradle

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

Jetzt müssen wir Gradle über einige der Android-Teile informieren. Es ist ziemlich einfach. Eine grundlegende (die in den meisten meiner Fälle funktioniert) sieht wie folgt aus. Ich habe einen Kommentar in diesem Block, der es mir ermöglicht, den Versionsnamen und den Code beim Generieren der APK anzugeben.

build.gradle

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

Etwas, das wir hinzufügen möchten, um allen zu helfen, die das Licht von Gradle noch nicht gesehen haben, eine Möglichkeit für sie, das Projekt zu verwenden, ohne es zu installieren.

build.gradle

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

Jetzt müssen wir also ein Projekt bauen. Jetzt werden wir die anderen hinzufügen. Ich lege sie in ein Verzeichnis, nenne es vielleicht deps oder subProjects. Es ist nicht wirklich wichtig, aber Sie müssen wissen, wo Sie es platzieren. Um Gradle mitzuteilen, wo sich die Projekte befinden, müssen Sie sie zur settings.gradle hinzufügen.

Verzeichnisaufbau:

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'

Das letzte , was Sie sicherstellen sollten , von der Teilprojekte / reallyCoolProject1 / build.gradle hat apply plugin: "android-library"statt apply plugin: "android".

Wie bei jedem Gradle-Projekt (und Maven) müssen wir jetzt das Root-Projekt über seine Abhängigkeit informieren. Dies kann auch alle normalen Java-Abhängigkeiten umfassen, die Sie möchten.

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

Ich weiß, das scheint eine Menge Schritte zu sein, aber sie sind ziemlich einfach, wenn Sie es ein- oder zweimal tun. Auf diese Weise können Sie auch auf einem CI-Server aufbauen, vorausgesetzt, Sie haben das Android SDK dort installiert.

NDK-Randnotiz: Wenn Sie das NDK verwenden möchten, benötigen Sie Folgendes. Eine Beispieldatei für build.gradle finden Sie hier: 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')
}

Quellen:

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/

Ich hatte gerade ein sehr ähnliches Problem mit Gradle Builds / Hinzufügen von .jar Bibliothek. Ich habe es durch eine Kombination von:

1. Verschieben des libs-Ordners in das Stammverzeichnis des Projekts (dasselbe Verzeichnis wie 'src') und Hinzufügen der Bibliothek zu diesem Ordner im Finder (unter Mac OS X)
2. Klicken Sie in Android Studio mit der rechten Maustaste auf den Ordner, um ihn als Bibliothek hinzuzufügen
3. Bearbeiten der Abhängigkeiten in der Datei build.gradle, Hinzufügen compile fileTree(dir: 'libs', include: '*.jar')}

ABER was noch wichtiger und ärgerlicher ist, nur wenige Stunden nachdem ich es zum Laufen gebracht habe, hat Android Studio gerade 0.3.7 veröffentlicht, das behauptet, viele Gradle-Probleme wie das Hinzufügen von .jar-Bibliotheken gelöst zu haben

http://tools.android.com/recent

Hoffe das hilft den Leuten!

Hier ist meine Lösung für Mac-Benutzer. Ich denke, sie funktioniert auch für Windows:

Gehen Sie zuerst zu Ihrer Android Studio-Symbolleiste

Erstellen> Projekt erstellen (während ihr online seid, lasst es die Dateien herunterladen) und dann

Build> Compile Module "Ihr App-Name wird hier angezeigt" (noch online lassen Sie die Dateien sein
herunterladen und beenden) und dann

Wenn Sie Ihre App ausführen, wird Ihr Emulator gestartet und konfiguriert. Führen Sie sie dann aus!

Das ist es!!! Happy Coding Jungs !!!!!!!

Gradle Build Tools 2.2.0+ - Alles funktioniert einfach

Dies ist der richtige Weg

Ich bin froh, dass 2.2.x der Gradle Build Tools herausgekommen ist und jetzt einfach funktioniert. Der Schlüssel ist das externalNativeBuildund zeigt auf das ndkBuildPfadargument auf ein Android.mkoder ändert ndkBuildauf cmakeund zeigt auf das Pfadargument auf ein CMakeLists.txtBuild-Skript.

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

Weitere Informationen finden Sie auf der Google-Seite zum Hinzufügen von nativem Code .

Nachdem dies korrekt eingerichtet wurde, können ./gradlew installDebugSie loslegen. Sie müssen sich auch darüber im Klaren sein, dass sich das NDK in Clang bewegt, da gcc im Android-NDK jetzt veraltet ist.