Como adiciono um projeto de biblioteca ao Android Studio?

Como adiciono um projeto de biblioteca (como Sherlock ABS) ao Android Studio ?

(Não para o antigo pacote configurável baseado no ADT Eclipse, mas para o novo Android Studio .)

Atualização para o Android Studio 1.0

Desde que o Android Studio 1.0 foi lançado (e muitas versões entre a v1.0 e uma das primeiras desde a minha resposta anterior), algumas coisas mudaram.

Minha descrição é focada em adicionar projetos de bibliotecas externas manualmente através de arquivos Gradle (para melhor entender o processo). Se você deseja adicionar uma biblioteca através do criador do Android Studio, basta verificar a resposta abaixo com o guia visual (existem algumas diferenças entre o Android Studio 1.0 e as das capturas de tela, mas o processo é muito semelhante).

Antes de começar a adicionar uma biblioteca ao seu projeto manualmente, considere adicionar a dependência externa. Não vai mexer na estrutura do seu projeto. Quase todas as bibliotecas Android conhecidas estão disponíveis em um repositório Maven e sua instalação requer apenas uma linha de código no app/build.gradlearquivo:

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

Adicionando a biblioteca

Aqui está o processo completo de adição de biblioteca externa do Android ao nosso projeto:

1. Crie um novo projeto via criador do Android Studio. Eu o chamei HelloWorld .
2. Aqui está a estrutura original do projeto criada pelo 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. No diretório raiz ( HelloWorld/), crie uma nova pasta: /libsna qual colocaremos nossas bibliotecas externas (esta etapa não é necessária - apenas para manter uma estrutura de projeto mais limpa).
4. Cole sua biblioteca na /libspasta recém-criada . Neste exemplo, usei a biblioteca PagerSlidingTabStrip (basta baixar o ZIP do GitHub, renomeie o diretório da biblioteca para „PagerSlidingTabStrip" e copie-o). Aqui está a nova estrutura do nosso projeto:

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 adicionando sua biblioteca a include. Se você usar um caminho personalizado como eu, também precisará definir o diretório do projeto para nossa biblioteca. Um settings.gradle inteiro deve se parecer com abaixo:

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

5.1 Se você enfrentar o erro "Configuração padrão", tente isso em vez da etapa 5,

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

6. Em app/build.gradleadicionar o nosso projeto de biblioteca como uma dependência:

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

6.1 Se você seguiu a etapa 5.1, siga esta em vez de 6,

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

        compile project(":libs:PagerSlidingTabStrip")
    }

7. Se o seu projeto de biblioteca não tiver um build.gradlearquivo, você deverá criá-lo manualmente. Aqui está um exemplo desse arquivo:

       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. Além disso, você pode criar uma configuração global para o seu projeto que conterá versões do SDK e criará a versão das ferramentas para cada módulo para manter a consistência. Basta editar o gradle.propertiesarquivo e adicionar linhas:

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

   Agora você pode usá-lo em seus build.gradlearquivos (nos módulos de aplicativos e bibliotecas), como abaixo:

   //...
   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. Isso é tudo. Basta clicar em 'sincronizar o projeto com o ícone Gradle' . Sua biblioteca deve estar disponível em seu projeto.

Google I / O 2013 - O novo Android SDK Build System é uma ótima apresentação sobre a criação de aplicativos Android com o Gradle Build System: como Xavier Ducrohet disse:

O Android Studio tem tudo a ver com edição, depuração e criação de perfil. Não se trata mais de construir.

No começo, pode ser um pouco confuso (especialmente para quem trabalha com o Eclipse e nunca viu a formiga - como eu;)), mas no final, Gradle nos oferece ótimas oportunidades e vale a pena aprender esse sistema de compilação.

Aqui está o guia visual:

Atualização para o Android Studio 0.8.2:

No Android Studio 0.8.2, vá para Estrutura do projeto -> em Módulos, basta clicar no botão mais e selecione Importar projeto existente e importar actionbarsherlock. Em seguida, sincronize seus arquivos Gradle.

Se você enfrentar o erro

Erro: A revisão das ferramentas de compilação do SDK (xx.xx) está muito baixa. O mínimo necessário é aa.aa

basta abrir o build.gradlearquivo no actionbarsherlockdiretório e atualizar buildToolsVersionpara o sugerido.

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

Arquivo de menu -> Estrutura do projeto ... :

Módulo -> Módulo de Importação

Após importar o módulo da biblioteca, selecione o módulo do projeto e inclua a dependência:

E, em seguida, selecione o módulo importado :

Use o menu Arquivo -> Estrutura do projeto -> Módulos .

Comecei a usá-lo hoje. É um pouco diferente.

Para Sherlock, talvez você queira excluir o diretório de teste ou adicionar o junit.jararquivo ao caminho de classe.

