L'aggiunta di file .aar locali alla build Gradle usando "flatDirs" non funziona

Sono a conoscenza di questa domanda: aggiungere file .aar locali alla mia build gradle ma la soluzione non funziona per me.

Ho provato ad aggiungere questa affermazione al livello superiore del mio build.gradlefile:

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

Ho anche inserito il slidingmenu.aarfile /libse fatto riferimento nella dependenciessezione: compile 'com.slidingmenu.lib:slidingmenu:1.0.0@aar'ma non ha funzionato affatto.

Ci ho provato compile files('libs/slidingmenu.aar')anche ma senza fortuna.

Cosa mi sto perdendo? Qualche idea?

PS Android Studio 0.8.2

Basandomi sulla risposta di Josiah, ecco come l'ho fatta funzionare.

Seguendo le sue istruzioni (in modifica) ( File -> Nuovo-> Nuovo modulo -> Importa .JAR / .AAR ) e importa il tuo .AAR.

Quindi nel tuo progetto build.gradle (non quello di primo livello, quello sotto 'app') aggiungi quanto segue (nella sezione delle dipendenze):

dependencies {
    compile project(':Name-Of-Your-Project')
}

Nota Nome del progetto deve corrispondere al nome della cartella che è stata aggiunta dopo aver importato il file AAR (allo stesso livello app/.ideadella cartella più in alto). O per dirla in un altro modo ...

La mia applicazione
  .idea
  App
  build.gradle (ecco dove aggiungere il progetto di compilazione (': ProjectName') alla sezione delle dipendenze)
  ProjectName (aggiunto automaticamente dopo l'importazione, corrispondente al nome del file aar)
  costruire
  Gradle
  eccetera

Questo ha funzionato per me con Android Studio 0.8.0. Non dimenticare di sincronizzare il gradle (usando il pulsante della barra degli strumenti o in File-> Sincronizza ) dopo aver fatto questo.

(Grazie a Josiah per avermi fatto andare nella giusta direzione)

(Nota: prima di questo ho provato ad aggiungerlo alla cartella libs, provando a manipolare il livello superiore build.gradlee il livello dell'app build.gradle, ma nulla di tutto ciò ha funzionato per i miei file aars - jar's funzionerà bene, ma non i file aar)

Aggiornamento : Come accennato da @ amram99, il problema è stato risolto a partire dalla versione di Android Studio v1.3.

Testato e verificato con le specifiche seguenti

• Android Studio v1.3
• gradle plugin v1.2.3
• Grado v2.4

Cosa funziona adesso

• Ora puoi importare un file aar locale tramite l'opzione File> Nuovo> Nuovo modulo> Importa pacchetto .JAR / .AAR in Android Studio v1.3

• Tuttavia, la risposta che segue è vera ed efficace indipendentemente dalle modifiche di Android Studio poiché si basa su script graduali.

Vecchia risposta: in un recente aggiornamento, le persone su Android hanno interrotto l'inclusione dei file locali dell'aar tramite l'opzione di menu Aggiungi nuovo modulo di Android Studio. Controlla il problema elencato qui. Indipendentemente da tutto ciò che entra e esce dall'elenco delle funzionalità di IDE, il metodo seguente funziona quando si tratta di lavorare con file aar locali (testato oggi):

Metti il ​​file aar nella directory libs (crealo se necessario), quindi aggiungi il seguente codice nel tuo build.gradle:

dependencies {
   compile(name:'nameOfYourAARFileWithoutExtension', ext:'aar')
 }
repositories{
      flatDir{
              dirs 'libs'
       }
 }

Modifica: il modo corretto (attualmente) di utilizzare un file AAR locale come dipendenza di compilazione è utilizzare la procedura guidata di importazione del modulo (File | Nuovo modulo | Importa pacchetto .JAR o .AAR) che aggiungerà automaticamente .aar come modulo di libreria nel tuo progetto.

Vecchia risposta

Prova questo:

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

...

compile(name:'slidingmenu', ext:'aar')

Ho funzionato su Android Studio 2.1. Ho un modulo chiamato "Native_Ads" che è condiviso tra più progetti.

Innanzitutto, ho creato una directory nel mio modulo Native_ads con il nome 'aars' e quindi ho inserito il file aar.

Struttura di directory:

libs/
aars/    <-- newly created
src/
build.gradle
etc

Quindi, le altre modifiche:

File di livello superiore:

allprojects {
    repositories {
        jcenter()
        // For module with aar file in it
        flatDir {
            dirs project(':Native_Ads').file('aars')
        }
    }
}

File build.gradle del modulo app: - nessuna modifica

File Settings.gradle (per includere il modulo):

include ':app'
include 'Native_Ads'
project(':Native_Ads').projectDir = new File(rootProject.projectDir, '../path/to/Native_Ads')

File Gradle per il modulo Native_Ads:

repositories {
    jcenter()
    flatDir {
        dirs 'aars'
    }
}
dependencies {
    compile(name:'aar_file_name_without_aar_extension', ext:'aar')
}

Questo è tutto. Pulisci e costruisci.

Il modo più semplice ora è aggiungerlo come modulo

Questo creerà un nuovo modulo contenente il file aar, quindi dovrai solo includere quel modulo come dipendenza in seguito

Questa è la mia struttura e come la risolvo:

MyProject / app / libs / mylib-1.0.0.aar

MyProject / app / myModulesFolder / myLibXYZ

Su build.gradle

da Progetto / app / myModulesFolder / myLibXYZ

Ho messo questo:

repositories {
   flatDir {
    dirs 'libs', '../../libs'
  }
}
compile (name: 'mylib-1.0.0', ext: 'aar')

Fatto e funzionante, il mio sottomodulo XYZ dipende dalla somelibrary del modulo principale.

Puoi farlo in questo modo. Deve andare nel formato maven:

repositories {
  maven { url uri('folderName')}
}

E quindi l'AAR deve andare in una struttura di cartelle per un ID di gruppo "com.example":

folderName/
  com/
    example/
       verion/
          myaar-version.aar

Quindi fare riferimento come dipendenza:

compile 'com.example:myaar:version@aar'

Dov'è versionla versione del tuo file aar (cioè 3.0, ecc.)

Per chiunque abbia questo problema con Android Studio 1.4, l'ho fatto funzionare creando un modulo all'interno del progetto che contiene 2 cose.

1. build.gradle con i seguenti contenuti:

   configurations.create("default")

   artifacts.add("default", file('facebook-android-sdk-4.7.0.aar'))

2. il file aar (in questo esempio 'facebook-android-sdk-4.7.0.aar')

Quindi includere la nuova libreria come dipendenza del modulo. Ora puoi usare un aar incorporato senza includere le fonti all'interno del progetto.

Ringraziamo Facebook per questo trucco. Ho trovato la soluzione integrando l'SDK di Android in un progetto.

Nel mio caso nessuna delle risposte sopra ha funzionato! dal momento che ho appena aggiunto diversi gusti di prodottorepositories{ flatDir{ dirs 'libs' } }

non ha funzionato! Ho finito per specificare la posizione esatta della directory libs :

repositories{
flatDir{
    dirs 'src/main/libs'
}

}

Immagino che uno dovrebbe introdurre flatDir come questo quando ci sono diversi ProductFlavors in build.gradle

Nel mio caso, ho appena messo il file aar in libs e ho aggiunto

dependencies { ... api fileTree(dir: 'libs', include: ['*.aar']) ... }

in build.gradle e funziona. Penso che sia simile alla dipendenza generata di default:

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

Questa riga include tutto aare jarfile dalla libscartella:

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

Questa soluzione funziona con Android Studio 4.0.1.

Oltre a creare un nuovo modulo come suggerito nella soluzione sopra, puoi provare questa soluzione.

Se nell'applicazione sono presenti più moduli e si desidera aggiungere l'aar a uno solo dei moduli, questa soluzione è utile.

Nel tuo progetto di root build.gradle

Inserisci

repositories {
flatDir {
    dirs 'libs'
}}

Quindi nel modulo in cui si desidera aggiungere il file .aar localmente. aggiungi semplicemente sotto le righe di codice.

dependencies {
api fileTree(include: ['*.aar'], dir: 'libs')
implementation files('libs/<yourAarName>.aar')

}

Happy Coding :)

