libreria - Android Studio: ¿Añadir jar como biblioteca?

generar jar android studio

Question

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 construcción.

Había creado un nuevo proyecto con solo una MainActivity . Copié gson-2.2.3.jar en la carpeta / libs y lo agregó como una dependencia de la biblioteca (clic derecho-> Agregar como biblioteca). Esto incluye el jar en Android Studio para que pueda ser referenciado desde los archivos de origen.

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 de .gradle. Después de eso, se compila correctamente, pero cuando ClassDefNotFoundException la aplicación obtengo una ClassDefNotFoundException .

¿Alguien sabe lo que estoy haciendo mal?

Answer 1

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

2. Haga clic derecho en el módulo deseado donde desea agregar la biblioteca externa, luego seleccione Nuevo> Directroy y nómbrelo como '' libs ''
3. Ahora copia el blah_blah.jar en la carpeta '' libs ''
4. Haga clic con el botón 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

Nota: si está utilizando bibliotecas de terceros, es mejor utilizar dependencias donde el script de Gradle descarga automáticamente el JAR y el JAR de dependencia cuando se ejecuta el script de gradle.

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

Leer más sobre Gradle Dependency Mangement

Answer 2

1. Ponga 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 ) libs/gson-2.2.4.jar en su archivo build.gradle.

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

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

Answer 3

1. Descargar el archivo de la biblioteca desde el sitio web
2. Copiar desde windows explorar
3. Pegar en la carpeta lib desde el Explorador de proyectos
4. Ctrl + Alt + Shift + S abrir la estructura del proyecto
5. Seleccione la pestaña Dependencias, agregue el archivo usando +
6. Barra de herramientas Sincroniza el proyecto con el archivo de gradle usando el botón

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

Answer 4

1. Se agregó la carpeta "libs" en el nivel de "app".
2. Añadido todos los "tarros" en este proyecto.
3. A continuación, seleccioné todos los frascos, en la carpeta "libs",
4. haga clic con el botón derecho en los elementos seleccionados y diga "agregar biblioteca"
5. A continuación, encontrará la opción de expansión de tarros, dentro del propio 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'', incluye: ''* .jar'')" debajo de compile-option ", inicialmente. Y después de agregar los archivos jar según los pasos mencionados anteriormente, el "build.gradle" obtuvo las entradas para los nuevos archivos jar agregados.

Answer 5

¡He leído todas las respuestas aquí y parece que todas cubren versiones antiguas de Android Studio!

Con un proyecto creado con Android Studio 2.2.3, solo necesitaba crear un directorio libs en la app y colocar mi tarro allí. Lo hice con mi administrador de archivos, sin necesidad de hacer clic o editar nada en Android Studio.

¿Por qué funciona? Abre Build / Edit Libraries and Dependencies y verás:

{include=[*.jar], dir=libs}

Answer 6

''compilar archivos ...'' solía funcionar para mí, pero ya no. Después de mucho dolor, encontré 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.

Answer 7

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 hasta 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'')

Answer 8

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 las descarga y las coloca en caché de Gradle.

Necesitamos agregar dependencias como:

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

eso es todo. Sin embargo, también podemos descargar jar & add that as library, pero la mejor práctica es agregar dependencias de Gradle.

Answer 9

Aquí están las instrucciones para agregar un archivo jar local como una 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 file agregue lo siguiente para que el cierre de sus dependencias tenga:

   dependencies {
       // ... other dependencies
       compile files(''libs/<your jar''s name here>'')
   }

3. Android Studio ya debería haber instalado un contenedor Gradlew. Desde la línea de comandos, navegue hasta el nivel superior de su proyecto (el directorio que tiene un archivo gradlew ).

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

4. Para que Android Studio reconozca los archivos jar locales como bibliotecas para que sean compatibles al codificar en el IDE, debe realizar algunos pasos más:

   4.1. Haga clic con el botón derecho en el módulo en el panel de la izquierda y elija Open Library Settings .

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

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

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

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

Answer 10

Como muchos antes señalados añadiréis

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", así que al eliminar la "s" se solucionó el problema.

Answer 11

Con Android Studio 3+:

Solo deberías poder simplemente copiar el archivo jar en la carpeta libs justo debajo de la carpeta de la aplicación.

... myproject / app / libs / myfile.jar

Luego, seleccione Archivos de proyecto del menú desplegable en 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).

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

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

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

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

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

Abre tu archivo java y agrega la declaración de importación allí:

import com.xxx.xxx;

Answer 12

Considero que Dependency Manager de Android Studio es muy útil y poderoso para administrar dependencias de terceros (como gson se menciona aquí). Proporcionando una guía paso a paso que me funcionó (NOTA: estos pasos se han probado para Android Studio 1.6 y versiones posteriores en la plataforma Windows).

Paso 1: Vaya a "Crear> Editar bibliotecas y dependencias ..." se abrirá el cuadro de diálogo "Estructura del proyecto"

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

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

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

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

Espero que esto ayude :)

Answer 13

Crea una carpeta libs. Añade 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.

Answer 14

Descargue y copie su archivo .jar en la carpeta libs luego agregue esta línea a build.gradle:

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

No te olvides de hacer clic en "Sincronizar ahora"

