L'ajout de fichiers .aar locaux à la compilation Gradle à l'aide de «flatDirs» ne fonctionne pas

Je suis conscient de cette question: ajouter des fichiers .aar locaux à ma version gradle mais la solution ne fonctionne pas pour moi.

J'ai essayé d'ajouter cette déclaration au niveau supérieur de mon build.gradlefichier:

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

J'ai également mis le slidingmenu.aarfichier /libset je l'ai référencé dans la dependenciessection: compile 'com.slidingmenu.lib:slidingmenu:1.0.0@aar'mais cela n'a pas fonctionné du tout.

J'ai essayé compile files('libs/slidingmenu.aar')aussi mais sans succès .

Qu'est-ce que je rate? Des idées?

PS Android Studio 0.8.2

Sur la base de la réponse de Josiah, voici comment je l'ai fait fonctionner.

Suivez ses instructions (en cours d'édition) ( Fichier -> Nouveau-> Nouveau module -> Importer .JAR / .AAR ) et importez votre .AAR.

Ensuite, dans votre projet build.gradle (pas celui de niveau supérieur, celui sous 'app'), ajoutez ce qui suit (dans la section des dépendances):

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

Remarque Name-Of-Your-Project doit correspondre au nom du dossier qui a été ajouté après l'importation du fichier AAR (au même niveau que app/.ideasous le dossier de niveau supérieur). Ou pour le dire autrement ...

Mon application
  .idée
  app
  build.gradle (voici où ajouter le projet de compilation (': ProjectName') à la section des dépendances)
  ProjectName (ajouté automatiquement après l'importation, correspondant au nom de votre fichier aar)
  construire
  gradle
  etc

Cela a fonctionné pour moi sous Android Studio 0.8.0. N'oubliez pas de synchroniser gradle (en utilisant le bouton de la barre d'outils ou dans Fichier-> Synchroniser ) après avoir fait cela.

(Merci à Josiah pour m'avoir poussé dans la bonne direction)

(Remarque: avant cela, j'ai essayé de l'ajouter au dossier libs, en essayant de manipuler le niveau supérieur build.gradleet le niveau de l'application build.gradle, mais rien de tout cela n'a fonctionné pour mes fichiers aars - les fichiers jar fonctionneront bien, mais pas les fichiers aar)

Mise à jour : comme @ amram99 l'a mentionné, le problème a été résolu depuis la sortie d'Android Studio v1.3.

Testé et vérifié avec les spécifications ci-dessous

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

Ce qui fonctionne maintenant

• Vous pouvez maintenant importer un fichier aar local via l' option Fichier> Nouveau> Nouveau module> Importer un package .JAR / .AAR dans Android Studio v1.3

• Cependant, la réponse ci-dessous est vraie et efficace quelles que soient les modifications d'Android Studio, car elles sont basées sur des scripts gradle.

Ancienne réponse: Dans une mise à jour récente, les gens d'Android ont interrompu l'inclusion de fichiers AAR locaux via l'option de menu Ajouter un nouveau module d'Android Studio. Vérifiez le problème répertorié ici. Indépendamment de tout ce qui entre et sort de la liste des fonctionnalités de l'EDI, la méthode ci-dessous fonctionne lorsqu'il s'agit de travailler avec des fichiers aar locaux (testée aujourd'hui):

Placez le fichier aar dans le répertoire libs (créez-le si nécessaire), puis ajoutez le code suivant dans votre build.gradle:

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

Modifier: La manière correcte (actuellement) d'utiliser un fichier AAR local comme dépendance de construction est d'utiliser l'assistant d'importation de module (Fichier | Nouveau module | Importer le package .JAR ou .AAR) qui ajoutera automatiquement le .aar en tant que module de bibliothèque dans votre projet.

Ancienne réponse

Essaye ça:

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

...

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

Je l'ai fait fonctionner sur Android Studio 2.1. J'ai un module appelé "Native_Ads" qui est partagé entre plusieurs projets.

Tout d'abord, j'ai créé un répertoire dans mon module Native_ads avec le nom «aars», puis j'ai mis le fichier aar là-dedans.

Structure du répertoire:

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

Ensuite, les autres changements:

Fichier Gradle de niveau supérieur:

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

Fichier build.gradle du module d'application: - aucun changement

Fichier Settings.gradle (pour inclure le module):

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

Fichier Gradle pour le module Native_Ads:

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

C'est tout. Nettoyez et construisez.

Le moyen le plus simple est maintenant de l'ajouter en tant que module

Cela créera un nouveau module contenant le fichier aar, il vous suffit donc d'inclure ce module en tant que dépendance par la suite

Voici ma structure et comment je résous ceci:

MonProjet / app / libs / mylib-1.0.0.aar

MyProject / app / myModulesFolder / myLibXYZ

Sur build.gradle

depuis Project / app / myModulesFolder / myLibXYZ

J'ai mis ceci:

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

Fait et fonctionne très bien, mon sous-module XYZ dépend de la bibliothèque du module principal.

Vous pouvez le faire de cette façon. Il doit être au format maven:

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

Et puis votre AAR doit aller dans une structure de dossiers pour un identifiant de groupe "com.example":

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

Puis référence en tant que dépendance:

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

Où versionest la version de votre fichier aar (c.-à-d., 3.0, etc.)

Pour tous ceux qui ont ce problème à partir d'Android Studio 1.4, je l'ai fait fonctionner en créant un module dans le projet qui contient 2 choses.

1. build.gradle avec le contenu suivant:

   configurations.create("default")

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

2. le fichier aar (dans cet exemple 'facebook-android-sdk-4.7.0.aar')

Incluez ensuite la nouvelle bibliothèque en tant que dépendance de module. Vous pouvez maintenant utiliser un aar intégré sans inclure les sources dans le projet.

Crédit à Facebook pour ce hack. J'ai trouvé la solution en intégrant le SDK Android dans un projet.

Dans mon cas, aucune des réponses ci-dessus n'a fonctionné! depuis que j'avais des produits différentsrepositories{ flatDir{ dirs 'libs' } }

n'a pas marché! J'ai fini par spécifier l'emplacement exact du répertoire libs :

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

}

