Come includere manualmente il pacchetto aar esterno usando il nuovo sistema Android Build Gradle

Ho sperimentato il nuovo sistema di build Android e ho riscontrato un piccolo problema. Ho compilato il mio pacchetto aar di ActionBarSherlock che ho chiamato 'actionbarsherlock.aar'. Quello che sto cercando di fare è effettivamente usare questo aar per costruire il mio APK finale. Se includo l'intera libreria ActionBarSherlock come modulo di libreria Android nel mio progetto principale usando il progetto di compilazione (': actionbarsherlock') sono in grado di costruire con successo senza problemi.

Ma il mio problema è che voglio fornire quella dipendenza come un pacchetto di file aAR MANUALMENTE solo se farei un JAR, non riesco a capire come includerlo correttamente nel mio progetto. Ho tentato di utilizzare la configurazione di compilazione ma questo non sembra funzionare. Continuo a non riuscire a trovare il simbolo durante la compilazione, il che mi dice che il pacchetto class.jar di aar non viene incluso nel percorso di classe.

Qualcuno sa della sintassi per includere manualmente un pacchetto aar come file?

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

EDIT: Quindi la risposta è che al momento non è supportato, ecco il problema se vuoi seguirlo.

EDIT: attualmente poiché questo non è ancora supportato direttamente, la migliore alternativa sembra essere la soluzione proposta da @RanWakshlak

EDIT: anche più semplice usando la sintassi proposta da @VipulShah

Seguire i passaggi seguenti per farlo funzionare (l'ho testato su Android Studio 2.2)

Diciamo che hai tenuto il file nella cartella libs. (supponiamo che il nome del file siacards.aar )

quindi nell'app build.gradlespecificare quanto segue e fare clic su Sincronizza progetto con i file Gradle. Apri Build.gradle a livello di progetto e aggiungi flatDir{dirs 'libs'}come fatto di seguito

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

e ora apri il file build.grdle a livello di app e aggiungi il .aarfile

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

Se tutto va bene vedrai la voce della libreria fatta in build -> esplded-aar

Inoltre, se stai importando un file .aar da un altro progetto che ha dipendenze, dovrai includerle anche nel tuo build.gradle.

1. Fare clic con il tasto destro sul progetto e selezionare "Apri le impostazioni del modulo" .

2. Fai clic sul pulsante "+" nell'angolo in alto a sinistra della finestra per aggiungere un nuovo modulo.

3. Seleziona "Importa pacchetto .JAR o .AAR" e fai clic sul pulsante "Avanti" .

4. Trova il file AAR usando il pulsante con i puntini di sospensione "..." accanto al campo "Nome file".

5. Mantieni selezionato il modulo dell'app e fai clic sul riquadro Dipendenze per aggiungere il nuovo modulo come dipendenza.

6. Utilizzare il pulsante "+" della schermata delle dipendenze e selezionare "Dipendenza del modulo" .

7. Seleziona il modulo e fai clic su "OK" .

È possibile fare riferimento a un file aar da un repository. Un maven è un'opzione, ma esiste una soluzione più semplice: metti il ​​file aar nella tua directory libs e aggiungi un repository di directory.

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

Quindi fare riferimento alla libreria nella sezione delle dipendenze:

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

Puoi dare un'occhiata al post sul blog di Min'an per maggiori informazioni.

L'approccio seguente funziona con l'ultimo Android Studio (> v0.8.x):

• Salvare il aarfile nella libscartella del modulo dell'app (ad es . <project>/<app>/libs/myaar.aar:)

• Aggiungi quanto segue a build.gradle della cartella del modulo "app" (non alla build del progetto build.gradle). Nota il nome nella riga di compilazione, è myaar @ aar non myaar.aar.

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

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

prima (default)

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

basta aggiungere '*.aar'in includearray.

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

funziona bene su Android Studio 3.x.

se vuoi ignorare qualche libreria? fare così.

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

Ci sono appena riuscito!

1. Copia il file mylib-0.1.aar nella cartella libs /

2. Aggiungi queste righe in fondo a build.gradle (dovrebbe essere un'app, non un progetto):

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

3. Fin qui tutto bene. Ecco il punto più importante:

Gradle deve accedere alla rete per dipendenze a meno che non sia abilitata la modalità offline.

Assicurati di aver abilitato il lavoro offline tramite la casella di controllo in Strutture di progetto / Grado

-- O --

Configurare le impostazioni del proxy per accedere alla rete.

Per configurare le impostazioni del proxy devi modificare il file gradle.properties del progetto , configurando separatamente http e https come di seguito:

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>

Spero che funzioni.

Attualmente fare riferimento a un file .aar locale non è supportato (come confermato da Xavier Ducrochet)

Quello che puoi fare invece è impostare un repository Maven locale (molto più semplice di quanto sembri) e fare riferimento al .aar da lì.

Ho scritto un post sul blog che spiega come farlo funzionare qui:

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

È possibile aggiungere più aardipendenze con solo poche righe di codice.

Aggiungi flatDirrepository locale :

repositories {
    flatDir {
        dirs 'libs'
    }
} 

Aggiungere tutti aarnella libsdirectory di compileconfigurazione di dipendenze:

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

Sfortunatamente nessuna delle soluzioni qui ha funzionato per me (ottengo dipendenze irrisolte). Quello che alla fine ha funzionato ed è il modo più semplice di IMHO: evidenzia il nome del progetto da Android Studio, quindi File -> Nuovo modulo -> Importa JAR o pacchetto AAR. Il merito va alla soluzione in questo post

Ci sono 2 modi:

Il primo modo

1. Apri Android Studio e vai alla Create New Modulefinestra diFile -> New -> New Module

2. Seleziona l' Import .JAR/.AAR Packageelemento e fai clic sul Nextpulsante

3. Aggiungi una dipendenza nel build.gradlefile che appartiene al tuo appmodulo.

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

È tutto.

Il secondo modo

1. Creare una cartella nella libsdirectory, ad esempio aars.

2. Metti la tua libreria aar nella cartella aars.

3. Aggiungi lo snippet di codice

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

nel tuo build.gradlefile appartiene al modulo dell'app.

4. Aggiungi una dipendenza nel build.gradlefile che appartiene al tuo appmodulo.

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

È tutto.

Se riesci a leggere il cinese, puoi controllare il blog 什么 是 AAR 文件 以及 如何 在 Android 开发 中 使用

Con Android Studio 3.4 e Gradle 5 puoi semplicemente farlo in questo modo

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

AGGIORNAMENTO STUDIO ANDROID 3.4

1. Vai a File -> Struttura del progetto

2. Moduli e fare clic su +

3. Seleziona Importa pacchetto .aar

4. Trova il percorso .aar

5. Termina e applica , quindi verifica se il pacchetto è stato aggiunto

6. Ora nel modulo dell'app, fai clic su + e Dipendenza dal modulo

7. Controlla il pacchetto della libreria e Ok

8. Verifica la dipendenza aggiunta

9. E la struttura del progetto in questo modo

Ho anche avuto questo problema. Segnala questo problema: https://code.google.com/p/android/issues/detail?id=55863 sembra suggerire che il riferimento diretto al file .AAR non sia supportato.

Forse l'alternativa per ora è definire la libreria actionbarsherlock come libreria Gradle nella directory principale del progetto e fare riferimento di conseguenza.

La sintassi è definita qui http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library

Ho trovato questa soluzione alternativa nel tracker dei problemi di Android: https://code.google.com/p/android/issues/detail?id=55863#c21

Il trucco (non una correzione) è isolare i tuoi file .aar in un sottoprogetto e aggiungere le tue librerie come artefatti:

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

Ulteriori informazioni: Gestione-dipendenze-transitive-per-manufatti-locali-barattoli-e-aar

Nel mio caso ho alcune dipendenze nella mia libreria e quando ne creo una aarho fallito, a causa di mancate dipendenze, quindi la mia soluzione è quella di aggiungere tutte le dipendenze dalla mia lib con un arrfile.

Quindi il mio livello di progetto build.gradlesembra così:

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) così:

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

e biblioteca 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
    ...
}