Para importar a biblioteca usando o gradle, você pode adicioná-lo à dependenciesseção sua build.gradle(a do módulo).

Por exemplo

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

O Android Studio está mudando.

Existe uma seção chamada "Configurações do módulo aberto" se você clicar com o botão direito do mouse em uma pasta do módulo na seção do projeto do Android Studio (estou usando a versão 0.2.10).

Eu consideraria a leitura necessária de Dependências, Bibliotecas Android e Configuração de vários projetos . Reserve alguns minutos para fazê-lo.

Particularmente, no caso de um projeto de biblioteca que não seja jar, leia o seguinte snippet da fonte acima:

Projetos gradle também podem depender de outros projetos gradle usando uma configuração de vários projetos. Uma configuração de vários projetos geralmente funciona com todos os projetos como subpastas de um determinado projeto raiz.

Por exemplo, dado à seguinte estrutura:

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

Podemos identificar 3 projetos. Gradle fará referência a eles com o seguinte nome:

:app
:libraries:lib1
:libraries:lib2

Cada projeto terá seu próprio build.gradle, declarando como ele é construído. Além disso, haverá um arquivo chamado settings.gradle na raiz que declara os projetos. Isso fornece a seguinte estrutura:

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

O conteúdo de settings.gradle é muito simples:

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

Isso define qual pasta é realmente um projeto Gradle.

É provável que o projeto: app dependa das bibliotecas, e isso é feito declarando as seguintes dependências:

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

Observe que houve pouco ou nenhum uso da GUI do Android Studio para fazer isso acontecer.

Atualmente, estou usando sub - módulos git para vincular a biblioteca aninhada ao repositório git da biblioteca real para evitar uma confusão de dependência.

Acabei de encontrar uma maneira mais fácil (em vez de escrever diretamente nos arquivos .gradle).

Isto é para o Android Studio 1.1.0.

1. Arquivo de menu -> Novo módulo ... :

   

   Clique em "Importar projeto existente".

2. Selecione a biblioteca desejada e o módulo desejado.

3. Clique em Concluir. O Android Studio importará a biblioteca para o seu projeto. Sincronizará arquivos gradle.

4. Adicione o módulo importado às dependências do seu projeto.

   Clique com o botão direito na pasta do aplicativo -> Abrir configurações do módulo -> vá para a guia dependências -> Clique no botão '+' -> clique em Dependência do módulo.

   O módulo da biblioteca será então adicionado às dependências do projeto.

   

5. ???

6. Lucro

A maneira mais fácil que encontrei para incluir projeto de biblioteca externa é (por exemplo, incluir uma biblioteca do Facebook que está armazenada em um diretório na pasta de dependências):

1. Em settings.gradle, adicione

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

2. Na seção dependências build.gradle, inclua

   compile project ('facebook')

Tudo o que resta a fazer é sincronizar o projeto com arquivos gradle.

Uma maneira simples de adicionar um arquivo JAR como uma biblioteca ao seu projeto do Android Studio:

a) Copie seus arquivos * .jar

b) Cole no diretório libs em seus projetos:

c) Adicione ao build.gradle:

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

b) Se o seu projeto do exemplo com.example.MYProject e as bibliotecas com.example.ScanAPI tiverem o mesmo espaço de nomes com.example , o Android Studio verificará sua compilação e criará todas as alterações necessárias em seu projeto. Depois disso, você pode revisar essas configurações no menu Arquivo -> Estrutura do projeto .

c) Se o seu projeto e as bibliotecas tiverem um espaço para nome diferente, clique com o botão direito do mouse na biblioteca e selecione a opção "Adicionar como biblioteca" e selecione o tipo que você precisa.

Lembre-se de que a opção "Estrutura do projeto" não está fazendo alterações automáticas em "build.gradle" na versão atual do Android Studio (0.2.3). Talvez esse recurso esteja disponível nas próximas versões.

Opção 1: Solte arquivos no diretório libs / do projeto

O arquivo build.gradle relevante será atualizado automaticamente.

Opção 2: Modificar o arquivo build.gradle manualmente

Abra o arquivo build.gradle e inclua uma nova regra de construção no fechamento de dependências. Por exemplo, se você quisesse adicionar o Google Play Services, a seção de dependências do seu projeto teria a seguinte aparência:

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

Opção 3: use a interface do usuário do Android Studio

No painel Projeto, Controlclique no módulo ao qual você deseja adicionar a dependência e selecione Abrir configurações do módulo.

Selecione a guia Dependências, seguida pelo botão + no canto inferior esquerdo. Você pode escolher na seguinte lista de opções:

• Dependência da Biblioteca
• Dependência de arquivo
• Dependência do módulo

