Jak ręcznie dołączyć zewnętrzny pakiet aar za pomocą nowego systemu kompilacji Gradle Android

Eksperymentowałem z nowym systemem kompilacji Androida i napotkałem mały problem. Skompilowałem własny pakiet aar ActionBarSherlock, który nazwałem „actionbarsherlock.aar”. To, co próbuję zrobić, to użyć tego aar do zbudowania mojego końcowego pakietu APK. Jeśli dołączę całą bibliotekę ActionBarSherlock jako moduł biblioteki Androida do mojego głównego projektu za pomocą projektu kompilacji („: actionbarsherlock”), będę mógł bez problemu zbudować pomyślnie.

Ale moim problemem jest to, że chcę zapewnić tę zależność jako pakiet plików AAR RĘCZNIE, tylko gdybym zrobił JAR, to nie wydaje mi się, aby wymyślić, jak poprawnie włączyć go do mojego projektu. Próbowałem użyć konfiguracji kompilacji, ale wydaje się, że to nie działa. Ciągle nie mogę znaleźć symbolu podczas kompilacji, co mówi mi, że plik klas.jar z pakietu aar nie jest uwzględniany w ścieżce klasy.

Czy ktoś wie o składni, aby ręcznie dołączyć pakiet aar jako plik?

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

EDYCJA: Więc odpowiedź jest taka, że ​​obecnie nie jest obsługiwana, oto problem, jeśli chcesz go śledzić.

EDYCJA: Obecnie, ponieważ nie jest to bezpośrednio obsługiwane, najlepszą alternatywą wydaje się proponowane rozwiązanie z @RanWakshlak

EDYCJA: Również prostsza przy użyciu składni zaproponowanej przez @VipulShah

Wykonaj poniższe kroki, aby go uruchomić (przetestowałem go do wersji Android Studio 2.2)

Powiedzmy, że trzymałeś plik AAR w folderze libs. (załóż, że nazwa pliku to cards.aar)

następnie w aplikacji build.gradleokreśl następujące i kliknij zsynchronizuj projekt z plikami Gradle. Otwórz build.gradle na poziomie projektu i dodaj flatDir{dirs 'libs'}tak jak poniżej

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

a teraz otwórz plik build.grdle na poziomie aplikacji i dodaj .aarplik

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

Jeśli wszystko pójdzie dobrze, zobaczysz, że wpis do biblioteki jest wykonywany w build -> exploded-aar

Pamiętaj również, że jeśli importujesz plik .aar z innego projektu, który ma zależności, musisz je również uwzględnić w pliku build.gradle.

1. Kliknij projekt prawym przyciskiem myszy i wybierz „Otwórz ustawienia modułu” .

2. Kliknij przycisk „+” w lewym górnym rogu okna, aby dodać nowy moduł.

3. Wybierz „Importuj .JAR lub .AAR Package” i kliknij przycisk „Dalej” .

4. Znajdź plik AAR za pomocą przycisku wielokropka „...” obok pola „Nazwa pliku”.

5. Pozostaw wybrany moduł aplikacji i kliknij panel Zależności, aby dodać nowy moduł jako zależność.

6. Użyj przycisku „+” na ekranie zależności i wybierz „Zależność modułu” .

7. Wybierz moduł i kliknij „OK” .

Możesz odwołać się do pliku AAR z repozytorium. Maven jest opcją, ale istnieje prostsze rozwiązanie: umieść plik aar w katalogu libs i dodaj repozytorium katalogów.

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

Następnie odwołaj się do biblioteki w sekcji zależności:

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

Więcej informacji można znaleźć na blogu Min'an .

Poniższe podejście działa z najnowszym Android studio (> v0.8.x):

• Zapisz aarplik w libsfolderze modułu aplikacji (np . <project>/<app>/libs/myaar.aar:)

• Dodaj poniżej plik build.gradle do folderu modułu „app” (nie do katalogu głównego build.gradle projektu). Zanotuj nazwę w wierszu kompilacji, myaar @ aar nie myaar.aar.

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

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

przed (domyślnie)

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

wystarczy dodać '*.aar'w includetablicy.

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

działa dobrze na Android Studio 3.x.

jeśli chcesz zignorować bibliotekę? rób jak to.

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

Właśnie mi się udało!

1. Skopiuj plik mylib-0.1.aar do folderu libs /

2. Dodaj te wiersze na dole build.gradle (powinna to być aplikacja, a nie projekt):

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

3. Na razie w porządku. Oto najważniejszy punkt:

Gradle musi uzyskać dostęp do sieci w celu uzyskania zależności, chyba że tryb offline jest włączony.

Upewnij się, że masz włączoną pracę offline za pomocą pola wyboru w Strukturach projektu / Gradade

- LUB -

Skonfiguruj ustawienia proxy , aby uzyskać dostęp do sieci.

Aby skonfigurować ustawienia proxy, musisz zmodyfikować plik gradle.properties projektu , konfigurując HTTP i https osobno, jak poniżej:

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>

Mam nadzieję, że to zadziała.

Obecnie odwołanie do lokalnego pliku .aar nie jest obsługiwane (co potwierdził Xavier Ducrochet)

Zamiast tego możesz skonfigurować lokalne repozytorium Maven (o wiele prostsze niż się wydaje) i stamtąd odwołać się do pliku .aar.

