Como adiciono um projeto de biblioteca ao Android Studio?

Alexander Kulyakhtin 08/22/2017. 29 answers, 544.786 views
android android actionbarsherlock android-library android-studio android-studio

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

(Não para o antigo pacote baseado em Eclipse do ADT, mas para o novo Android Studio .)

4 Comments
25 Daniel Smith 05/21/2013
Sim, descobrir isso era muito mais confuso do que deveria ... não era como se fosse melhor no eclipse.
3 user1785900 01/19/2014
O vídeo do YouTube How to Add Libraries to Android Studio explica o processo.
1 craned 10/16/2014
Se você estiver usando o Gradle , veja esta resposta do StackOverflow .
1 Simon 12/20/2014
Aqui está um vídeo que eu achei muito útil: youtube.com/watch?v=1MyBO9z7ojk

29 Answers


froger_mcs 05/23/2017.

Update for Android Studio 1.0

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

Minha descrição é focada em adicionar manualmente o projeto de biblioteca externa via arquivos Gradle (para entender melhor o processo). Se você quiser adicionar uma biblioteca por meio do criador do Android Studio, verifique a resposta abaixo com um guia visual (há algumas diferenças entre o Android Studio 1.0 e as de 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 atrapalhar a estrutura do seu projeto. Quase todas as bibliotecas conhecidas do Android estão disponíveis em um repositório Maven e sua instalação usa apenas uma linha de código no arquivo app/build.gradle :

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

Adding the library

Aqui está o processo completo de adicionar biblioteca Android externa ao nosso projeto:

  1. Crie um novo projeto por meio do criador do Android Studio. Eu 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
      ... 
  1. No diretório raiz ( HelloWorld/ ), crie uma nova pasta: /libs na qual colocaremos nossas bibliotecas externas (essa etapa não é necessária - apenas para manter uma estrutura de projeto mais limpa).
  2. Cole sua biblioteca na pasta recém-criada /libs . Neste exemplo eu usei a biblioteca PagerSlidingTabStrip (apenas baixe 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
      ... 
  1. Edite settings.gradle adicionando sua biblioteca para include . Se você usar um caminho personalizado como eu fiz, também terá que definir o diretório do projeto para nossa biblioteca. Um todo settings.gradle deve se parecer abaixo:

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

5.1 Se você encontrar o erro "Configuração padrão", tente isto em vez do passo 5,

include ':app'
    include ':libs:PagerSlidingTabStrip' 
  1. Em app/build.gradle adicione 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 o passo 5.1, então siga isto ao invés de 6,

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

        compile project(":libs:PagerSlidingTabStrip")
    } 
  1. Se o seu projeto de biblioteca não tiver o arquivo build.gradle 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']
                }
            }
        } 
  2. Além disso, você pode criar uma configuração global para o seu projeto, que conterá versões do SDK e criará versões de ferramentas para cada módulo para manter a consistência. Basta editar o arquivo gradle.properties 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 arquivos build.gradle (nos módulos app 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)
        }
    }
    //... 
  3. Isso é tudo. Basta clicar em ‚sincronizar o projeto com o ícone do Gradle ' sincronizar com 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 para Android com o Gradle Build System: como disse Xavier Ducrohet:

O Android Studio é tudo sobre edição, depuração e criação de perfil. Não se trata de construir mais.

No começo, pode ser um pouco confuso (especialmente para aqueles que trabalham com Eclipse e nunca viram a formiga como eu;)), mas no final a Gradle nos dá ótimas oportunidades e vale a pena aprender esse sistema de construção.