Você pode inserir mais informações sobre a dependência que deseja adicionar ao seu projeto. Por exemplo, se você escolher Dependência da biblioteca, o Android Studio exibirá uma lista de bibliotecas para você escolher.

Depois de adicionar sua dependência, verifique seu arquivo build.gradle no nível do módulo. Ele deve ter sido atualizado automaticamente para incluir a nova dependência.

Fonte

É assim que funciona para mim no Android Studio 1.5+

No projeto em que você deseja adicionar um projeto de biblioteca externa, vá para o menu Arquivo -> Novo -> * Importar novo módulo **, navegue até o projeto de biblioteca que deseja adicionar ao seu projeto, selecione para adicionar o módulo 'library' em seu projecto. Você obterá settings.gradle em seus projetos, ao lado do aplicativo, na biblioteca incluída, algo como isto:

include ':app', ':library'

Adicione no build.gradle (Módulo: app) na seção dependências:

Projeto de compilação (': library')

Reconstrua o projeto, e é isso.

* Você pode adicionar quantas bibliotecas (módulos) quiser. Nesse caso, em settings.gradle você terá:

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

E no build.gradle, você precisará ter:

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

    // Some other dependencies...

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

Se você precisar acessar os recursos de um projeto de biblioteca (como você faz com o ABS), adicione o projeto / módulo da biblioteca como uma "Dependência do módulo" em vez de uma "Biblioteca".

Você pode fazer isso facilmente. Vá para o menu Arquivo -> Novo -> Módulo de importação ... :

Procure o diretório que contém o módulo. Clique em Concluir:

Vá para Estrutura do projeto e adicione Dependência do módulo :

Nota: Se você receber um erro do SDK, atualize esse.

1. Pressione F4para mostrar a Estrutura do projeto , clique em bibliotecas ou Bibliotecas globais e clique em+ para adicionar o arquivo JAR.
2. Clique em Módulos que você deseja adicionar jar, selecione a guia Dependências , clique em +e adicione Biblioteca.

A edição de dependências da biblioteca por meio da GUI não é aconselhável, pois isso não grava essas alterações no arquivo build.gradle. Portanto, seu projeto não será construído a partir da linha de comando. Devemos editar o arquivo build.gradle diretamente da seguinte maneira.

Por exemplo, dado à seguinte estrutura:

Meu projeto/

• aplicativo/
• bibliotecas /
  • lib1 /
  • lib2 /

Podemos identificar três projetos. Gradle fará referência a eles com os seguintes nomes:

1. :aplicativo
2. : bibliotecas: lib1
3. : bibliotecas: lib2

É provável que o projeto: app dependa das bibliotecas, e isso é feito declarando as seguintes dependências:

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

Para adicionar à resposta: Se o IDE não mostrar nenhum erro, mas quando você tentar compilar, obterá algo como:

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

Seu projeto de biblioteca provavelmente é compilado como um projeto de aplicativo. Para mudar isso, vá para:

Arquivo de menu -> Estrutura do projeto -> Facetas -> [Nome da biblioteca] -> Marque "Módulo da biblioteca".

Primeira maneira Isso está funcionando para o MacBook.

Primeiro, selecione seu arquivo builder.gradle como a tela fornecida:

Adicione dependências como na tela selecionada:

Selecione sincronizar projeto.

Se você estiver recebendo um erro como "O projeto com o caminho ': signature-pad' não foi encontrado no projeto ': app'", use a segunda maneira:

Selecione o menu Arquivo -> Novo -> Importar módulo ... :

Depois de clicar no módulo de importação ,

forneça o caminho da biblioteca como o meu caminho do MacBook:

Clique em Concluir . Agora sua biblioteca foi adicionada.

Depois de importar o Módulo ABS (de Arquivo> Estrutura do projeto) e garantir que o Android 2.2 e a Biblioteca de suporte v4 sejam dependentes, eu ainda estava recebendo o seguinte erro quando você @Alex

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

Eu adicionei o módulo recém-importado como uma dependência ao meu módulo de aplicativo principal e isso corrigiu o problema.

Android Studio 3.0

Basta adicionar o nome da biblioteca ao bloco de dependências do arquivo build.gradle do seu aplicativo .

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

Observe que você deve usar em implementationvez de compileagora. Isso é novo no Android Studio 3.0. Veja estas perguntas e respostas para obter uma explicação da diferença.

Para resolver esse problema, você só precisa adicionar o caminho do recurso abs ao arquivo de construção do projeto, como abaixo:

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

Então, eu compilar novamente sem erros.

Se você possui o Android Studio .0.4.0, pode criar uma nova pasta no caminho da compilação YourApp/libraries. Copie o arquivo JAR. Lá, clique com o botão direito do mouse e em "Adicionar como biblioteca". Agora você tem um pop-up. Basta selecionar seu diretório e pressionar OK, e é isso.

