Comment inclure manuellement un package aar externe à l'aide du nouveau système de construction Android Gradle

J'ai expérimenté avec le nouveau système de construction Android et j'ai rencontré un petit problème. J'ai compilé mon propre paquet aar d'ActionBarSherlock que j'ai appelé 'actionbarsherlock.aar'. Ce que j'essaie de faire, c'est d'utiliser cet aar pour construire mon APK final. Si j'inclus toute la bibliothèque ActionBarSherlock en tant que module de bibliothèque Android à mon projet principal en utilisant le projet de compilation (': actionbarsherlock'), je suis en mesure de construire avec succès sans aucun problème.

Mais mon problème est que je veux fournir cette dépendance en tant que package de fichiers aar manuellement si je veux un JAR, alors je n'arrive pas à comprendre comment l'inclure correctement dans mon projet. J'ai essayé d'utiliser la configuration de compilation, mais cela ne semble pas fonctionner. Je continue à ne pas trouver de symbole pendant la compilation, ce qui m'indique que le fichier classes.jar du package aar n'est pas inclus dans le chemin de classe.

Quelqu'un connaît-il la syntaxe pour inclure manuellement un package aar en tant que fichier?

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: Donc, la réponse est qu'il n'est pas actuellement pris en charge, voici le problème si vous souhaitez le suivre.

EDIT: Actuellement, comme cela n'est toujours pas pris en charge directement, la meilleure alternative semble être la solution proposée par @RanWakshlak

EDIT: Également plus simple en utilisant la syntaxe proposée par @VipulShah

Veuillez suivre les étapes ci-dessous pour le faire fonctionner (je l'ai testé jusqu'à Android Studio 2.2)

Disons que vous avez conservé un fichier aar dans le dossier libs. (supposez que le nom du fichier est cards.aar)

puis dans l'application, build.gradlespécifiez ce qui suit et cliquez sur le projet de synchronisation avec les fichiers Gradle. Ouvrez le niveau projet build.gradle et ajoutez flatDir{dirs 'libs'}comme ci-dessous

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

et maintenant ouvrir le fichier build.grdle au niveau de l'application et ajouter un .aarfichier

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

Si tout se passe bien, vous verrez que l'entrée de la bibliothèque est faite dans build -> exploded-aar

Notez également que si vous importez un fichier .aar à partir d'un autre projet qui a des dépendances, vous devrez également les inclure dans votre build.gradle.

1. Faites un clic droit sur votre projet et sélectionnez "Ouvrir les paramètres du module" .

2. Cliquez sur le bouton "+" dans le coin supérieur gauche de la fenêtre pour ajouter un nouveau module.

3. Sélectionnez "Importer un package .JAR ou .AAR" et cliquez sur le bouton "Suivant" .

4. Recherchez le fichier AAR à l'aide du bouton de sélection "..." à côté du champ "Nom de fichier".

5. Gardez le module de l'application sélectionné et cliquez sur le volet Dépendances pour ajouter le nouveau module en tant que dépendance.

6. Utilisez le bouton "+" de l'écran des dépendances et sélectionnez "Dépendance du module" .

7. Sélectionnez le module et cliquez sur "OK" .

Vous pouvez référencer un fichier aar à partir d'un référentiel. Un maven est une option, mais il existe une solution plus simple: mettez le fichier aar dans votre répertoire libs et ajoutez un référentiel de répertoire.

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

Référencez ensuite la bibliothèque dans la section des dépendances:

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

Vous pouvez consulter le blog Min'an pour plus d'informations.

L'approche ci-dessous fonctionne avec le dernier studio Android (> v0.8.x):

• Enregistrez le aarfichier sous du module app libsdossier (par exemple: <project>/<app>/libs/myaar.aar)

• Ajoutez ce qui suit à build.gradle de votre dossier de module "app" (pas à votre racine de projet build.gradle). Notez le nom dans la ligne de compilation, c'est myaar @ aar et non myaar.aar.

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

• Cliquez sur Tools -> Android -> Sync Project with Gradle Files

avant (par défaut)

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

il suffit d' ajouter '*.aar'au includetableau.

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

cela fonctionne bien sur Android Studio 3.x.

si vous voulez ignorer une bibliothèque? fait comme ça.

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

Je viens de réussir!

1. Copiez le fichier mylib-0.1.aar dans le dossier libs /

2. Ajoutez ces lignes au bas de build.gradle (devrait être une application, pas un projet):

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

3. Jusqu'ici tout va bien. Voici le point le plus important:

Gradle doit accéder au réseau pour les dépendances, sauf si le mode hors ligne est activé.

Assurez-vous que vous avez activé le travail hors ligne via la case à cocher dans Project Structures / Gradle

-- OU --

Configurez les paramètres du proxy pour accéder au réseau.

Pour configurer les paramètres du proxy, vous devez modifier le fichier gradle.properties du projet , en configurant séparément http et https comme ci-dessous:

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>

J'espère que cela fonctionne.

Le référencement actuel d'un fichier .aar local n'est pas pris en charge (comme confirmé par Xavier Ducrochet)

Ce que vous pouvez faire à la place est de configurer un référentiel Maven local (beaucoup plus simple qu'il n'y paraît) et de référencer le .aar à partir de là.

