Android Studio: ¿Agregar jar como biblioteca?

Aquí están las instrucciones para agregar un archivo jar local como biblioteca a un módulo:

1. Crear 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 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 wrapper de gradlew. Desde la línea de comandos, vaya al nivel superior de su project (el directorio que tiene un archivo gradlew).

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

4. Para que Android Studio reconozca los archivos jar locales como bibliotecas de 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 diálogo, elija Libraries.

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

   

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

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

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

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

Consulte La ayuda de Intellij sobre cómo 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 ficha 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 Elegido.

Si la biblioteca no aparece en el cuadro de diálogo, agréguela en 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.

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

Agregue la siguiente dependencia en su compilación.archivo 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 la biblioteca de terceros en Android studio

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

Archivo > Nuevo módulo...

La siguiente pantalla se ve rara, como si estuviera seleccionando algún widget o algo, pero manténgalo en la primera imagen y por debajo de desplazamiento y encontrar " JAR de importación o .Paquete AAR "

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

'compilar archivos... solía trabajar 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 hizo una diferencia, pero, al menos la maldita cosa está funcionando ahora.

Sencillos pasos para agregar una biblioteca externa en Android Studio

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

1. Haga clic con el botón derecho en el módulo deseado donde desea agregar la biblioteca externa, luego seleccione Nuevo > Directroy y nómbrelo como 'libs'
2. Ahora copia el blah_blah.jar en el 'libs' folder
3. Haga clic derecho en el blah_blah.jar, Luego seleccione ' Agregar como Biblioteca..'. Esto agregará y entrará automáticamente en build.gradle como compilar archivos ('libs / blah_blah.jar') y sincronizar el gradle. Y has terminado

Tenga en cuenta : Si está utilizando bibliotecas de terceros, entonces es mejor usar dependencias donde Gradle script descarga automáticamente el JAR y el JAR de dependencias cuando gradle ejecución del guión.

Ej: compile ' com.Google.androide.gms: play-services-ads:9.4.0'

Lee más sobre Gradle Dependency Mangement

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

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

Hice que funcionara simplemente agregando una línea para construir.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 olvides hacer clic en "Sincronizar ahora" en la esquina superior derecha.

Estoy usando Android Studio 1.0.1.

Me pareció Gestor de dependencias de Android Studio muy útil y potente para la gestión de dependencias de terceros (como gson mencionado aquí). Proporcionar 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: Goto " Build > Edit Libraries and Dependencies..."se abriría el diálogo "Estructura del proyecto"

Paso-2: Seleccione " app " y luego seleccione Pestaña "Dependencias". A continuación, seleccione "Add > 1 Library dependency"

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

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

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

Espero que esto ayude :)

1. Ponga el frasco (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 compilación.archivo gradle.

3. Ahora haz clic en "Sincronizar proyecto con archivos de Gradle"(A la izquierda del botón AVD manager en la barra superior).

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

Descargue y Copie Su archivo .jar en la carpeta libs y luego agregue estas líneas para compilar.gradle:

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

No olvides hacer clic en "Sincronizar ahora"

Android Studio 1.1.0

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 pone en la caché de gradle.

Necesitamos agregar dependencias como:

Dependencies {compile ' com.Google.codificar.gson: gson:2.2.4'}

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

Puede hacer esto con dos opciones.

Primera manera simple.

Copie el .archivo jar al portapapeles y luego agregarlo a la carpeta libs. Para ver la carpeta libs del proyecto, seleccione el proyecto de combobox por encima 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. Puedes ver el .archivo jar en build.archivo 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 manera es que: Podemos agregar a .archivo jar a un módulo mediante la importación este .jar file como a .módulo jar luego agregue este módulo a cualquier módulo que queramos.

Módulo de Importación ---> elija su .archivo jar than > que importar como a .frasco --

Luego CTRL+ALT+SHIFT+S project> project sturure choose>elija el módulo que desea para agregar un jar Depend>Dependencendies Dependency> Module Dependency. construir.gradle del módulo se actualizará automáticamente.

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

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

Esta línea de código en el archivo graddle de apps hará el resto.

Happy Coding :)

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