Simplesmente importe o projeto da biblioteca Android como um módulo e no Build.gradle .

Aplicar plugin: 'com.android.library'

Depois disso, siga estas etapas:

1. Clique com o botão direito do mouse em Módulo e selecione Abrir configurações do módulo
2. Selecione dependências, clique em +, selecione dependências da biblioteca e adicione o módulo importado anteriormente.

https://www.dropbox.com/s/1e3eteu3h0pmkf7/Android%20studio%20_doc.doc?dl=0 é o link do Dropbox de como adicionar um projeto de arquivo e biblioteca JAR na versão mais recente do Android Studio 1.0.1.

Por favor, consulte a documentação com capturas de tela. É muito fácil para um novo usuário.

Eu encontrei a solução. É tão simples. Siga as instruções froger_mcs .

Certifique-se de transformar a pasta src em uma pasta Source em Estrutura do projeto -> Módulos (fontes).

Basicamente, você pode incluir seus arquivos JAR de três maneiras diferentes. A última é a biblioteca remota que está usando o https://bintray.com/ jcenter repositório online. Mas, se você fizer isso de uma das duas outras maneiras, o arquivo JAR será incluído fisicamente no seu projeto. Por favor, leia este link https://stackoverflow.com/a/35369267/5475941 para obter mais informações. Neste post, expliquei como importar seu arquivo JAR no Android studio e expliquei todas as maneiras possíveis.

Em resumo, se é assim (endereço local), eles são baixados e esses arquivos JAR estão fisicamente no projeto:

Mas, se for um endereço da Internet como este, elas são bibliotecas remotas (parte bintray.com jcenter) e serão usadas remotamente:

Espero que ajude.

Abra o arquivo do aplicativo build gradle module e adicione sua dependência. Se você baixar a biblioteca, basta importar e construir como gradle.

Caso contrário, adicione repositórios no aplicativo side gradle module:

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

Os primeiros repositórios farão o download da biblioteca para você.

E compile a biblioteca baixada:

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

Se você estiver criando uma biblioteca, basta importar o projeto como importar novo módulo.

Eu tinha uma causa diferente do problema, então para as pessoas:

repositories {
    mavenCentral()
}

altere mavenCentral () para jcenter () e adicione

allprojects {
    repositories {
        jcenter()
    }
}

No Android Studio, acesse a pasta do aplicativo e abra o arquivo build.gradle. Aqui você verá dependências {}. Dentro dele, você pode adicionar o projeto da biblioteca e sincronizar. Agora, depois de sincronizar a biblioteca, ela será adicionada ao seu projeto e você poderá usar suas funções e classes no seu projeto.

Para o Android Studio:

Clique em Build.gradle (module: app) .

E adicione para

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

e em seu diretório "app", crie um diretório "libs". Adicione o arquivo yourfile.jar:

Por fim, compile os arquivos Gradle:

Eu também encontrei o mesmo problema, depois fiz as seguintes coisas.

1. Importo o projeto da biblioteca no meu AndroidStudio IDE como um módulo usando o menu Arquivo -> Importar menus do módulo

2. Então eu fui ao meu módulo principal no qual eu quero o projeto da biblioteca como um projeto dependente

3. Clique com o botão direito do mouse no módulo principal (no meu caso, seu nome é app ) -> abra a configuração do módulo -> vá para a guia dependências -> clique no botão + (você o encontrará no lado direito da janela) -> clique na dependência do módulo - > selecione seu projeto de biblioteca da lista

Aplique as alterações e clique no OKbotão

Funcionou para mim. Espero que ajude os outros também.

Adicione isso no seu arquivo gradle de compilação:

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

De fato, conforme as versões estão mudando, o mesmo acontece com a interface do usuário e as opções disponíveis no menu. Depois de ler a maioria das respostas para essas perguntas, tive que adivinhar o que funcionaria para o Android Studio 1.1.0 .

1. Com o mouse, selecione o projeto no nível principal (é aqui que ele mostra o nome do seu aplicativo).

2. Clique com o botão direito e selecione as opções de menu Novo, Pasta, Pasta de ativos .

3. Após criar a pasta de ativos, cole ou copie nela, qualquer arquivo JAR necessário para sua biblioteca.

4. No menu principal do Android Studio (parte superior da tela), selecione Arquivo -> Estrutura do projeto .

5. Em seguida, selecione o nome do seu projeto e vá para a guia Dependências .

6. Clique no sinal de mais ( +) no canto inferior esquerdo da caixa de diálogo e selecione a dependência do arquivo.

7. Por fim, abra a pasta de ativos criada recentemente, selecione os arquivos JAR que você copiou e clique em aplicar e OK.

Limpe e reconstrua seu projeto.