So fügen Sie ein externes AAR-Paket mit dem neuen Gradle Android Build System manuell ein

Ich habe mit dem neuen Android-Build-System experimentiert und bin auf ein kleines Problem gestoßen. Ich habe mein eigenes aar-Paket von ActionBarSherlock zusammengestellt, das ich 'actionbarsherlock.aar' genannt habe. Was ich versuche, ist, dieses aar tatsächlich zu verwenden, um meine endgültige APK zu erstellen. Wenn ich die gesamte ActionBarSherlock-Bibliothek als Android-Bibliotheksmodul mit Kompilierungsprojekt (': actionbarsherlock') in mein Hauptprojekt einbinde, kann ich problemlos erfolgreich erstellen.

Mein Problem ist jedoch, dass ich diese Abhängigkeit MANUELL als aar-Dateipaket bereitstellen möchte, nur wenn ich eine JAR verwenden würde, kann ich anscheinend nicht herausfinden, wie ich sie richtig in mein Projekt aufnehmen kann. Ich habe versucht, die Kompilierungskonfiguration zu verwenden, aber dies scheint nicht zu funktionieren. Ich bekomme beim Kompilieren immer wieder kein Symbol, das mir sagt, dass die classes.jar aus dem aar-Paket nicht in den Klassenpfad aufgenommen wird.

Kennt jemand die Syntax, um ein aar-Paket manuell als Datei einzuschließen?

build.gradle

buildscript {

 repositories {
     mavenCentral()
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:0.4'
  }
}
apply plugin: 'android'

repositories {
   mavenCentral()
}
dependencies {
    compile files('libs/actionbarsherlock.aar')
}

android {
    compileSdkVersion 15
    buildToolsVersion "17.0"
}

BEARBEITEN: Die Antwort lautet also, dass es derzeit nicht unterstützt wird. Hier ist das Problem, wenn Sie es verfolgen möchten.

EDIT: Da dies derzeit noch nicht direkt unterstützt wird, scheint die beste Alternative die vorgeschlagene Lösung von @RanWakshlak zu sein

BEARBEITEN: Auch einfacher mit der von @VipulShah vorgeschlagenen Syntax

Befolgen Sie die folgenden Schritte, um es zum Laufen zu bringen (ich habe es bis Android Studio 2.2 getestet).

Nehmen wir an, Sie haben eine AAR-Datei im libs-Ordner gespeichert. (Angenommen, der Dateiname ist cards.aar)

Geben Sie dann in der App build.gradleFolgendes an und klicken Sie auf Projekt mit Gradle-Dateien synchronisieren. Öffnen Sie build.gradle auf Projektebene und fügen Sie es flatDir{dirs 'libs'}wie unten beschrieben hinzu

allprojects {
   repositories {
      jcenter()
      flatDir {
        dirs 'libs'
      }
   }
}

Öffnen Sie jetzt die Datei build.grdle auf App-Ebene und fügen Sie die .aarDatei hinzu

    dependencies {
       compile(name:'cards', ext:'aar')
}

Wenn alles gut geht, werden Sie sehen, dass der Bibliothekseintrag in build -> exploded-aar erfolgt

Beachten Sie außerdem, dass Sie beim Importieren einer .aar-Datei aus einem anderen Projekt mit Abhängigkeiten diese ebenfalls in Ihr build.gradle aufnehmen müssen.

1. Klicken Sie mit der rechten Maustaste auf Ihr Projekt und wählen Sie "Moduleinstellungen öffnen" .

2. Klicken Sie auf die Schaltfläche "+" in der oberen linken Ecke des Fensters, um ein neues Modul hinzuzufügen.

3. Wählen Sie ".JAR- oder .AAR-Paket importieren" und klicken Sie auf die Schaltfläche "Weiter" .

4. Suchen Sie die AAR-Datei mithilfe der Auslassungsschaltfläche "..." neben dem Feld "Dateiname".

