Android Studio: ¿Agregar jar como biblioteca?

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?

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]

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

   

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

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

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:

2:

3:

Verás esto:

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

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.

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

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 asígnele el nombre ' libs '
3. Ahora copie el blah_blah.jar en la carpeta ' libs '
4. 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

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

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.

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.

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"

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

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"

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

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

Espero que esto ayude :)

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.

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"

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 -

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.

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

(Estoy usando Android Studio 2.1.2)

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

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

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

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

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

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

import com.xxx.xxx;

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

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.

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

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 .

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.

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

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.

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

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

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.

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

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

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.

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.

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