Je suppose que l'on devrait introduire flatDirs comme celui-ci quand il y a différents productFlavors dans build.gradle

Dans mon cas, je viens de mettre le fichier aar dans les libs, et d'ajouter

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

dans build.gradle et cela fonctionne. Je pense que c'est similaire avec la dépendance générée par défaut:

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

Cette ligne comprend tous les fichiers aaret les jarfichiers du libsdossier:

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

Cette solution fonctionne avec Android Studio 4.0.1.

En plus de créer un nouveau module comme suggéré dans la solution ci-dessus, vous pouvez essayer cette solution.

Si vous avez plusieurs modules dans votre application et que vous souhaitez ajouter un aar à un seul module, cette solution est pratique.

Dans votre projet racine build.gradle

ajouter

repositories {
flatDir {
    dirs 'libs'
}}

Puis dans le module où vous souhaitez ajouter le fichier .aar localement. ajoutez simplement ci-dessous des lignes de code.

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

}

Bon codage :)

Ajouter ci-dessous dans le projet d'implémentation du fichier de gradle d'application (chemin: ': nom du projet')

Si vous utilisez déjà Kotlin Gradle DSL, l'alternative à l'utiliser de cette façon:

Voici ma structure de projet

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

ma app/build.gradle.kts

1. Utilisation d'une approche simple avec 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. En utilisant la même approche que la récupération à partir du référentiel maven local / distant avec 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")
}

Le groupétait nécessaire, en raison de son obligatoire (pas facultatif / a une valeur par défaut) dans kotlin implementation, voir ci-dessous:

// 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
)

Avertissement: La différence en utilisant l' flatDirsapproche n ° 1 et n ° 2, je ne sais toujours pas grand-chose, vous voudrez peut-être modifier / commenter cette réponse.

Références:

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

Cette solution fonctionne avec Android Studio 4.0.1.

En plus de créer un nouveau module comme suggéré dans la solution ci-dessus, vous pouvez essayer cette solution.

Si vous avez plusieurs modules dans votre application et que vous souhaitez ajouter un aar à un seul module, cette solution est pratique.

Dans votre projet racine build.gradle

ajouter

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

Puis dans le module où vous souhaitez ajouter le fichier .aar localement. ajoutez simplement ci-dessous des lignes de code.

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

}

Bon codage :)