5. Lassen Sie das Modul der App ausgewählt und klicken Sie auf den Bereich Abhängigkeiten , um das neue Modul als Abhängigkeit hinzuzufügen.

6. Verwenden Sie die Schaltfläche "+" des Abhängigkeitsbildschirms und wählen Sie "Modulabhängigkeit" .

7. Wählen Sie das Modul aus und klicken Sie auf "OK" .

Sie können auf eine aar-Datei aus einem Repository verweisen. Ein Maven ist eine Option, aber es gibt eine einfachere Lösung: Legen Sie die aar-Datei in Ihrem libs-Verzeichnis ab und fügen Sie ein Verzeichnis-Repository hinzu.

    repositories {
      mavenCentral()
      flatDir {
        dirs 'libs'
      }
    }

Verweisen Sie dann auf die Bibliothek im Abschnitt "Abhängigkeit":

  dependencies {
        implementation 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
}

Weitere Informationen finden Sie im Min'an-Blogbeitrag .

Der folgende Ansatz funktioniert mit dem neuesten Android Studio (> v0.8.x):

• Speichern Sie die aarDatei unter App - Moduls libsOrdner (zB: <project>/<app>/libs/myaar.aar)

• Fügen Sie das Folgende zu build.gradle Ihres Modulordners "app" hinzu (nicht zu Ihrem Projektstamm build.gradle). Beachten Sie den Namen in der Kompilierungszeile, es ist myaar @ aar, nicht myaar.aar.

  dependencies {
      compile 'package.name.of.your.aar:myaar@aar'
  }
  
  repositories{
      flatDir{
          dirs 'libs'
      }
  }

• Klicken Tools -> Android -> Sync Project with Gradle Files

vor (Standard)

implementation fileTree(include: ['*.jar'], dir: 'libs')

einfach '*.aar'in includeArray hinzufügen .

implementation fileTree(include: ['*.jar', '*.aar'], dir: 'libs')

es funktioniert gut unter Android Studio 3.x.

Wenn Sie eine Bibliothek ignorieren möchten? mag das.

implementation fileTree(include: ['*.jar', '*.aar'], exclude: 'test_aar*', dir: 'libs')
debugImplementation files('libs/test_aar-debug.aar')
releaseImplementation files('libs/test_aar-release.aar')

Ich habe es gerade geschafft!

1. Kopieren Sie die Datei mylib-0.1.aar in den Ordner libs /

2. Fügen Sie diese Zeilen am Ende von build.gradle hinzu (sollte App sein, kein Projekt):

   repositories {
      flatDir {
          dirs 'libs'
      }
   }
   dependencies {
       compile 'com.example.lib:mylib:0.1@aar'
   }

3. So weit, ist es gut. Hier kommt der wichtigste Punkt:

Gradle muss für Abhängigkeiten auf das Netzwerk zugreifen, es sei denn, der Offline-Modus ist aktiviert.

Stellen Sie sicher, dass Sie die Offline-Arbeit über das Kontrollkästchen in Projektstrukturen / Gradle aktiviert haben

-- ODER --

Konfigurieren Sie die Proxy-Einstellungen, um auf das Netzwerk zuzugreifen.

Um die Proxy-Einstellungen zu konfigurieren, müssen Sie die Datei gradle.properties des Projekts ändern und http und https wie folgt separat konfigurieren:

systemProp.http.proxyHost=proxy.example.com
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=user
systemProp.http.proxyPassword=pass
systemProp.http.nonProxyHosts=localhost
systemProp.http.auth.ntlm.domain=example <for NT auth>

systemProp.https.proxyHost=proxy.example.com
systemProp.https.proxyPort=8080
systemProp.https.proxyUser=user
systemProp.https.proxyPassword=pass
systemProp.https.nonProxyHosts=localhost
systemProp.https.auth.ntlm.domain=example <for NT auth>

Hoffe das funktioniert.

Derzeit wird das Verweisen auf eine lokale .aar-Datei nicht unterstützt (wie von Xavier Ducrochet bestätigt).

