¿Cómo agrego un proyecto de biblioteca a Android Studio?

¿Cómo agrego un proyecto de biblioteca (como Sherlock ABS) a Android Studio ?

(No para el antiguo paquete basado en ADT Eclipse, sino para el nuevo Android Studio ).

Actualización para Android Studio 1.0

Desde que se lanzó Android Studio 1.0 (y muchas versiones entre v1.0 y una de las primeras desde el momento de mi respuesta anterior) algunas cosas han cambiado.

Mi descripción se centra en agregar proyectos de bibliotecas externas a mano a través de archivos Gradle (para comprender mejor el proceso). Si desea agregar una biblioteca a través del creador de Android Studio, simplemente verifique la respuesta a continuación con una guía visual (existen algunas diferencias entre Android Studio 1.0 y las de las capturas de pantalla, pero el proceso es muy similar).

Antes de comenzar a agregar una biblioteca a su proyecto a mano, considere agregar la dependencia externa. No afectará la estructura de tu proyecto. Casi todas las bibliotecas conocidas de Android están disponibles en un repositorio de Maven y su instalación solo requiere una línea de código en el app/build.gradlearchivo:

dependencies {
     compile 'com.jakewharton:butterknife:6.0.0'
}

Agregar la biblioteca

Aquí está el proceso completo de agregar una biblioteca externa de Android a nuestro proyecto:

1. Crea un nuevo proyecto a través del creador de Android Studio. Lo llamé HelloWorld .
2. Aquí está la estructura original del proyecto creada por Android Studio:

HelloWorld/
      app/
           - build.gradle  // local Gradle configuration (for app only)
           ...
      - build.gradle // Global Gradle configuration (for whole project)
      - settings.gradle
      - gradle.properties
      ...

3. En el directorio raíz ( HelloWorld/), cree una nueva carpeta: /libsen la que colocaremos nuestras bibliotecas externas (este paso no es obligatorio, solo para mantener una estructura de proyecto más limpia).
4. Pegue su biblioteca en la /libscarpeta recién creada . En este ejemplo, utilicé la biblioteca PagerSlidingTabStrip (solo descargue ZIP de GitHub, cambie el nombre del directorio de la biblioteca a "PagerSlidingTabStrip" y cópielo). Aquí está la nueva estructura de nuestro proyecto:

HelloWorld/
      app/
           - build.gradle  // Local Gradle configuration (for app only)
           ...
      libs/
           PagerSlidingTabStrip/
                - build.gradle // Local Gradle configuration (for library only)
      - build.gradle // Global Gradle configuration (for whole project)
      - settings.gradle
      - gradle.properties
      ...

5. Edite settings.gradle agregando su biblioteca a include. Si usa una ruta personalizada como lo hice, también debe definir el directorio del proyecto para nuestra biblioteca. Un settings.gradle completo debería verse a continuación:

   include ':app', ':PagerSlidingTabStrip'
   project(':PagerSlidingTabStrip').projectDir = new File('libs/PagerSlidingTabStrip')
   

5.1 Si enfrenta el error "Configuración predeterminada", intente esto en lugar del paso 5,

    include ':app'
    include ':libs:PagerSlidingTabStrip'

6. En app/build.gradleagregar nuestro proyecto de biblioteca como una dependencia:

   dependencies {
       compile fileTree(dir: 'libs', include: ['*.jar'])
       compile 'com.android.support:appcompat-v7:21.0.3'
       compile project(":PagerSlidingTabStrip")
   }
   

6.1. Si siguió el paso 5.1, siga esto en lugar de 6,

    dependencies {
        compile fileTree(dir: 'libs', include: ['*.jar'])
        compile 'com.android.support:appcompat-v7:21.0.3'

        compile project(":libs:PagerSlidingTabStrip")
    }

