Android Studio: ¿Agregar jar como biblioteca?

1027

Estoy tratando de usar el nuevo Android Studio pero parece que no puedo hacerlo funcionar correctamente.

Estoy usando la biblioteca Gson para serializar / deserializar objetos JSON. Pero la biblioteca de alguna manera no está incluida en la compilación.

Había creado un nuevo proyecto con solo una actividad principal . Copiado GSON-2.2.3.jar en el / libs carpeta y añaden como una dependencia de la biblioteca (click-derecho> Agregar como biblioteca). Esto incluye el jar en el estudio de Android para que pueda ser referenciado desde los archivos fuente.

Cuando intento ejecutar el proyecto, no se puede compilar, así que agregué:

compile files('libs/gson-2.2.3.jar')

a las dependencias en el archivo .gradle. Después de eso se compila correctamente, pero cuando ejecuto la aplicación obtengo un ClassDefNotFoundException.

¿Alguien sabe lo que estoy haciendo mal?

Ozzie
fuente
Consulte: stackoverflow.com/a/6859020/28557
Vinayak Bevinakatti el
1
Aunque esto no resuelve el problema, solo quiero señalar que "compilar" fue desaprobado en favor de "implementación".
Amir Rezazadeh

Respuestas:

1535

He estado luchando con lo mismo durante muchas horas, intentando que el tarro Gson no funcione menos. Finalmente lo descifré, aquí están los pasos que tomé:

  1. Ponga el tarro de Gson (en mi caso gson-2.2.4.jar) en la libscarpeta
  2. Haga clic derecho y presione 'Agregar como biblioteca'
  3. Asegúrese de que compile files('libs/gson-2.2.4.jar')esté en su build.gradlearchivo (o compile fileTree(dir: 'libs', include: '*.jar')si está utilizando muchos archivos jar)

    Editar: Usar implementation files('libs/gson-2.2.4.jar')(o implementation fileTree(dir: 'libs', include: '*.jar')) en Android Studio 3.0+

  4. Realice una compilación limpia (probablemente pueda hacerlo bien en Android Studio, pero para asegurarse de que navegué en un terminal a la carpeta raíz de mi aplicación y escribí gradlew clean. Estoy en Mac OS X, el comando puede ser diferente en su sistema

Después de hacer los cuatro anteriores, comenzó a funcionar bien. Creo que el paso 'Agregar como biblioteca' fue el que me había perdido anteriormente, y tampoco funcionó hasta que lo limpié.

[Editar - agregó el build.gradlepaso que también es necesario como otros han señalado]

lepoetemaudit
fuente
66
Gradlew Clean también me ayudó. ¡Muchas gracias!
František Žiačik
172
Si no desea tener que agregar explícitamente una línea para cada archivo jar: compile fileTree(dir: 'libs', include: '*.jar')
J c
65
Recomendaría aprovechar la gestión de dependencia transitoria de gradle y descargar gson de mavenCentral () (si se requiere una conexión a Internet. Simplemente agregue repositories { mavenCentral() }y reemplace su compile files(...)línea con compile 'com.google.code.gson:gson:2.2.4'y gradle descargará y administrará automáticamente el archivo jar por usted. Esto le permite a SCM rastrear solo archivos de código fuente y no bibliotecas.
Joe
38
No obtengo la opción Agregar como biblioteca en el paso 2.
Yster
66
En Android Studio 1.0.2, los pasos 2 y 3 no son necesarios porque esta línea ya está en el valor predeterminado build.gradle: compilar fileTree (dir: 'libs', incluir: ['* .jar'])
Brian Marick el
268

Estas son las instrucciones para agregar un archivo jar local como biblioteca a un módulo:

  1. Cree una carpeta 'libs' en el nivel superior del directorio del módulo (el mismo directorio que contiene el directorio 'src')

  2. En el build.gradle fileagregar lo siguiente para que su cierre de dependencias tenga:

    dependencies {
        // ... other dependencies
        compile files('libs/<your jar's name here>')
    }
    
  3. Android Studio ya debería haber configurado un contenedor gradlew. Desde la línea de comando, navegue hasta el nivel superior de su proyecto (el directorio que tiene un gradlewarchivo).

    Ejecutar ./gradlew assemble. Esto debería compilar el proyecto con la biblioteca. Es posible que deba corregir errores en su archivo build.gradle según sea necesario.

  4. Para que Android Studio reconozca los archivos jar locales como bibliotecas para soporte mientras codifica en el IDE, debe seguir algunos pasos más:

    4.1. Haga clic derecho en el módulo en el panel izquierdo y elija Open Library Settings.

    4.2. En el panel izquierdo del cuadro de diálogo, elija Libraries.

    4.3. Haga clic en el +signo sobre el panel segundo desde la izquierda ->Java

    Menú

    4.4. Seleccione su jar local y agréguelo al proyecto.

  5. Es posible que deba ejecutar el ./gradlewcomando anterior una vez más

ZenBalance
fuente
Esto funcionó para mí. Tengo Android Studio versión 1.2 Build 141.1890965, en Ubuntu. ¿Por qué dices "a partir de Android Studio 2.5"? ¿Es una versión diferente en Windows / Mac? (1a) Encontrar esto fue difícil. El cuadro combinado está en la parte superior izquierda del área de estructura del proyecto. Debe seleccionar "Proyecto" en lugar de "Android" y expandir la "aplicación". (1b) No apareció la opción "agregar", pero "Pegar" funcionó. (2) Tenía una línea "compile fileTree (dir: 'libs', include: ['* .jar'])", pero aún tenía que agregar su línea única explícita. (4, 5) no es necesario una vez (3) hecho con éxito. ¡Gracias!
Phil Freihofner
"el panel de la izquierda"? ¿Te refieres al panel del proyecto? Podría estar en cualquier lugar ... Con Android 2.3.3 Estudio no puedo encontrar Configuración de la biblioteca, pero la adición de la jarra para Dependencias en Ajustes del módulo parece ser el mismo ...
La increíble Ene
para mac, si no tiene gradle: $ brew instale gradle si obtiene "./gradlew: permiso denegado", necesita ejecutar $ chmod 755 gradlew. Luego puede ejecutar $ ./gradlew assemble
Azkario Rizky
110

En el proyecto haz clic derecho

-> new -> module
-> import jar/AAR package
-> import select the jar file to import
-> click ok -> done

Siga las capturas de pantalla a continuación:

1:

Paso 1

2:

ingrese la descripción de la imagen aquí

3:

ingrese la descripción de la imagen aquí

Verás esto:

ingrese la descripción de la imagen aquí

Ganesh Pandey
fuente
@CamConnor, también lo creo. Otras respuestas están desactualizadas
Ganesh Pandey
Esta es LA respuesta
Alessandro el
44
Pero no se reconoce como libraray. Por ejemplo, editor de estudio andriod: intente importar un paquete en el jar importado, no reconocido.
Dave
No se pudo encontrar una forma de eliminar el módulo importado de esta manera.
Dave
¿Por qué debería usar este método de agregar jar externo y no las otras respuestas del método de carpeta "copy-jar-to-libs"?
Eido95
48

En Android Stuido, me gusta usar Gradle para administrar Gson lib.

Agregue la dependencia a continuación en su archivo build.gradle.

repositories {mavenCentral()}

dependencies {compile 'com.google.code.gson:gson:2.2.4'}

Todo está bien.

También puedes ver esta publicación. La mejor manera de integrar la biblioteca de terceros en el estudio de Android

saneryee
fuente
Este método es el mejor porque está usando Maven.
Gary Drocella
1
Solo recuerde actualizar el número de versión a la última :) A partir de ahora es 2.3.1, pero revise el enlace
Kitalda
47

IIRC, simplemente usando "Agregar como biblioteca" no es suficiente para que se compile con el proyecto.

Consulte la ayuda de Intellij sobre cómo agregar bibliotecas a un proyecto

La parte que más le interesará es esta:

(En File > Project Structure) Abra la configuración del módulo y seleccione la pestaña Dependencias.

En la pestaña Dependencias, haga clic en Agregar y seleccione Biblioteca.

En el cuadro de diálogo Elegir bibliotecas, seleccione una o más bibliotecas y haga clic en Agregar seleccionado.

Si la biblioteca no aparece en el cuadro de diálogo, agréguela en la configuración de Bibliotecas, justo debajo de Módulos.

No debería necesitar agregar compile files()más, y la biblioteca debería agregarse correctamente a su proyecto.

Jukurrpa
fuente
Agregar como biblioteca ya agrega el jar de la misma manera. Entonces creo que el resultado es el mismo. Lo intentaré más tarde.
Ozzie
Agregar como biblioteca hace esto con éxito - Estoy en el mismo bote que tú Ozzie - EXACTO el mismo problema.
Jonás H.
Bien, pensé que Agregar como biblioteca solo lo agregaba a la lista de bibliotecas y no lo agregaba a las dependencias del módulo.
Jukurrpa
Cuando intenté esto, descubrí que sí agregaba las líneas de los archivos de compilación () a mi archivo build.gradle, pero parecía usar rutas absolutas a las bibliotecas (/libs/foo.jar). Los cambio a rutas relativas (libs / foo.jar), lo que me solucionó el problema.
Matt Holgate
40

Todas estas soluciones están desactualizadas. Es realmente fácil ahora en Android Studio:

Archivo> Nuevo módulo ...

La siguiente pantalla se ve extraña, como si estuviera seleccionando algún widget o algo, pero manténgalo en la primera imagen y debajo del desplazamiento y busque "Importar paquete JAR o .AAR"

Luego tome Project Structuredel menú Archivo. Seleccione appde la ventana abierta, luego seleccione dependencies, luego presione green plus button, seleccione y module dependencyluego seleccione el módulo que importó, luego presioneOK

Helzgate
fuente
Creo que usar maven aún sería la mejor solución, especialmente para proyectos a gran escala, es decir, proporcionada por saneryee.
Gary Drocella
2
Incluso esto parece estar desactualizado. Simplemente coloque su archivo .jar en su directorio "libs" y se compilará automáticamente a su proyecto. Ya hay una configuración de regla predeterminada en Android Studio 1.4 para incluir todos los archivos * .jar del directorio "libs".
Daniele Testa
35

Pasos sencillos para agregar una biblioteca externa en Android Studio

  1. Si está en la vista de Android en el explorador de proyectos, cámbielo a la vista de proyectos como se muestra a continuación

ingrese la descripción de la imagen aquí

  1. Haga clic derecho en el módulo deseado donde desea agregar la biblioteca externa, luego seleccione Nuevo> Directroy y asígnele el nombre ' libs '
  2. Ahora copie el blah_blah.jar en la carpeta ' libs '
  3. Haga clic derecho en blah_blah.jar, luego seleccione ' Agregar como biblioteca ... '. Esto agregará automáticamente una entrada en build.gradle como archivos de compilación ('libs / blah_blah.jar') y sincronizará el gradle. Y ya terminaste

Tenga en cuenta: si está utilizando bibliotecas de terceros, entonces es mejor usar dependencias donde el script Gradle descarga automáticamente el JAR y el JAR de dependencia cuando se ejecuta el script gradle.

Ej: compile 'com.google.android.gms: play-services-ads: 9.4.0'

Leer más sobre Gradle Dependency Mangement

Vinayak Bevinakatti
fuente
34

'compilar archivos ...' solía funcionar para mí, pero ya no. después de mucho dolor, descubrí que usar esto en su lugar funciona:

compile fileTree(dir: 'libs', include: '*.jar')

No tengo idea de por qué eso marcó la diferencia, pero, al menos, la maldita cosa está funcionando ahora.

usuario2084396
fuente
1
Esto funciona para mí, sin embargo, recientemente encontrado, a veces AS no recoge jarras nuevas / actualizadas hasta que realiza una sincronización de Gradle.
scottyab
Solo recuerde que "compilar" fue desaprobado en favor de "implementación".
Amir Rezazadeh
17
  1. Descargar el archivo de la Biblioteca del sitio web
  2. Copiar desde Windows explorar
  3. Pegar a la carpeta lib desde Project Explorer
  4. Ctrl+ Alt+ Shift+ Sestructura abierta del proyecto
  5. Seleccione la pestaña Dependencias, agregue el archivo usando +
  6. Barra de herramientas Sincronizar proyecto con archivo gradle usando el botón

Eso resolvió mi problema. Intenta, si alguien quiere más detalles, házmelo saber.

sansalk
fuente
17

Lo hice funcionar simplemente agregando una línea a build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar']) ----> AS creates this
    implementation 'com.google.code.gson:gson:2.3.1'   ----------> I added this one
}

No olvides hacer clic Sync nowen la esquina superior derecha.

Estoy usando Android Studio 1.0.1.

Fergara
fuente
¿Podría elaborar sobre lo que hace la fileTreelínea?
Thufir
13

Encontré a Dependency Manager de Android Studio bastante útil y poderoso para administrar dependencias de terceros (como gson mencionado aquí). Proporcionar una guía paso a paso que funcionó para mí (NOTA: Estos pasos se prueban para Android Studio 1.6 y versiones posteriores en la plataforma Windows).

Paso 1: Ir a "Construir> Editar bibliotecas y dependencias ..." abriría el cuadro de diálogo "Estructura del proyecto"

ingrese la descripción de la imagen aquí

Paso 2: Seleccione "aplicación" y luego seleccione la pestaña "Dependencias". Luego seleccione "Agregar> 1 dependencia de biblioteca"

ingrese la descripción de la imagen aquí

Paso 3: se mostrará el cuadro de diálogo "Elegir dependencia de biblioteca", especifique "gson" en la búsqueda y presione el "botón de búsqueda"

ingrese la descripción de la imagen aquí

Paso 4: la dependencia deseada se mostraría en la lista de búsqueda, seleccione com.google.code.gson: gson: 2.7 (esta es la última versión en el momento en que escribí la respuesta), presione OK

ingrese la descripción de la imagen aquí

Presione OK en el cuadro de diálogo "Estructura del proyecto". Gradle actualizaría sus scripts de compilación en consecuencia.

ingrese la descripción de la imagen aquí

Espero que esto ayude :)