(estoy usando Android Studio 2.1.2)

Paso 1

• Agrega el nombre de paquete jar (como ejemplo compile 'com.squareup.okhttp3:okhttp:3.3.1') en el script de compilación de gradle bajo compilación.gradle (Module:app) .

Paso 2: Haga clic derecho en app folder -> New - > Módulo

Paso 3: Haga clic en Importar JAR/.AAR Package Luego navega por tu paquete. por ejemplo: OkHttp.jar

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

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. Add compile statement to build.grade

3. Instalar gradle v1.6 (usar homebrew)

   • instalación de brew gradle
   • gradle-v
   • si no es v1. 6, actualizar homebrew

4. Gradle clean (reconstruir android no funcionó)

Esto me solucionó.

Crear una carpeta libs. Añade tu .archivo jar. Haga clic derecho sobre él y encontrará agregar jar como dependencia. Haga clic en él. Es todo lo que necesitas hacer. Puedes encontrar las dependencias agregadas a tu compilación.archivo 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, ve a Archivo - > Estructura del proyecto - > Dependencias - > Añadir - > Dependencia del archivo y navega hasta tu archivo jar, que debería estar en 'src/your_libs'

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

Y luego puedes ver en tu compilación.gradle así: compile files ('src / your_libs / your.jar')

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

1: Ponga 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í puedes ver tu archivo jar. Selecciónelo y se resuelve.

Paso 1 : Ahora bajo su app folder usted debe ver libs, si usted no lo ve, , a continuación, cree que .

Paso 2 : Drag & Drop the .jar file here, usted puede obtener una pronta "This file does not belong to the project", simplemente haga clic en OK el Botón .

Paso 3: Ahora deberías 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, esto jar ha sido añadir.

Con Android Studio 3+:

Simplemente debería poder 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 derecho en el proyecto, seleccione Sincronizar para ver el archivo en Archivos de proyecto. Agregará automáticamente las dependencias en el archivo gradle (Module: app).

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

Aquí hay otra solución:

Ir al Proyecto Vista de archivos (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, haz clic con el botón derecho en el archivo jar y selecciona Agregar como biblioteca... desde 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 instrucción import allí:

import com.xxx.xxx;

Como muchos antes han señalado, agregarás

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

A tu compilación.archivo gradle.

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

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

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

¿por Qué funciona? Abre Construye / Edita Bibliotecas y Dependencias y verás:

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

compile fileTree(dir: 'libs', include: '*.jar') funciona bien, pero no {[1] } han probado con Studio Beta 0.8.1

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

1. Construcción abierta.gradle

2. Añádase 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. El compile fileTree(dir: 'libs', include: ['*.jar']) (como @Binod mencionado) le dice al compilador que busque bajo las librerías de carpetas cualquier jar. Es una buena práctica crear una carpeta de este tipo 'libs' que contendrá los paquetes jar que nuestra aplicación necesita utilizar.

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

PS: Yo uso ambos

Para Android 1.0.2 más reciente, lo siguiente ya está en tu compilación.gradle file

Compile FileTree(incluya: ['*.jar'], dir: 'libs')

Agregue el jar 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 añade automáticamente a la compilación.gradle

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

Eso lo hizo por mí. no se necesitaba nada más. he mostrado esto para Android aquery otra biblioteca de terceros para Android.

1. Se agregó la carpeta "libs" al nivel de "app".
2. Se agregaron todos los "jars" en este proyecto.
3. A continuación, seleccionamos todos los frascos, en la carpeta" libs",
4. haga clic derecho en los elementos seleccionados y diga "agregar biblioteca"
5. a continuación, encontrará la opción de expansión jars, dentro del explorador de proyectos en sí.

Observé que "CTRL+ALT+SHIFT+S structure> estructura del proyecto > >app-module Depend > Dependencias" ya tenía una entrada como "(dir: 'libs', include: '*.jar')" bajo "compile-option", inicialmente. Y después de agregar el frasco según los pasos indicados anteriormente, el " build.gradle " consiguió las entradas para el nuevo jarro añadido, sí mismo.