J'ai écrit un article de blog détaillant comment le faire fonctionner ici:

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

Vous pouvez ajouter plusieurs aardépendances avec seulement quelques lignes de code.

Ajouter un flatDirréférentiel local :

repositories {
    flatDir {
        dirs 'libs'
    }
} 

Ajoutez chaque répertoire aarin libsà compilela configuration des dépendances:

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

Malheureusement, aucune des solutions ici n'a fonctionné pour moi (j'obtiens des dépendances non résolues). Ce qui a finalement fonctionné et est le moyen le plus simple à mon humble avis est: Mettez en surbrillance le nom du projet à partir d'Android Studio puis Fichier -> Nouveau module -> Importer le package JAR ou AAR. Le mérite revient à la solution dans cet article

Il y a 2 façons:

La première façon

1. Ouvrez votre Android Studio et accédez à la Create New Modulefenêtre enFile -> New -> New Module

2. Sélectionnez l' Import .JAR/.AAR Packageélément et cliquez sur le Nextbouton

3. Ajoutez une dépendance dans le build.gradlefichier qui appartient à votre appmodule.

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

C'est tout.

La deuxième voie

1. Créez un dossier dans le libsrépertoire, tel que aars.

2. Mettez votre bibliothèque aar dans le dossier aars.

3. Ajouter l'extrait de code

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

dans votre build.gradlefichier appartient au module d'application.

4. Ajoutez une dépendance dans le build.gradlefichier qui appartient à votre appmodule.

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

C'est tout.

Si vous pouvez lire le chinois, vous pouvez consulter le blog 什么 是 AAR 文件 以及 如何 在 Android 开发 中 使用

Avec Android Studio 3.4 et Gradle 5, vous pouvez simplement le faire comme ceci

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

METTRE À JOUR ANDROID STUDIO 3.4

1. Allez dans Fichier -> Structure du projet

2. Modules et cliquez sur +

3. Sélectionnez Importer un package .aar

4. Trouver la route .aar

5. Terminer et appliquer , puis vérifier si le package est ajouté

6. Maintenant, dans le module d'application, cliquez sur + et la dépendance du module

7. Vérifiez le package de la bibliothèque et OK

8. Vérifiez la dépendance ajoutée

9. Et la structure du projet comme ça

J'ai également eu ce problème. Ce rapport de problème: https://code.google.com/p/android/issues/detail?id=55863 semble suggérer que le référencement direct du fichier .AAR n'est pas pris en charge.

Peut-être que l'alternative pour l'instant est de définir la bibliothèque actionbarsherlock comme une bibliothèque Gradle sous le répertoire parent de votre projet et de la référencer en conséquence.

La syntaxe est définie ici http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library

J'ai trouvé cette solution de contournement dans le suivi des problèmes Android: https://code.google.com/p/android/issues/detail?id=55863#c21

L'astuce (pas un correctif) consiste à isoler vos fichiers .aar dans un sous-projet et à ajouter vos bibliothèques en tant qu'artéfacts:

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

Plus d'informations: Gestion des dépendances transitives pour les artefacts-locaux-pots-et-aar

Dans mon cas, j'ai des dépendances dans ma bibliothèque et quand j'en crée une à aarpartir de celle-ci, j'ai échoué, à cause de dépendances manquées, donc ma solution est d'ajouter toutes les dépendances de ma bibliothèque avec un arrfichier.

Donc, mon niveau de projet build.gradleressemble à ceci:

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) donc:

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

et bibliothèque 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
    ...
}

J'ai essayé toutes les solutions ici mais aucune ne fonctionne, puis je me rends compte que j'ai fait une erreur, j'ai mis le .aarmauvais dossier, comme vous pouvez le voir ci-dessous, j'ai pensé que je devrais mettre dans le dossier racine, alors j'ai créé un libsdossier là-bas (1 dans l'image ), mais dans le dossier de l'application, il y a déjà un libs, vous devriez le mettre en second lieu libs, j'espère que cela aidera ceux qui ont le même problème que le mien:

La manière standard d'importer un fichier AAR dans une application est donnée dans https://developer.android.com/studio/projects/android-library.html#AddDependency

Cliquez sur Fichier> Nouveau> Nouveau module. Cliquez sur Importer le package .JAR / .AAR, puis sur Suivant. Entrez l'emplacement du fichier AAR ou JAR compilé, puis cliquez sur Terminer.

Veuillez consulter le lien ci-dessus pour les prochaines étapes.

Simplement pour simplifier la réponse

Si le fichier .aar est présent localement, incluez-le
compile project(':project_directory')dans les dépendances de build.gradle de votre projet.

Si le fichier .aar est présent à distance, incluez-le compile 'com.*********.sdk:project_directory:0.0.1@aar'dans les dépendances de build.gradle de votre projet.

Dans mon cas, il suffit de travailler lorsque j'ajoute "projet" pour compiler:

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


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

vous pouvez faire quelque chose comme ça:

1. Mettez vos bibliothèques locales (avec l'extension: .jar, .aar, ...) dans le dossier 'libs' (ou un autre si vous le souhaitez).

2. Dans build.gradle (niveau application), ajoutez cette ligne dans les dépendances

   fileTree d'implémentation (inclure: ['* .jar', '* .aar'], dir: 'libs')