AB
fuente
He encontrado algún problema con este enfoque, he estado trabajando en una aplicación que usa commons-io-2.5. Cuando cargó la aplicación en Google Developer Console, muestra 0 dispositivos compatibles con el apk firmado. Después de una investigación exhaustiva, descubrí que tengo que colocar el archivo jar en app / libs / commons-io-2.5.jar y actualizar las dependencias en gralde como este 'compilar archivos (' libs / commons-io-2.5.jar ') ', no estoy seguro de lo que he estado haciendo mal aquí y por qué la documentación no cubre esto.
AB
Esta es la forma en que funciona. Todas las otras respuestas no funcionaron. Android Studio 2.3.3
imsrgadich
11

1. Coloque el jar (en mi caso gson-2.2.4.jar) en la carpeta libs.

2. Asegúrese de que los archivos de compilación ( libs/gson-2.2.4.jar) estén en su archivo build.gradle.

3. Ahora haga clic en "Sincronizar proyecto con archivos Gradle" (botón de izquierda a administrador AVD en la barra superior).

Después de hacer los tres anteriores, comenzó a funcionar bien.

Sandeep
fuente
9

Descargue y copie su .jararchivo en la libscarpeta y luego agregue estas líneas a build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.code.gson:gson:2.3.1'
}

No olvides hacer clic en "Sincronizar ahora"