7. Si su proyecto de biblioteca no tiene build.gradlearchivo, debe crearlo manualmente. Aquí hay un ejemplo de ese archivo:

       apply plugin: 'com.android.library'
   
       dependencies {
           compile 'com.android.support:support-v4:21.0.3'
       }
   
       android {
           compileSdkVersion 21
           buildToolsVersion "21.1.2"
   
           defaultConfig {
               minSdkVersion 14
               targetSdkVersion 21
           }
   
           sourceSets {
               main {
                   manifest.srcFile 'AndroidManifest.xml'
                   java.srcDirs = ['src']
                   res.srcDirs = ['res']
               }
           }
       }
   

8. Además, puede crear una configuración global para su proyecto que contendrá versiones de SDK y versión de herramientas de compilación para cada módulo para mantener la coherencia. Solo edite el gradle.propertiesarchivo y agregue líneas:

   ANDROID_BUILD_MIN_SDK_VERSION=14
   ANDROID_BUILD_TARGET_SDK_VERSION=21
   ANDROID_BUILD_TOOLS_VERSION=21.1.3
   ANDROID_BUILD_SDK_VERSION=21
   

   Ahora puede usarlo en sus build.gradlearchivos (en módulos de aplicaciones y bibliotecas) como a continuación:

   //...
   android {
       compileSdkVersion Integer.parseInt(project.ANDROID_BUILD_SDK_VERSION)
       buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION
   
       defaultConfig {
           minSdkVersion Integer.parseInt(project.ANDROID_BUILD_MIN_SDK_VERSION)
           targetSdkVersion Integer.parseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION)
       }
   }
   //...
   

9. Eso es todo. Simplemente haga clic en sincronizar el proyecto con el icono de Gradle . Su biblioteca debería estar disponible en su proyecto.

Google I / O 2013: el nuevo Android SDK Build System es una excelente presentación sobre la creación de aplicaciones de Android con Gradle Build System: como dijo Xavier Ducrohet:

Android Studio se trata de edición, depuración y creación de perfiles. Ya no se trata de construir.

Al principio puede ser un poco confuso (especialmente para aquellos que trabajan con Eclipse y nunca han visto la hormiga, como yo;)), pero al final Gradle nos brinda grandes oportunidades y vale la pena aprender este sistema de construcción.

Aquí está la guía visual:

Actualización para Android Studio 0.8.2:

En Android Studio 0.8.2, vaya a Estructura del proyecto -> en Módulos, simplemente presione el botón más y seleccione Importar proyecto existente e importar actionbarsherlock. Luego sincronice sus archivos Gradle.

Si te enfrentas al error

Error: la revisión de SDK Build Tools (xx.xx) es demasiado baja. El mínimo requerido es aa.aa

simplemente abra el build.gradlearchivo en el actionbarsherlockdirectorio y actualice el buildToolsVersional sugerido.

android {
  compileSdkVersion 19
  buildToolsVersion 'yy.y.y'

Archivo de menú -> Estructura del proyecto ... :

Módulo -> Módulo Importar

Después de importar el módulo de biblioteca, seleccione su módulo de proyecto y agregue la dependencia:

Y luego seleccione el módulo importado :

Use el menú Archivo -> Estructura del proyecto -> Módulos .

Empecé a usarlo hoy. Es un poco diferente

Para Sherlock, tal vez desee eliminar su directorio de prueba o agregar el junit.jararchivo al classpath.

Para importar la biblioteca usando gradle, puede tener que agregarla a la dependenciessección de su build.gradle(la del módulo).

P.ej

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.1.0'
    compile 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
}

Android Studio está cambiando.

Existe una sección llamada "Configuración de módulo abierto" si hace clic derecho en una carpeta de módulo en la sección de proyecto de Android Studio (estoy usando la versión 0.2.10).

Consideraría la lectura necesaria de Dependencias, Bibliotecas de Android y Configuración de proyectos múltiples . Tómese unos minutos para hacerlo.

En particular, en el caso de un proyecto de biblioteca que no sea jar, lea el siguiente fragmento de la fuente anterior:

Los proyectos de Gradle también pueden depender de otros proyectos de Gradle mediante el uso de una configuración multiproyecto. Una configuración multiproyecto generalmente funciona al tener todos los proyectos como subcarpetas de un proyecto raíz determinado.

Por ejemplo, dado a la siguiente estructura:

MyProject/
 + app/
 + libraries/
    + lib1/
    + lib2/

Podemos identificar 3 proyectos. Gradle los referenciará con el siguiente nombre:

:app
:libraries:lib1
:libraries:lib2

Cada proyecto tendrá su propio build.gradle declarando cómo se construye. Además, habrá un archivo llamado settings.gradle en la raíz que declara los proyectos. Esto da la siguiente estructura:

MyProject/
 | settings.gradle
 + app/
    | build.gradle
 + libraries/
    + lib1/
       | build.gradle
    + lib2/
       | build.gradle

El contenido de settings.gradle es muy simple:

include ':app', ':libraries:lib1', ':libraries:lib2'

Esto define qué carpeta es realmente un proyecto Gradle.

Es probable que el proyecto: app dependa de las bibliotecas, y esto se hace declarando las siguientes dependencias:

dependencies {
    compile project(':libraries:lib1')
}

Tenga en cuenta que hubo poco o ningún uso de la GUI de Android Studio para que esto sucediera.

Actualmente estoy usando submódulos git para vincular la biblioteca anidada al repositorio git de la biblioteca real para evitar un desastre de dependencia.

Acabo de encontrar una manera más fácil (en lugar de escribir directamente en los archivos .gradle).

Esto es para Android Studio 1.1.0.

1. Archivo de menú -> Nuevo módulo ... :

   

   Haga clic en "Importar proyecto existente".

2. Seleccione la biblioteca deseada y el módulo deseado.

3. Haga clic en finalizar. Android Studio importará la biblioteca a su proyecto. Se sincronizará archivos gradle.

4. Agregue el módulo importado a las dependencias de su proyecto.

   Haga clic derecho en la carpeta de la aplicación -> Abrir configuración del módulo -> vaya a la pestaña de dependencias -> Haga clic en el botón '+' -> haga clic en Dependencia del módulo.

   El módulo de la biblioteca se agregará a las dependencias del proyecto.

   

5. ???

6. Lucro

La forma más fácil que encontré para incluir un proyecto de biblioteca externa es (por ejemplo, incluir una biblioteca de Facebook que se almacena en un directorio en la carpeta de dependencias):

1. En settings.gradle add

   include ':facebook'
   
   project(':facebook').projectDir = new File(settingsDir, '../dependencies/FacebookSDK')

2. En la sección de dependencias build.gradle, agregue

   compile project ('facebook')

Todo lo que queda por hacer es sincronizar el proyecto con los archivos gradle.

Una forma sencilla de agregar un archivo JAR como biblioteca a su proyecto de Android Studio:

a) Copie sus archivos * .jar

b) Pegue en el directorio libs debajo de sus proyectos:

c) Agregar a build.gradle:

dependencies {
    ...
    compile files('libs/ScanAPIAndroid.jar', 'libs/ScanAPIFactoryAndroid.jar', .., ..)
}

b) Si su proyecto del ejemplo com.example.MYProject y las bibliotecas com.example.ScanAPI tiene el mismo espacio de nombres com.example , Android Studio verificará su compilación y creará todos los cambios necesarios en su proyecto. Después de eso, puede revisar esta configuración en el menú Archivo -> Estructura del proyecto .

c) Si su proyecto y sus bibliotecas tienen un espacio de nombres diferente , debe hacer clic derecho en la biblioteca y seleccionar la opción "Agregar como biblioteca" y seleccionar el tipo que necesita.

Recuerde que la opción "Estructura del proyecto" no está haciendo ningún cambio automático en "build.gradle" en la versión actual de Android Studio (0.2.3). Tal vez esta característica estará disponible en las próximas versiones.