Android Studio 1.1.0

Answer 15

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

1: Poner 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 archivos". Aquí puede ver su archivo jar. Selecciónelo y queda resuelto.

Answer 16

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

Agregue debajo la dependencia en su archivo build.gradle.

repositories {mavenCentral()}

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

Todo está bien.

También puedes ver este post. La mejor manera de integrar bibliotecas de terceros en el estudio de Android.

Answer 17

En Mac OS X:

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

2. Agregue compilación a build.grade

3. Instale gradle v1.6 (use homebrew)

   • brew install gradle
   • gradle -v
   • Si no es v1.6, mejora homebrew

4. gradle limpio (reconstruir Android no funcionó)

Esto me solucionó.

Answer 18

En el proyecto 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:

2:

3:

Verás esto:

Answer 19

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

1. Pon el tarro de Gson (en mi caso, gson-2.2.4.jar ) en la carpeta libs
2. Haz clic derecho y presiona ''Agregar como biblioteca''

3. Asegúrese de que los compile files(''libs/gson-2.2.4.jar'') en su archivo build.gradle (o compile fileTree(dir: ''libs'', include: ''*.jar'') si está usando muchos archivos jar )

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

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

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

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

Answer 20

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

(Estoy usando Android Studio 2.1.2)

Paso 1

• Agregue el nombre de su paquete jar (como ejemplo compile ''com.squareup.okhttp3:okhttp:3.3.1'' ) en el script de desarrollo de gradle en build.gradle (Module: app) .

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

Paso 3: Haga clic en Importar paquete JAR / .AAR y luego busque su paquete. como ejemplo: OkHttp.jar

Answer 21

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

Consulte la ayuda de Intellij para agregar bibliotecas a un proyecto.

La parte que debería interesarte más 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 seleccionadas.

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

Ya no es necesario agregar compile files() , y la biblioteca debe agregarse correctamente a su proyecto.

Answer 22

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

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

No olvide hacer clic en "Sincronizar ahora" en la esquina superior derecha.

Estoy usando Android Studio 1.0.1.

Answer 23

Mi respuesta es básicamente recopilar algunas de las respuestas correctas pero incompletas que se proporcionaron anteriormente.

1. Abrir 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á el soporte para dos formas diferentes de agregar dependencias. La compile fileTree(dir: ''libs'', include: [''*.jar'']) (como mencionó @Binod) le dice al compilador que busque debajo de la carpeta libs para CUALQUIER jar. Es una buena práctica crear tal carpeta ''libs'' que contendrá los paquetes jar que nuestra aplicación necesita usar.

Pero esto también permitirá el apoyo a 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 considere al compilar el proyecto (tenerlo en el classpath)

PD: yo uso ambos

Answer 24

Para el nuevo Android 1.0.2, lo siguiente ya está allí en su archivo build.gradle

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

Agregue el contenedor de la biblioteca a su carpeta de bibliotecas -> haga clic derecho en la biblioteca -> haga clic en agregar como una biblioteca -> le pide que el proyecto lo agregue para -> seleccione su proyecto -> haga clic en ok La siguiente línea se agrega automáticamente para compilar .gradle

compilar archivos (''libs / android-query.jar'')

Eso lo hizo por mí. nada más era requerido. He mostrado esto para Android Aquery otra biblioteca de terceros para Android.

Answer 25

Paso 1: Ahora, en la app folder , deberías ver libs , si no la ves, créala .

Paso 2: Drag & Drop the .jar file here , puede obtener un mensaje "This file does not belong to the project" , simplemente haga OK botón OK .

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 este frasco ha sido añadido.

Answer 26

Puedes hacer esto con dos opciones.

Primera forma sencilla.

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

luego haga clic con el botón derecho en el archivo .jar y haga clic en agregar como una 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 {
        compile fileTree(dir: ''libs'', include: [''*.jar''])
        compile ''com.android.support:appcompat-v7:21.0.3''
        compile project('':okhttp-2.0.0'')
        compile ''com.google.code.gson:gson:2.3.1''
    }

La segunda forma es que: podemos agregar un archivo .jar a un módulo importando este archivo .jar como un 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 -

Luego presione CTRL + ALT + MAYÚS + S -> Proyecto de protección -> elija el módulo que desea agregar para agregar un jar -> Dependencendies -> Dependencia de módulos. build.gradle del módulo se actualizará automáticamente.

Answer 27

Simplemente coloque los archivos .jar en la carpeta libs del proyecto de Android.

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

Esta línea de código en el archivo de aplicaciones Graddle hará el resto.

Happy Coding :)

Answer 28

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

Archivo> Nuevo módulo ...

La siguiente pantalla parece rara, como si estuviera seleccionando algún widget o algo, pero manténgalo en la primera imagen y debajo, desplácese y busque "Importar JAR o .AAR Package"

Luego tome la Project Structure del Project Structure del menú Archivo. Seleccione la app de la ventana abierta, luego seleccione las dependencies , luego presione green plus button , seleccione la module dependency luego seleccione el módulo que importó y luego presione OK

Answer 29

compile fileTree(dir: ''libs'', include: ''*.jar'') funciona bien pero no compile files(...) han probado con Studio Beta 0.8.1

Answer 30

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