NarenderNishad
fuente
9

Puedes hacer esto con dos opciones.

primera forma simple

Copie el archivo .jar en el portapapeles y luego agréguelo a la carpeta libs. Para ver la carpeta libs en el proyecto, elija el proyecto desde el cuadro combinado arriba de las carpetas.

luego haga clic derecho en el archivo .jar y haga clic en agregar como biblioteca, luego elija un módulo y luego ok. Puede ver el archivo .jar en el archivo build.gradle dentro del bloque de dependencias.

 dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'com.android.support:appcompat-v7:21.0.3'
        implementation project(':okhttp-2.0.0')
        implementation 'com.google.code.gson:gson:2.3.1'
    }

La segunda forma es eso: podemos agregar un archivo .jar a un módulo importando este archivo .jar como módulo .jar y luego agregar este módulo a cualquier módulo que queramos.

módulo de importación ---> elija su archivo .jar -> que importar como .jar - ingrese la descripción de la imagen aquí

Luego, CTRL + ALT + MAYÚS + S -> proyecto sturure -> elija el módulo que desea para agregar un jar -> Dependencendies -> Module Dependency. build.gradle del módulo se actualizará automáticamente. ingrese la descripción de la imagen aquí

huseyin
fuente
Agradable. una edición: ahora es "Nuevo módulo" (Android Studio 1.0.1). "Módulo de importación" lo envía a un asistente diferente ..
Aviv Ben Shabat
7