Opción 1: colocar archivos en el directorio libs / del proyecto

El archivo build.gradle relevante se actualizará automáticamente.

Opción 2: Modificar el archivo build.gradle manualmente

Abra su archivo build.gradle y agregue una nueva regla de compilación al cierre de dependencias. Por ejemplo, si desea agregar Google Play Services, la sección de dependencias de su proyecto se vería así:

dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.google.android.gms:play-services:6.5.+'
   }

Opción 3: usar la interfaz de usuario de Android Studio

En el panel Proyecto, Controlhaga clic en el módulo al que desea agregar la dependencia y seleccione Abrir configuración del módulo.

Seleccione la pestaña Dependencias, seguido del botón + en la esquina inferior izquierda. Puede elegir de la siguiente lista de opciones:

• Dependencia de biblioteca
• Dependencia de archivo
• Dependencia del módulo

Luego puede ingresar más información sobre la dependencia que desea agregar a su proyecto. Por ejemplo, si elige la dependencia de la biblioteca, Android Studio muestra una lista de bibliotecas entre las que puede elegir.

Una vez que haya agregado su dependencia, verifique su archivo build.gradle a nivel de módulo. Debería haberse actualizado automáticamente para incluir la nueva dependencia.

Fuente

Así es como me funciona en Android Studio 1.5+

En el proyecto donde desea agregar un proyecto de biblioteca externa, vaya al menú Archivo -> Nuevo -> * Importar nuevo módulo **, navegue al proyecto de biblioteca que desea agregar a su proyecto, seleccione para agregar el módulo 'biblioteca' en tu proyecto. Obtendrá settings.gradle en sus proyectos, junto a la aplicación, la biblioteca incluida, algo como esto:

include ':app', ':library'

Agregue build.gradle (Módulo: aplicación) en la sección de dependencias:

Compilar proyecto (': biblioteca')

Reconstruye el proyecto y listo.

* Puede agregar tantas bibliotecas (módulos) como desee. En ese caso, en settings.gradle tendrás:

 include ':app', ':lib1', ':lib2', ...

Y en build.gradle, necesitarás tener:

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

    // Some other dependencies...

    compile project(':lib1')
    compile project(':lib2')
    ...
}

Si necesita acceso a los recursos de un proyecto de biblioteca (como lo hace con ABS) asegúrese de agregar el proyecto / módulo de biblioteca como una "Dependencia del módulo" en lugar de una "Biblioteca".

Puedes hacer esto fácilmente. Vaya al menú Archivo -> Nuevo -> Módulo de importación ... :

Busque el directorio que contiene el módulo. Haga clic en Finalizar:

Vaya a Estructura del proyecto y agregue Dependencia del módulo :

Nota: Si recibe un error de SDK, actualícelo.

1. Presione F4para mostrar Estructura del proyecto , haga clic en bibliotecas o bibliotecas globales y haga clic +para agregar el archivo JAR.
2. Haga clic en Módulos en lo que desea agregar jar, seleccione la pestaña Dependencias , haga clic +y agregue Biblioteca.

No es aconsejable editar las dependencias de la biblioteca a través de la GUI, ya que eso no escribe esos cambios en su archivo build.gradle. Entonces su proyecto no se construirá desde la línea de comandos. Deberíamos editar el archivo build.gradle directamente de la siguiente manera.

Por ejemplo, dado a la siguiente estructura:

Mi proyecto/

• aplicación /
• bibliotecas /
  • lib1 /
  • lib2 /

Podemos identificar tres proyectos. Gradle los referenciará con los siguientes nombres:

1. : aplicación
2. : bibliotecas: lib1
3. : bibliotecas: lib2

Es probable que el proyecto: app dependa de las bibliotecas, y esto se hace declarando las siguientes dependencias:

dependencies {
    compile project(':libraries:lib1')
}