Ho provato tutte le soluzioni qui ma nessuna funziona, quindi mi rendo conto di aver fatto un errore, ho inserito la .aarcartella sbagliata, come puoi vedere di seguito, ho pensato che avrei dovuto mettere la cartella principale, quindi ho creato una libscartella lì (1 in figura ), ma all'interno della cartella dell'app, c'è già un libs, dovresti metterlo in secondo luogo libs, spero che questo aiuti quelli che hanno il mio stesso problema:

Viene fornito il modo standard per importare file AAR in un'applicazione https://developer.android.com/studio/projects/android-library.html#AddDependency

Fai clic su File> Nuovo> Nuovo modulo. Fare clic su Importa pacchetto .JAR / .AAR quindi fare clic su Avanti. Immettere il percorso del file AAR o JAR compilato, quindi fare clic su Fine.

Si prega di fare riferimento al link sopra per i passaggi successivi.

Solo per semplificare la risposta

Se il file .aar è presente localmente, includi
compile project(':project_directory')nelle dipendenze di build.gradle del tuo progetto.

Se il file .aar è presente in remoto, includi le compile 'com.*********.sdk:project_directory:0.0.1@aar'dipendenze di build.gradle del tuo progetto.

Nel mio caso lavoro solo quando aggiungo "progetto" per compilare:

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


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

puoi fare qualcosa del genere:

1. Metti le tue librerie locali (con estensione: .jar, .aar, ...) nella cartella 'libs' (o un'altra se vuoi).

2. In build.gradle (a livello di app), aggiungi questa riga nelle dipendenze

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