Napisałem post na blogu, w którym szczegółowo opisuję, jak to działa:

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

Możesz dodać wiele aarzależności za pomocą zaledwie kilku wierszy kodu.

Dodaj lokalne flatDirrepozytorium:

repositories {
    flatDir {
        dirs 'libs'
    }
} 

Dodaj każdy aarw libskatalogu do compilekonfiguracji zależności:

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

Niestety żadne z rozwiązań tutaj nie zadziałało (dostaję nierozwiązane zależności). To, co w końcu działało i jest najłatwiejszym sposobem IMHO: Podświetl nazwę projektu z Android Studio, a następnie Plik -> Nowy moduł -> Importuj pakiet JAR lub AAR. Kredyt trafia do rozwiązania w tym poście

Istnieją 2 sposoby:

Pierwszy sposób

1. Otwórz Android Studio i przejdź do Create New Moduleokna przezFile -> New -> New Module

2. Wybierz Import .JAR/.AAR Packageelement i kliknij Nextprzycisk

3. Dodaj zależność w build.gradlepliku należącym do appmodułu.

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

To wszystko.

Drugi sposób

1. Utwórz folder w libskatalogu, np aars.

2. Umieść swoją bibliotekę aar lib w folderze aars.

3. Dodaj fragment kodu

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

do build.gradlepliku należy do modułu aplikacji.

4. Dodaj zależność w build.gradlepliku należącym do appmodułu.

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

To wszystko.

Jeśli umiesz czytać po chińsku, możesz sprawdzić blog 在 是 AAR 文件 以及 如何 在 Android 开发 中 使用

W Android Studio 3.4 i Gradle 5 możesz to po prostu zrobić w ten sposób

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

AKTUALIZACJA STUDIO ANDROIDA 3.4

1. Przejdź do Plik -> Struktura projektu

2. Moduły i kliknij +

3. Wybierz opcję Importuj pakiet .aar

4. Znajdź trasę .aar

5. Zakończ i zastosuj , a następnie sprawdź, czy pakiet został dodany

6. Teraz w module aplikacji kliknij + i Zależność modułu

7. Sprawdź pakiet biblioteki i OK

8. Sprawdź dodaną zależność

9. I taka struktura projektu

Też miałem ten problem. Ten raport o problemie: https://code.google.com/p/android/issues/detail?id=55863 wydaje się sugerować, że bezpośrednie odwoływanie się do pliku .AAR nie jest obsługiwane.

Być może alternatywą jest na razie zdefiniowanie biblioteki actionbarsherlock jako biblioteki Gradle w katalogu nadrzędnym projektu i odpowiednie odniesienie.

Składnia jest zdefiniowana tutaj http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library

Znalazłem to obejście w narzędziu do śledzenia problemów Androida: https://code.google.com/p/android/issues/detail?id=55863#c21

Sztuką (a nie poprawką) jest izolowanie plików .aar w podprojekt i dodawanie bibliotek lib jako artefaktów:

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

Więcej informacji: Obsługa-przechodnie-zależności-dla-lokalnych-artefaktów-słoików-i-aar

W moim przypadku mam pewne depresje w swojej bibliotece, a kiedy utworzyłem aarz niego, nie udało mi się, z powodu pominiętych depresji, więc moim rozwiązaniem jest dodanie wszystkich depencji z mojej bibliotekiarr pliku.

Mój poziom projektu build.gradlewygląda więc tak:

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) więc:

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

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

Wypróbowałem tutaj wszystkie rozwiązania, ale żadne nie działa, ale zdaję sobie sprawę, że popełniłem błąd, umieściłem .aarniewłaściwy folder, jak widać poniżej, pomyślałem, że powinienem umieścić w folderze głównym, więc utworzyłem tam libsfolder (1 na zdjęciu ), ale w folderze aplikacji jest już libs, powinieneś umieścić na drugim miejscu libs, mam nadzieję, że pomoże to tym, którzy mają ten sam problem co mój:

Standardowy sposób importowania pliku AAR w aplikacji podano w https://developer.android.com/studio/projects/android-library.html#AddDependency

Kliknij opcję Plik> Nowy> Nowy moduł. Kliknij opcję Importuj pakiet .JAR / .AAR, a następnie kliknij przycisk Dalej. Wprowadź lokalizację skompilowanego pliku AAR lub JAR, a następnie kliknij przycisk Zakończ.

Dalsze kroki można znaleźć w powyższym linku.

Aby uprościć odpowiedź

Jeśli plik .aar jest lokalnie obecny, uwzględnij go
compile project(':project_directory')w zależnościach build.gradle twojego projektu.

Jeśli plik .aar jest obecny na zdalnym poziomie, uwzględnij compile 'com.*********.sdk:project_directory:0.0.1@aar'w zależności build.gradle twojego projektu.

W moim przypadku po prostu działaj, gdy dodam „projekt” do kompilacji:

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


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

możesz zrobić coś takiego:

1. Umieść swoje biblioteki lokalne (z rozszerzeniem: .jar, .aar, ...) w folderze „libs” (lub innym, jeśli chcesz).

2. W build.gradle (poziom aplikacji) dodaj tę linię do zależności

   plik implementacyjny Drzewo (obejmują: ['* .jar', '* .aar'], reż: 'libs')