He hecho más de 3 pasos y su encanto de trabajo para mí.

(Estoy usando Android Studio 2.1.2)

ingrese la descripción de la imagen aquí

Paso 1

  • Agregue el nombre del paquete jar (como ejemplo compile 'com.squareup.okhttp3:okhttp:3.3.1') en el script de construcción de gradle en build.gradle (Módulo: aplicación) .

ingrese la descripción de la imagen aquí

Paso 2: haga clic derecho en la carpeta de la aplicación -> Nuevo -> Módulo

ingrese la descripción de la imagen aquí

Paso 3: haga clic en Importar paquete JAR / .AAR Luego busque su paquete. como ejemplo: OkHttp.jar

ingrese la descripción de la imagen aquí

Elshan
fuente
7

Con Android Studio 3+:

Debería poder simplemente copiar el archivo jar a la carpeta libs justo debajo de la carpeta de la aplicación.

... myproject \ app \ libs \ myfile.jar

Luego seleccione Archivos de proyecto en el menú desplegable de la ventana Proyectos, haga clic con el botón derecho en el proyecto, seleccione Sincronizar para ver el archivo en Archivos de proyecto. Agregará automáticamente las dependencias en el archivo gradle (Módulo: aplicación).

dependencies {
...
    implementation files('libs/myfile.jar')

Aquí hay otra solución:

Vaya a la vista Archivos de proyecto (seleccione Archivos de proyecto en el menú desplegable).

ingrese la descripción de la imagen aquí

Seleccione Nuevo ... Directorio, cree una carpeta llamada libs justo debajo de la aplicación.

ingrese la descripción de la imagen aquí

Abra el Explorador de archivos, copie y pegue su archivo jar en la carpeta libs.

En Android Studio, haga clic derecho en el archivo jar y seleccione Agregar como biblioteca ... en el menú emergente.

ingrese la descripción de la imagen aquí

Debería ver el archivo listado en la lista de dependencias en el archivo gradle:

dependencies {
...
    implementation files('libs/myfile.jar')
}

Abra su archivo java y agregue la declaración de importación allí:

import com.xxx.xxx;
vive el amor
fuente
7

Ponga los .jararchivos en la libscarpeta del proyecto de Android.

Luego agregue esta línea de código en el archivo gradle de la aplicación:

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

Para Android Gradle Plugin 3.0 y posterior, es mejor usar esto en su lugar:

    implementation fileTree(dir: 'libs', include: ['*.jar'])
Aby Mathew
fuente
7

A diferencia de Eclipse, no necesitamos descargar jar y ponerlo en la carpeta / libs. Gradle maneja estas cosas, solo necesitamos agregar dependencias de Gradle, Gradle lo descarga y lo coloca en el caché de Gradle.

Necesitamos agregar dependencias como:

dependencias {implementación 'com.google.code.gson: gson: 2.2.4'}

Sin embargo, también podemos descargar jar y agregarlo como biblioteca, pero la mejor práctica es agregar dependencias de Gradle.

Pankaj kumar
fuente
5
menu File -> project struct -> module select "app" -> dependencies tab -> + button 
-> File dependency -> PATH/myfile.jar
vuhung3990
fuente
5

Paso 1: Ahora debajo de tu app folderdeberías ver libs, si no lo ves, entonces créalo .

Paso 2: Drag & Drop the .jar file herepuede recibir un mensaje "This file does not belong to the project", simplemente haga clic en el OKbotón.

Paso 3: Ahora debería ver el archivo jar en la carpeta libs , haga clic derecho en el archivo jar y seleccione"Add as library", Click OK for prompt "Create Library"

Paso 4: ahora se ha agregado este frasco .

ingrese la descripción de la imagen aquí

IntelliJ Amiya
fuente
4

Crea una carpeta libs. Agrega tu archivo .jar. Haga clic derecho sobre él y encontrará agregar jar como dependencia. Haz click en eso. Es todo lo que necesitas hacer. Puede encontrar las dependencias agregadas a su archivo build.gradle.

Gowtham Chandrasekaran
fuente
4

1) cree una carpeta 'your_libs' dentro de la carpeta Project / app / src.