Stattdessen können Sie ein lokales Maven-Repository einrichten (viel einfacher als es sich anhört) und von dort aus auf die .aar-Datei verweisen.

Ich habe einen Blogpost geschrieben, in dem beschrieben wird, wie es hier funktioniert:

http://www.flexlabs.org/2013/06/using-local-aar-android-library-packages-in-gradle-builds

Sie können aarmit nur wenigen Codezeilen mehrere Abhängigkeiten hinzufügen .

Lokales flatDirRepository hinzufügen:

repositories {
    flatDir {
        dirs 'libs'
    }
} 

In jeden aarin libsVerzeichnis compileAbhängigkeit Konfiguration:

fileTree(dir: 'libs', include: '**/*.aar')
        .each { File file ->
    dependencies.add("compile", [name: file.name.lastIndexOf('.').with { it != -1 ? file.name[0..<it] : file.name }, ext: 'aar'])
}

Leider hat keine der Lösungen hier für mich funktioniert (ich bekomme ungelöste Abhängigkeiten). Was letztendlich funktioniert hat und meiner Meinung nach der einfachste Weg ist: Markieren Sie den Projektnamen in Android Studio und dann Datei -> Neues Modul -> JAR- oder AAR-Paket importieren. Gutschrift geht an die Lösung in diesem Beitrag

Es gibt zwei Möglichkeiten:

Der erste Weg

1. Öffnen Sie Ihr Android Studio und navigieren Sie zum Create New ModuleFenster vonFile -> New -> New Module

2. Wählen Sie das Import .JAR/.AAR PackageElement aus und klicken Sie auf die NextSchaltfläche

3. Fügen Sie der build.gradleDatei, die zu Ihrem appModul gehört, eine Abhängigkeit hinzu .

    dependencies {
        ...
        implementation project(path: ':your aar lib name')
    }

Das ist alles.

Der zweite Weg

1. Erstellen Sie einen Ordner im libsVerzeichnis, z aars.

2. Legen Sie Ihre aar lib in den aars-Ordner.

3. Fügen Sie das Code-Snippet hinzu

repositories {
    flatDir {
        dirs 'libs/aars'
    }
}

in Ihre build.gradleDatei gehört zum App-Modul.

4. Fügen Sie der build.gradleDatei, die zu Ihrem appModul gehört, eine Abhängigkeit hinzu .

dependencies {
    ...
    implementation (name:'your aar lib name', ext:'aar')
}

Das ist alles.

Wenn Sie Chinesisch lesen können, können Sie den Blog AR 是 AAR 文件 以及 如何 在 Android 开发 中 使用 überprüfen

Mit Android Studio 3.4 und Gradle 5 können Sie dies einfach so tun

dependencies {
    implementation files('libs/actionbarsherlock.aar')
}

UPDATE ANDROID STUDIO 3.4

1. Gehen Sie zu Datei -> Projektstruktur

2. Module und klicken Sie auf +

3. Wählen Sie .aar-Paket importieren

4. Finden Sie die .aar-Route

5. Fertig stellen und Übernehmen , dann überprüfen, ob das Paket hinzugefügt wurde

6. Klicken Sie nun im App-Modul auf + und Modulabhängigkeit

7. Überprüfen Sie das Bibliothekspaket und Ok

8. Überprüfen Sie die hinzugefügte Abhängigkeit

9. Und die Projektstruktur so

Ich habe auch dieses Problem gehabt. Dieser Problembericht : https://code.google.com/p/android/issues/detail?id=55863 scheint darauf hinzudeuten, dass ein direkter Verweis auf die .AAR-Datei nicht unterstützt wird.

Möglicherweise besteht die Alternative vorerst darin, die Actionbarsherlock-Bibliothek als Gradle-Bibliothek im übergeordneten Verzeichnis Ihres Projekts zu definieren und entsprechend zu referenzieren.

Die Syntax wird hier definiert: http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library