Para agregar a la respuesta: si el IDE no muestra ningún error, pero cuando intenta compilar, obtiene algo como:

No resource found that matches the given name 'Theme.Sherlock.Light'

Su proyecto de biblioteca probablemente se compila como un proyecto de aplicación. Para cambiar esto, vaya a:

Archivo de menú -> Estructura del proyecto -> Facetas -> [Nombre de la biblioteca] -> Marque "Módulo de la biblioteca".

Primera forma Esto está funcionando para MacBook.

Primero seleccione su archivo builder.gradle como pantalla dada:

Agregue dependencias como en la pantalla seleccionada:

Seleccione proyecto de sincronización.

Si recibe un error como "No se pudo encontrar el proyecto con la ruta ': firma-pad' en el proyecto ': aplicación'", utilice la segunda forma:

Seleccione el menú Archivo -> Nuevo -> Importar módulo ... :

Después de hacer clic en Importar módulo ,

dar la ruta de la biblioteca como mi ruta de MacBook:

Haz clic en Finalizar . Ahora se agregan su biblioteca.

Después de importar el Módulo ABS (desde Archivo> Estructura del proyecto) y asegurarme de que tiene Android 2.2 y Support Library v4 como dependencias, seguía recibiendo el siguiente error cuando usted @Alex

Error retrieving parent for item: No resource found that matches the given name 'Theme.Sherlock.Light.DarkActionBar'

Agregué el módulo recién importado como una dependencia a mi módulo de aplicación principal y eso solucionó el problema.

Android Studio 3.0

Simplemente agregue el nombre de la biblioteca al bloque de dependencias del archivo build.gradle de su aplicación .

dependencies {
    // ...
    implementation 'com.example:some-library:1.0.0'
}

Tenga en cuenta que debe usar en implementationlugar de compileahora. Esto es nuevo con Android Studio 3.0. Consulte estas preguntas y respuestas para obtener una explicación de la diferencia.

Para resolver este problema, solo necesita agregar la ruta del recurso abs al archivo de compilación de su proyecto, tal como se muestra a continuación:

sourceSets {
    main {
        res.srcDirs = ['src/main/res','../../ActionBarSherlock/actionbarsherlock/res']
    }
}

Entonces, nuevamente compilo sin ningún error.

Si usted tiene Android Studio .0.4.0, puede crear una nueva carpeta en su trayectoria de la estructura, YourApp/libraries. Copie el archivo JAR. Allí, haga clic derecho sobre él y "Agregar como biblioteca". Ahora tienes una ventana emergente. Simplemente seleccione su directorio y presione OK, y listo.

Simplemente importe el proyecto de la biblioteca de Android como módulo y en Build.gradle .

Aplicar complemento: 'com.android.library'

Después de eso, sigue estos pasos:

1. Haga clic derecho en Módulo y seleccione abrir Configuración del módulo
2. Seleccione dependencias, haga clic en +, seleccione dependencias de biblioteca y agregue el módulo importado anteriormente.

https://www.dropbox.com/s/1e3eteu3h0pmkf7/Android%20studio%20_doc.doc?dl=0 es el enlace de Dropbox sobre cómo agregar un archivo JAR y un proyecto de biblioteca en la última versión de Android Studio 1.0.1.

Por favor, consulte la documentación con capturas de pantalla. Es muy fácil para un nuevo usuario.

Encontré la solución. Es tan simple. Siga las instrucciones de froger_mcs .

Asegúrese de hacer de la carpeta src una carpeta Fuente en Estructura del proyecto -> Módulos (Fuentes).

Básicamente, puede incluir sus archivos JAR de tres maneras diferentes. La última es la biblioteca remota que utiliza el depósito en línea https://bintray.com/ jcenter. Pero, si lo hace de una de las otras dos formas, el archivo JAR se incluirá físicamente en su proyecto. Lea este enlace https://stackoverflow.com/a/35369267/5475941 para obtener más información. En esta publicación, le expliqué cómo importar su archivo JAR en el estudio de Android y le expliqué todas las formas posibles.