5 comments
6 victor n. 05/24/2013
Ei, você explicou perfeitamente a questão real. Votando sua resposta para que outras pessoas possam ver. Uma pequena coisa que não funcionou do meu lado é referenciar a biblioteca de suporte no build.gradle da dependência. como acontece ': Project / libs ...' não funcionou por algum motivo. Eu tive que acabar com a identificação do projeto. então 'libs / ...'. e compilou bem. Uma observação é que essas duas formas de referenciar caminhos ou projetos são confusas. Espero que surja um esquema simples e unificado no futuro. Não há razão para que a solução original não funcione.
9 Akbar ibrahim 05/24/2013
+1. Estava lutando com isso por um longo tempo. Como venceu, referenciar o jar de suporte do projeto principal do módulo actionbarsherlock não funciona. Eu tive que fazer o seguinte para fazê-lo funcionar ... (1) Remova os arquivos de compilação ('libs / android-support-v4.jar') do build.gradle do projeto. O módulo principal deve ter apenas o projeto de compilação (": libraries: actionbarsherlock") . (2) Adicione arquivos de compilação ('libs / android-support-v4.jar') em vez de arquivos de compilação (': HelloWorld / libs / android-support-v4.jar') em build.gradle do actionbarsherlock.
8 alicanbatur 11/07/2013
Por que não tenho a seção "Módulo de Importação", na opção em que você nos direciona? Estou usando o Android Studio 0.3.1
5 amalBit 02/08/2014
A opção Import Module está faltando !!
147 Kyle Gobel 10/19/2014
Por que isso é tão incrivelmente confuso ?!

Sam Rad 07/01/2016.

Aqui está o guia visual:

Update para o Android Studio 0.8.2:

No Android Studio 0.8.2, vá para Project Structure -> em Modules basta pressionar o botão mais e selecionar Import Existing Project e importar actionbarsherlock . Em seguida, sincronize seus arquivos Gradle.

Se você enfrentar o erro

Erro: A revisão das Ferramentas de Construção do SDK (xx.xx) está muito baixa. O mínimo requerido é yy.yy

basta abrir o arquivo build.gradle no diretório actionbarsherlock e atualizar o buildToolsVersion para o sugerido.

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

Android Studio 0.8.2


File Menu -> Project Structure... :

Primeiro

Module -> Import Module

Segundo

Depois de importar o módulo da biblioteca, selecione your módulo de projeto e adicione a dependência:

Terceiro

E, em seguida, selecione o imported module :

Adiante