Ich habe diese Problemumgehung im Android Issue Tracker gefunden: https://code.google.com/p/android/issues/detail?id=55863#c21

Der Trick (kein Fix) besteht darin, Ihre .aar-Dateien in einem Teilprojekt zu isolieren und Ihre Bibliotheken als Artefakte hinzuzufügen:

configurations.create("default")
artifacts.add("default", file('somelib.jar'))
artifacts.add("default", file('someaar.aar'))

Weitere Informationen: Umgang mit transitiven Abhängigkeiten für lokale Artefakte

In meinem Fall habe ich einige Abhängigkeiten in meiner Bibliothek, und als ich eine aardaraus erstellte, bin ich aufgrund fehlender Abhängigkeiten fehlgeschlagen. Daher besteht meine Lösung darin, alle Abhängigkeiten aus meiner Bibliothek mit einer arrDatei hinzuzufügen .

Meine Projektebene build.gradlesieht also so aus:

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

allprojects {
    repositories {
        mavenCentral()
        //add it to be able to add depency to aar-files from libs folder in build.gradle(yoursAppModule)
        flatDir {
            dirs 'libs'
        }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

build.gradle(modile app) damit:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.3"

    defaultConfig {
        applicationId "com.example.sampleapp"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    //your project depencies
    ...
    //add lib via aar-depency
    compile(name: 'aarLibFileNameHere', ext: 'aar')
    //add all its internal depencies, as arr don't have it
    ...
}

und Bibliothek build.gradle:

apply plugin: 'com.android.library'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.3"

    defaultConfig {
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    //here goes library projects dependencies, which you must include
    //in yours build.gradle(modile app) too
    ...
}

Ich habe hier alle Lösungen ausprobiert, aber keine funktioniert. Dann habe ich .aarfestgestellt, dass ich einen Fehler gemacht habe. Ich habe den Ordner in den falschen Ordner gelegt, wie Sie unten sehen können. Ich dachte, ich sollte ihn in den Stammordner legen, also habe ich dort einen libsOrdner erstellt (1 im Bild) ), aber im App-Ordner gibt es bereits einen libs, den Sie an zweiter Stelle setzen libssollten. Hoffen Sie , dass dies denjenigen hilft, die das gleiche Problem wie ich haben :

Die Standardmethode zum Importieren von AAR-Dateien in eine Anwendung finden Sie unter https://developer.android.com/studio/projects/android-library.html#AddDependency

Klicken Sie auf Datei> Neu> Neues Modul. Klicken Sie auf .JAR / .AAR-Paket importieren und dann auf Weiter. Geben Sie den Speicherort der kompilierten AAR- oder JAR-Datei ein und klicken Sie auf Fertig stellen.

Bitte beziehen Sie sich auf den obigen Link für die nächsten Schritte.

Nur um die Antwort zu vereinfachen

Wenn die .aar-Datei lokal vorhanden ist, schließen Sie sie
compile project(':project_directory')in die Abhängigkeiten von build.gradle Ihres Projekts ein.

Wenn eine Remote-Datei auf Remote vorhanden ist, schließen Sie sie compile 'com.*********.sdk:project_directory:0.0.1@aar'in die Abhängigkeiten von build.gradle Ihres Projekts ein.

In meinem Fall arbeiten Sie einfach, wenn ich "Projekt" zum Kompilieren hinzufüge:

repositories {
    mavenCentral()
    flatDir {
        dirs 'libs'
    }
}


dependencies {
   compile project('com.x.x:x:1.0.0')
}

Sie können so etwas tun:

1. Legen Sie Ihre lokalen Bibliotheken (mit der Erweiterung: .jar, .aar, ...) in den Ordner 'libs' (oder in einen anderen, wenn Sie möchten).

2. Fügen Sie in build.gradle (App-Ebene) diese Zeile zu Abhängigkeiten hinzu

   ImplementierungsdateiTree (include: ['* .jar', '* .aar'], dir: 'libs')