En resumen, si es así (dirección local), se descargan y estos archivos JAR están físicamente en el proyecto:

Pero, si se trata de una dirección de Internet como esta, son bibliotecas remotas (parte bincey.com jcenter) y se utilizarán de forma remota:

Espero que ayude.

Abra el archivo de aplicación del módulo build gradle y agregue su dependencia. Si descarga la biblioteca, simplemente importe y compile como gradle.

De lo contrario, agregue repositorios en la aplicación del módulo de gradle lateral:

repositories {
        maven { url 'http://clinker.47deg.com/nexus/content/groups/public' }
}

Los primeros repositorios descargarán la biblioteca por usted.

Y compile la biblioteca descargada:

 compile ('com.fortysevendeg.swipelistview:swipelistview:1.0-SNAPSHOT@aar') {
        transitive = true
    }

Si está creando una biblioteca, solo necesita importar el proyecto como importar módulo nuevo.

Tenía una causa diferente del problema, así que para las personas:

repositories {
    mavenCentral()
}

cambie mavenCentral () a jcenter () y agregue

allprojects {
    repositories {
        jcenter()
    }
}

En Android Studio, vaya a la carpeta de aplicaciones internas y abra el archivo build.gradle. Aquí verá dependencias {}. Dentro de él puede agregar el proyecto de biblioteca y sincronizar. Ahora, después de sincronizar la biblioteca, se agregará a su proyecto y podrá usar sus funciones y clases en su proyecto.

Para Android Studio:

Haga clic en Build.gradle (módulo: aplicación) .

Y agregue para

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    compile files('libs/commons-io-2.4.jar')
}

y en su directorio "aplicación", cree un directorio, "libs". Agregue el archivo yourfile.jar:

Finalmente, compile los archivos de Gradle:

También encontré el mismo problema y luego hice lo siguiente.

1. Importo el proyecto de la biblioteca en mi AndroidStudio IDE como un módulo usando el menú Archivo -> Importar menús del módulo

2. Luego fui a mi módulo principal en el que quiero que el proyecto de la biblioteca sea un proyecto dependiente

3. Haga clic derecho en el módulo principal (en mi caso su nombre es aplicación ) -> abra la configuración del módulo -> vaya a la pestaña de dependencias -> haga clic en el botón + (lo obtendrá en el lado derecho de la ventana) -> haga clic en la dependencia del módulo - > seleccione su proyecto de biblioteca de la lista

Aplica los cambios y haz clic en el OKbotón.

Funcionó para mi. Espero que ayude a otros también.

Agregue esto en su archivo de construcción gradle:

 dependencies {
     implementation 'com.jakewharton:butterknife:9.0.0'
}

De hecho, a medida que las versiones cambian, también cambia la interfaz de usuario y las opciones disponibles en el menú. Después de leer la mayoría de las respuestas a estas preguntas, tuve que adivinar qué funcionaría para Android Studio 1.1.0 .

1. Con el mouse, seleccione el proyecto en el nivel principal (aquí es donde muestra el nombre de su aplicación).

2. Haga clic derecho y seleccione las opciones de menú Nuevo, Carpeta, Carpeta de activos .

3. Después de crear la carpeta de activos, péguela o cópiela, sea cual sea el archivo JAR que necesite para su biblioteca.

4. Desde el menú principal de Android Studio (parte superior de la pantalla) seleccione Archivo -> Estructura del proyecto .

5. Luego seleccione el nombre de su proyecto y vaya a la pestaña Dependencias .

6. Haga clic en el signo más ( +) en la esquina inferior izquierda del cuadro de diálogo y seleccione la dependencia del archivo.

7. Finalmente, abra la carpeta de activos creada recientemente, seleccione los archivos JAR que copió y luego haga clic en aplicar y OK.

Limpia y reconstruye tu proyecto.