Aggiungi di seguito nel progetto di implementazione del file di livello app (percorso: ': nome progetto')

Se usi già Kotlin Gradle DSL, l'alternativa all'utilizzo in questo modo:

Ecco la mia struttura del progetto

|-root
|----- app
|--------- libs // I choose to store the aar here
|-------------- my-libs-01.aar
|-------------- my-libs-02.jar
|--------- build.gradle.kts // app module gradle
|----- common-libs // another aar folder/directory
|----------------- common-libs-01.aar
|----------------- common-libs-02.jar
|----- build.gradle.kts // root gradle

Mio app/build.gradle.kts

1. Utilizzando un approccio semplice con fileTree

// android related config above omitted...

dependencies {
    // you can do this to include everything in the both directory
    // Inside ./root/common-libs & ./root/app/libs
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
    implementation(fileTree(mapOf("dir" to "../common-libs", "include" to listOf("*.jar", "*.aar"))))
}

2. Utilizzando lo stesso approccio come il recupero dal repository Maven locale / remoto con flatDirs

// android related config above omitted...

repositories {
    flatDir {
        dirs = mutableSetOf(File("libs"), File("../common-libs") 
    }
}

dependencies {
   implementation(group = "", name = "my-libs-01", ext = "aar")
   implementation(group = "", name = "my-libs-02", ext = "jar")

   implementation(group = "", name = "common-libs-01", ext = "aar")
   implementation(group = "", name = "common-libs-02", ext = "jar")
}

L' groupera necessario, a causa della sua obbligatoria (/ non facoltativo ha valore di default) in Kotlin implementation, vedere sotto:

// Filename: ReleaseImplementationConfigurationAccessors.kt
package org.gradle.kotlin.dsl

fun DependencyHandler.`releaseImplementation`(
    group: String,
    name: String,
    version: String? = null,
    configuration: String? = null,
    classifier: String? = null,
    ext: String? = null,
    dependencyConfiguration: Action<ExternalModuleDependency>? = null
)

Disclaimer: la differenza con l' flatDirsapproccio n. 1 e n. 2, ancora non ne so molto, potresti voler modificare / commentare questa risposta.

Riferimenti:

1. https://stackoverflow.com/a/56828958/3763032
2. https://github.com/gradle/gradle/issues/9272

Questa soluzione funziona con Android Studio 4.0.1.

Oltre a creare un nuovo modulo come suggerito nella soluzione sopra, puoi provare questa soluzione.

Se nell'applicazione sono presenti più moduli e si desidera aggiungere l'aar a uno solo dei moduli, questa soluzione è utile.

Nel tuo progetto di root build.gradle

Inserisci

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

Quindi nel modulo in cui si desidera aggiungere il file .aar localmente. aggiungi semplicemente sotto le righe di codice.

dependencies {
api fileTree(include: ['*.aar'], dir: 'libs')
implementation files('libs/<yourAarName>.aar')

}

Happy Coding :)