5 comments
29 amalBit 02/08/2014
Opção de módulo de importação não disponível no Android Studio4.3
3 toobsco42 08/25/2014
A chave para eu fazer isso funcionar e resolver os erros do pacote não encontrado foi a etapa Select your project module and add dependency dependencies { // ... compile project(':library') }
6 Rémy DAVID 10/06/2014
Isso copiará o módulo de biblioteca em seu projeto, que não é o que você deseja se você quiser uma base de código comum compartilhada entre vários projetos
CCJ 11/13/2015
@amalBit são ... você é do futuro? Mas, falando sério, eles precisam simplificar isso como no Eclipse ADT; Quem quer bater um repo de terceiros e compilar (potencialmente) código arbitrário em cada compilação? Isso compromete seriamente os protocolos de controle de qualidade e de congelamento de código
amalBit 11/17/2015
Foi caminho de volta durante os dias beta do estúdio Android 0.4.3. Quanto à adesão repo de terceiros, id dizer, evite usar +. Basta especificar a versão desejada. Se você ainda não pode confiar o suficiente, você pode criar um jar (ou clone) de qualquer repo e usá-lo.

Blackbelt 07/01/2016.

Use o menu File -> Project Structure -> Modules .

Eu comecei a usá-lo hoje. É um pouco diferente.

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

Para importar a biblioteca usando gradle, você pode ter que adicioná-lo à seção de dependencies do seu build.gradle (o 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 "Abrir configurações do módulo" 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).

5 comments
1 Alexander Kulyakhtin 05/16/2013
Hmm ainda diz android-apt-compiler: styles.xml: 5: error: Erro ao recuperar o pai para o item: Nenhum recurso encontrado que corresponde ao nome dado 'Theme.Sherlock.Light.DarkActionBar'.
Blackbelt 05/16/2013
Sob o Módulo Sherlock -> Dependências eu tenho android 4.2.2 e suporte a Biblioteca v4
Blackbelt 05/16/2013
@ ρяσѕρєяK ao lado do botão de execução, há um rótulo com o Android. Se você clicar aqui, você encontrará Editar configuração. Empurrar e sob o dispositivo de destino, clique em "Mostrar Seletor de Seletor"
7 fish 05/16/2013
Oi, eu tenho o mesmo problema como Alex ("Gradle: Erro ao recuperar pai para o item: Nenhum recurso encontrado que corresponda ao nome dado 'Theme.Sherlock.Light'.") - a dependência Java parece ser resolvido corretamente, causar o A IDE não culpa minha SherlockActivity, mas por alguma razão, Gradle não parece olhar para os recursos do ABS. Alguma ideia?
4 Konrad Morawski 09/15/2013
No Android Studio 0.2.8 não há seção Modules na janela Project Structure do Project Structure .

Jonathan Lin 10/14/2013.

Eu consideraria Dependências, Bibliotecas Android e configuração necessária para vários projetos . Por favor, dedique alguns minutos para isso.

Particularmente, no caso de um projeto de biblioteca não-jar, leia o seguinte trecho da fonte acima:

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

Por exemplo, dado a seguinte estrutura:

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

Podemos identificar 3 projetos. Gradle irá referenciá-los 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 dá a seguinte estrutura:

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

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

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

Isso define qual pasta é realmente um projeto Gradle.

O projeto: app provavelmente depende das bibliotecas, e isso é feito declarando as seguintes dependências:

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

Por favor, note que houve pouca ou nenhuma utilização da GUI do Android Studio para que isso aconteça.

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

4 comments
Jonathan Lin 10/14/2013
Por favor, revise se você achou isso útil, para que os outros possam evitar a dor e se mover mais rápido.
RichieHH 03/24/2014
Muito útil e, mais importante, não jogar para os caprichos gui do dia.
1 dcunited001 04/20/2014
muito obrigado por incluir a única resposta que faz sentido. todas as outras respostas estão desatualizadas e simplesmente não funcionam. Eu nem tentei em CS na Virginia Tech porque os primeiros dois anos estavam aprendendo a fckn clicar em eclipse. Não fazia sentido, mas ver o resultado gradle de cliques aleatórios em um IDE faz.
velis 06/01/2015
Obrigado pela dica de submodules git. Eu estava usando a junção antes, mas agora mudei para as externas do SVN. Funciona como um encanto.

René Michel 07/01/2016.

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. File Menu -> New Module... :

    Importar projeto existente

    Clique em "Importar projeto existente".

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

  3. Clique em terminar. O Android Studio importará a biblioteca para o seu projeto. Ele irá sincronizar os arquivos gradle.

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

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

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

    Adicionar módulo de biblioteca

  5. ???

  6. Lucro


Vilen 07/01/2016.

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

  1. Em settings.gradle add

    include ':facebook'
    
    project(':facebook').projectDir = new File(settingsDir, '../dependencies/FacebookSDK') 
  2. Na seção de dependências build.gradle, adicione

    compile project ('facebook') 

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

4 comments
Rajnish Mishra 03/23/2015
Oi Vilen o que é settingsDir aqui
Vilen 04/02/2015
Oi Rajnish Da documentação: settingsDir Retorna o diretório de configurações da compilação. O diretório de configurações é o diretório que contém o arquivo de configurações. Retorna: O diretório de configurações. Nunca retorna null.
Rajnish Mishra 04/03/2015
Os dois pontos antes / dependências são mais importantes para serem atendidos Sua resposta me ajuda muito .. Obrigado
Solata 11/18/2015
NOTE: para avaliação de strings em gradle você deve usar aspas duplas ("). Isso" salva o dia "para mim.

Eugene Bosikov 07/01/2016.

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 sob seus projetos:

Digite a descrição da imagem aqui

c) Adicionar ao build.gradle:

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

b) Se o seu projeto do exemplo com.example.MYProject e bibliotecas com.example.ScanAPI tiverem o mesmo namespace 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 File -> Project Structure .

c) Se o seu projeto e bibliotecas tiverem um namespace diferente, você deve clicar com o botão direito na biblioteca e selecionar a opção "Add as Library" e selecionar o tipo de que você precisa.

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


pathe.kiran 06/27/2016.

Opção 1: Soltar 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 seu arquivo build.gradle e inclua uma nova regra de construção no encerramento de dependências. Por exemplo, se você quiser adicionar o Google Play Services, a seção de dependências do seu projeto será semelhante a esta:

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

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

No painel Project, Control + clique no módulo ao qual você deseja adicionar a dependência e selecione Open Module Settings.

Digite a descrição da imagem aqui

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

  • Dependência de 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 de 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 de módulo. Ele deve ter atualizado automaticamente para incluir a nova dependência.

Fonte


drewan50 07/01/2016.

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