2) Copie su archivo jar en esta carpeta 'your_libs'

3) En Android Studio, vaya a Archivo -> Estructura del proyecto -> Dependencias -> Agregar -> Dependencia de archivos y navegue a su archivo jar, que debe estar debajo de 'src / your_libs'

3) Seleccione su archivo jar y haga clic en 'Aceptar'

y luego puede ver en su build.gradle así: compile archivos ('src / your_libs / your.jar')

idris yıldız
fuente
4

En Android Studio 1.1.0. Resolví esta pregunta siguiendo los pasos:

1: Coloque el archivo jar en el directorio libs. (en Finder)

2: Abra la configuración del módulo, vaya a Dependencias, en la esquina inferior izquierda hay un botón más. Haga clic en el botón más y luego elija "Dependencia de archivo". Aquí puede ver su archivo jar. Selecciónelo y se resuelve.

mbo
fuente
4

¡He leído todas las respuestas aquí y todas parecen cubrir versiones antiguas de Android Studio!

Con un proyecto creado con Android Studio 2.2.3, solo necesitaba crear un libsdirectorio appy colocar mi jar allí. Lo hice con mi administrador de archivos, no es necesario hacer clic o editar nada en Android Studio.

Por que funciona Abra Construir / Editar bibliotecas y dependencias y verá:

{include=[*.jar], dir=libs}
0xF
fuente
3

En Mac OS X:

  1. Agregue jar como biblioteca (arrastre jar a libs, haga clic con el botón derecho en agregar como lib)

  2. Agregar declaración de compilación a build.grade

  3. Instalar gradle v1.6(usar homebrew)

    • brew instalar gradle
    • gradle -v
    • si no es v1.6, actualice homebrew
  4. Gradle Clean (reconstruir Android no funcionó)

Esto me solucionó.

usuario2573236
fuente
3

Como muchos antes señalaron, agregará

compile files('libs/gson-2.2.3.jar') 

a su archivo build.gradle.

Sin embargo, tengo un proyecto en Android Studio que se migró de Eclipse y, en este caso, la carpeta "libs" se llama "lib", por lo que eliminar la "s" resolvió el problema.

Christina
fuente
3
  1. Se agregó la libscarpeta a nivel de app.
  2. Se agregó todo jarsen este proyecto.
  3. A continuación, seleccionó todos los frascos, en la libscarpeta,
  4. haga clic derecho en los elementos seleccionados y diga add library
  5. luego encontrará la opción de expansión de jarras, dentro del explorador de proyectos.

Observé que CTRL+ ALT+ SHIFT+ S-> estructura del proyecto -> módulo de aplicación -> Dependencias "ya tenía una entrada como (dir: 'libs', include: '*.jar')debajo compile-option, inicialmente. Y después de agregar los jar según los pasos indicados anteriormente, build.gradleobtuve las entradas para el nuevo agregado jarra en sí.

parasitar
fuente
3

En Android Studio 2.1 sigo el siguiente camino,

Ir a la aplicación -> src-> principal -> carpeta de activos (si no está disponible, créelo ) -> coloque sus archivos JAR

ingrese la descripción de la imagen aquí

En su build.gradle agregue dependencia como esta,

implementation files('src/main/assets/jsoup.jar')
implementation files('src/main/assets/org-apache-xmlrpc.jar')
implementation files('src/main/assets/org.apache.commons.httpclient.jar')
implementation files('src/main/assets/ws-commons-util-1.0.2.jar')

Sincronizar ahora. Ahora sus archivos JAR están listos para usar.

Ranjith Kumar
fuente
¿Por qué no usas el directorio libs?
Deni Erdyneev
@ErdeniErdyneev Doy otro enfoque para almacenar archivos jar. ¿Por qué no uso los activos? ¿Algún problema en mi enfoque? Estoy listo para corregir errores si estoy equivocado
Ranjith Kumar
3

Para la versión más reciente de Android 1.0.2, lo siguiente ya está allí en su archivo build.gradle

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

Agregue el tarro de la biblioteca a su carpeta libs -> haga clic con el botón derecho en la biblioteca -> haga clic en agregar como biblioteca -> le pide el proyecto para agregarlo -> seleccione su proyecto -> haga clic en Aceptar La siguiente línea se agrega automáticamente para compilar .gradle

implementation files('libs/android-query.jar')

Eso lo hizo por mí. No se requería nada más. He mostrado esto para Android Aquery otra biblioteca de terceros para Android.

usuario2779311
fuente
2

Mi respuesta es básicamente reunir algunas de las respuestas correctas pero incompletas proporcionadas anteriormente.

  1. Abra build.gradle
  2. Agregue lo siguiente:

    dependencies {
    compile 'com.android.support:appcompat-v7:19.+'
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.google.code.gson:gson:2.3'
    }

    Esto permitirá la compatibilidad con dos formas diferentes de agregar dependencias. El compile fileTree(dir: 'libs', include: ['*.jar'])(como mencionó @Binod) le dice al compilador que busque debajo de la carpeta libs CUALQUIER jar. Es una buena práctica crear una carpeta 'libs' que contenga los paquetes jar que nuestra aplicación necesita usar.

Pero esto también permitirá el soporte para la dependencia de Maven. La compilación 'com.google.code.gson:gson:2.3'(como lo menciona @saneryee) es otra forma recomendada de agregar dependencias que están en un repositorio remoto central y no en nuestro "repositorio local" / libs. Básicamente le dice a Gradle que busque esa versión de ese paquete y le dice al compilador que lo tenga en cuenta al compilar el proyecto (tenerlo en el classpath)

PD: yo uso ambos

diegosasw
fuente