volley - importar jar en android studio




Android Studio: ¿Añadir jar como biblioteca? (20)

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

  1. Haga clic 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 la carpeta ' libs '
  3. 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

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?


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.


  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.


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

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


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.


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.


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;

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.


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



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


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]


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


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.


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


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.


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.


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


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







dependency-management