1 comments
1 cosimo 04/01/2014
Sim! Você senhor ganha a Internet! Obrigado! Acabei de perder algumas horas da minha vida porque não sabia disso.

pandabear 07/01/2016.

É assim que funciona para mim no Android Studio 1.5

No projeto onde você deseja adicionar um projeto de biblioteca externa, vá ao menu File -> New -> * Importar Novo Módulo **, navegue até o projeto da biblioteca que você deseja adicionar ao seu projeto, selecione para adicionar o módulo 'biblioteca' no seu projecto. Você vai ter settings.gradle em seus projetos, ao lado de app, biblioteca incluída, algo assim:

include ':app', ':library' 

Adicione build.gradle(Module :app) na seção de dependências:

Compile project(':library')

Reconstrua o projeto e pronto.

* Você pode adicionar quantas bibliotecas (módulos) desejar. 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')
    ...
} 

Adiii 07/01/2016.

Você pode fazer isso facilmente. Vá para o menu File -> New -> Import Module... :

Digite a descrição da imagem aqui

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

Digite a descrição da imagem aqui

Vá para Project Structure e adicione Module Dependency :

Digite a descrição da imagem aqui

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


Dalmas 06/27/2016.

Para adicionar à resposta: Se o IDE não mostrar nenhum erro, mas quando você tentar compilar, você terá 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:

File Menu -> Project structure -> Facets -> [Nome da Biblioteca] -> Verificar "Módulo Biblioteca".


crossle 07/01/2016.
  1. Pressione F4 para mostrar a Project Structure , 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 Dependencies , clique em + e adicione Biblioteca.

Shakti Malik 07/01/2016.

A edição de dependências de bibliotecas através da GUI não é aconselhável, pois não grava essas alterações em seu arquivo build.gradle. Portanto, seu projeto não será criado a partir da linha de comando. Devemos editar o arquivo build.gradle diretamente da seguinte maneira.

Por exemplo, dado a seguinte estrutura:

Meu projeto/

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

Podemos identificar três projetos. Gradle irá referenciá-los com os seguintes nomes:

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

O projeto: app provavelmente depende das bibliotecas, e isso é feito declarando as seguintes dependências:

dependencies {
    compile project(':libraries:lib1')
} 
2 comments
Alexander Kulyakhtin 05/23/2013
Mesmo? Estranho, eles têm todo o GUI e ainda não é aconselhável. Como assim?
Shakti Malik 05/23/2013
Como a edição através da GUI não grava essas alterações no seu arquivo build.gradle. A edição da GUI apenas salva as alterações nos dados do próprio projeto do IntelliJ. Este é um bug no momento que será corrigido em versões futuras. Você pode consultar essa resposta com o Lead de equipe do Google Android-Studio stackoverflow.com/questions/16678447/…

Erwan 05/17/2013.

Depois de importar o módulo ABS (de File> Project Structure) e ter certeza de que ele tem o Android 2.2 e a Support Library v4 como dependências, 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 do meu módulo principal de aplicativo e resolvi o problema.

3 comments
christiaanderidder 05/19/2013
Eu tentei todas as etapas inclusing adicionando o módulo como uma dependência, mas eu ainda tenho Gradle: Error retrieving parent for item: No resource found that matches the given name 'Theme.Sherlock.Light'. . Parece que meu projeto principal não vê os recursos do projeto da biblioteca (ABS). O IDE, no entanto, reconhece as referências a classes e recursos. Screenshot
Calvin Chan 06/04/2013
O mesmo aqui. Quem pode resolver isso?
Dmitriy Tarasov 06/06/2013
Eu estou migrar para IDEA 13 de 12 e tenho esse erro também. Apenas a reimportação de todas as minhas dependências ajudará. Remova manualmente todos os módulos, remova os arquivos * .iml relacionados e importe novamente suas bibliotecas

azh 02/09/2014.

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

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

Então, eu novamente compilar sem erros.


Hemant 07/01/2016.

First Way Isso está funcionando para o MacBook.

Primeiro, selecione seu arquivo builder.gradle como uma tela:

Digite a descrição da imagem aqui

Adicione dependências como na tela selecionada:

Digite a descrição da imagem aqui

Selecione o projeto de sincronização.

Se você está recebendo um erro como "Projeto com caminho": o bloco de assinatura 'não pôde ser encontrado no projeto': app '", use a segunda maneira:

Selecione o menu File -> New -> Import Module... :

Digite a descrição da imagem aqui

Depois de clicar em Import Module ,

Digite a descrição da imagem aqui

dar o caminho da biblioteca como o meu caminho MacBook:

Digite a descrição da imagem aqui

Clique em Finish . Agora sua biblioteca foi adicionada.


Braunster 02/09/2014.

Se você tiver o Android Studio .0.4.0, poderá criar uma nova pasta em seu caminho de construção, YourApp/libraries . Copie o arquivo JAR. Lá, clique com o botão direito e "Add As Library". Agora você tem um pop-up. Basta selecionar o seu diretório e pressione OK, e é isso.


ankitbumblebee 07/01/2016.

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

Por favor, veja a documentação com screenshots. É muito fácil para um novo usuário.


passsy 05/23/2017.

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

Certifique-se de fazer da pasta src uma pasta Source em Project Structure -> Modules (Sources).

Digite a descrição da imagem aqui


voghDev 05/23/2017.

Um exemplo de adição com êxito de outra biblioteca (PullToRefresh). Também trabalha para o libproject do ABS.

Esta pergunta SO

Esta postagem


Mohammad 05/23/2017.

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

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

insira a descrição da imagem aqui

Mas, se é um endereço de internet como este, eles são bibliotecas remotas (bintray.com jcenter part) e eles serão usados ​​remotamente:

insira a descrição da imagem aqui

Espero que ajude.


Jinu 06/27/2016.

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

Caso contrário, adicione repositórios no aplicativo do módulo Gradle Side:

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

Os primeiros repositórios irão baixar a 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 novo módulo de importação.


Dharmendra Pratap 06/27/2016.

No Android Studio, vá para a pasta do aplicativo e abra o arquivo build.gradle. Aqui você verá as 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 em seu projeto.


MAMASSI 07/01/2016.

Para o Android Studio:

Digite a descrição da imagem aqui

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 no seu diretório "app", crie um diretório, "libs". Adicione o arquivo yourfile.jar:

Digite a descrição da imagem aqui

Por fim, compile os arquivos Gradle:

Digite a descrição da imagem aqui

1 comments
Badre 03/23/2016
cara respeito: D

Pankaj kumar 07/01/2016.

Basta importar o projeto da biblioteca do 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 no módulo e selecione as configurações do módulo aberto
  2. Selecione dependências, clique em + , selecione as dependências da biblioteca e adicione o módulo importado anteriormente.

jobbert 07/01/2016.

Eu tive uma causa diferente do problema para as pessoas:

repositories {
    mavenCentral()
} 

altere mavenCentral () para jcenter () e adicione

allprojects {
    repositories {
        jcenter()
    }
} 

Eu também encontrei o mesmo problema, então eu fiz as seguintes coisas.

  1. Eu importo o projeto da biblioteca para o meu IDE do AndroidStudio como um módulo usando o menu File -> Importar menus do módulo

  2. Então eu fui para o meu módulo principal em que eu quero o projeto da biblioteca como um projeto dependente

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

Aplique as alterações e clique no botão OK .

Isso funcionou para mim. Espero que ajude os outros também.


monn3t 07/01/2016.

De fato, conforme as versões estão mudando, também está mudando a interface do usuário e as opções disponíveis no menu. Depois de ler a maioria das respostas a 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 (é onde ele mostra o nome do seu aplicativo).

  2. Clique com o botão direito e selecione as opções de menu New, Folder, Assets Folder .

  3. Depois de criar a pasta de recursos, cole ou copie nela, seja qual for o arquivo JAR necessário para sua biblioteca.

  4. No menu principal do Android Studio (parte superior da tela), selecione File -> Project Structure .

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

  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 recém-criada, selecione os arquivos JAR que você copiou e, em seguida, clique em aplicar e em OK .

Limpe e reconstrua seu projeto.

2 comments
1 Rajnish Mishra 03/23/2015
fazer cópias de potes em ativos não é uma boa ideia, aumentará desnecessariamente o tamanho do apk
monn3t 04/12/2015
Obrigado pelo conselho @RajnishMishra. Eu suspeitava disso, mas o que você propõe?

Related questions

Hot questions

Language

Popular Tags