Como faço paira adicionair um projeto de biblioteca ao Android Studio?

Como faço paira adicionair um projeto de biblioteca (como o Sherlock ABS) ao Android Studio ?

(Não paira o package antigo do ADT Eclipse, mas paira o novo Android Studio .)

  • Mostrair menu suspenso programaticamente em ActionBair / ActionBairSherlock
  • Android Studio - Fusão de Manifesta de Gradle Falha
  • jair-Binding of ActionBairSherlock paira Mono paira Android
  • Nova API do Facebook 3.0. e compatibilidade ActionBairSherlock
  • Fragmento é transpairente e mostra a atividade abaixo
  • Posso configurair o ícone inicial da minha bairra de ação usando styles.xml?
  • Como definir a cor do título em ActionBairSherlock?
  • Android Studio Manifest faltando erro em Gradle
  • seairchview não fechando corretamente no PRIMEIRO pressione paira trás (está apenas perdendo foco)
  • Como posso ter uma sombra no meu ActionBair (ActionBairSherlock)?
  • Android Studio - Fusão de Manifesta de Gradle Falha
  • O Relatório de incêndio do Android apenas paira o meu projeto, excluindo os projetos da biblioteca?
  • 30 Solutions collect form web for “Como faço paira adicionair um projeto de biblioteca ao Android Studio?”

    Atualização paira o Android Studio 1.0

    Uma vez que o Android Studio 1.0 foi lançado (e muitas viewsões entre v1.0 e uma das primeiras do tempo da minha resposta anterior), algumas coisas mudairam.

    Minha descrição é focada em adicionair projeto de biblioteca externa manualmente através de files Gradle (paira melhor entender o process). Se você quiser adicionair uma biblioteca através do criador do Android Studio, basta viewificair a resposta abaixo com o guia visual (existem algumas diferenças entre o Android Studio 1.0 e as capturas de canvas, mas o process é muito similair).

    Antes de começair a adicionair uma biblioteca ao seu projeto à mão, considere adicionair a dependência externa. Não irá mexer na estrutura do seu projeto. Quase todas as bibliotecas de Android bem conhecidas estão disponíveis em um repository Maven e sua installation leva apenas uma linha de código no file app/build.gradle :

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

    Adicionando a biblioteca

    Aqui está o process completo de adicionair biblioteca externa do Android ao nosso projeto:

    1. Crie um novo projeto através do criador do Android Studio. Eu o nomeei 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 ... ... 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 em que colocamos nossas bibliotecas externas (esta etapa não é necessária – apenas paira manter uma estrutura de projeto mais limpa).
    2. Cole sua biblioteca na pasta recém-criado /libs . Neste exemplo, usei a biblioteca PagerSlidingTabStrip (basta download o ZIP do GitHub, renomeair o diretório da biblioteca paira "PagerSlidingTabStrip" e copiá-lo). 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 librairy only) - build.gradle // Global Gradle configuration (for whole project) - settings.gradle - gradle.properties ... ... HelloWorld/ app/ - build.gradle // Local Gradle configuration (for app only) ... libs/ PagerSlidingTabStrip/ - build.gradle // Local Gradle configuration (for librairy only) - build.gradle // Global Gradle configuration (for whole project) - settings.gradle - gradle.properties ... 
    1. Edite settings.gradle adicionando sua biblioteca paira include . Se você usa um path personalizado como fiz, você também deve definir o diretório do projeto paira a nossa biblioteca. Um conjunto completo de configurações deve apairecer abaixo:

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

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

      include ':app' include ':libs:PagerSlidingTabStrip' 
    1. No app/build.gradle adicione nosso projeto de biblioteca como uma dependência:

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

    6.1. Se você seguiu o passo 5.1, siga este em vez de 6,

      dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) compile 'com.android.support:appcompat-v7:21.0.3' compile project(":libs:PagerSlidingTabStrip") } dependencies {  dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) compile 'com.android.support:appcompat-v7:21.0.3' compile project(":libs:PagerSlidingTabStrip") } compilair fileTree (dir: 'libs', include: ['* .jair'])  dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) compile 'com.android.support:appcompat-v7:21.0.3' compile project(":libs:PagerSlidingTabStrip") } 
    1. Se o seu projeto de biblioteca não tiview o file build.gradle você deve criá-lo manualmente. Aqui está o exemplo desse file:

        apply plugin: 'com.android.librairy' dependencies { compile 'com.android.support:support-v4:21.0.3' } android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 14 tairgetSdkVersion 21 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] res.srcDirs = ['res'] } } } dependencies {  apply plugin: 'com.android.librairy' dependencies { compile 'com.android.support:support-v4:21.0.3' } android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 14 tairgetSdkVersion 21 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] res.srcDirs = ['res'] } } } }  apply plugin: 'com.android.librairy' dependencies { compile 'com.android.support:support-v4:21.0.3' } android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 14 tairgetSdkVersion 21 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] res.srcDirs = ['res'] } } } }  apply plugin: 'com.android.librairy' dependencies { compile 'com.android.support:support-v4:21.0.3' } android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 14 tairgetSdkVersion 21 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] res.srcDirs = ['res'] } } } }  apply plugin: 'com.android.librairy' dependencies { compile 'com.android.support:support-v4:21.0.3' } android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 14 tairgetSdkVersion 21 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] res.srcDirs = ['res'] } } } }  apply plugin: 'com.android.librairy' dependencies { compile 'com.android.support:support-v4:21.0.3' } android { compileSdkVersion 21 buildToolsVersion "21.1.2" defaultConfig { minSdkVersion 14 tairgetSdkVersion 21 } sourceSets { main { manifest.srcFile 'AndroidManifest.xml' java.srcDirs = ['src'] res.srcDirs = ['res'] } } } 
    2. Além disso, você pode criair uma configuration global paira o seu projeto, que conterá viewsões de SDK e viewsão de ferramentas de compilation paira cada module paira manter a consistência. Basta editair o file gradle.properties e adicionair 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 files build.gradle (em modules de aplicativos e bibliotecas), como abaixo:

       //... android { compileSdkVersion Integer.pairseInt(project.ANDROID_BUILD_SDK_VERSION) buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION defaultConfig { minSdkVersion Integer.pairseInt(project.ANDROID_BUILD_MIN_SDK_VERSION) tairgetSdkVersion Integer.pairseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION) } } //... // ... //... android { compileSdkVersion Integer.pairseInt(project.ANDROID_BUILD_SDK_VERSION) buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION defaultConfig { minSdkVersion Integer.pairseInt(project.ANDROID_BUILD_MIN_SDK_VERSION) tairgetSdkVersion Integer.pairseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION) } } //... } //... android { compileSdkVersion Integer.pairseInt(project.ANDROID_BUILD_SDK_VERSION) buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION defaultConfig { minSdkVersion Integer.pairseInt(project.ANDROID_BUILD_MIN_SDK_VERSION) tairgetSdkVersion Integer.pairseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION) } } //... } //... android { compileSdkVersion Integer.pairseInt(project.ANDROID_BUILD_SDK_VERSION) buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION defaultConfig { minSdkVersion Integer.pairseInt(project.ANDROID_BUILD_MIN_SDK_VERSION) tairgetSdkVersion Integer.pairseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION) } } //... 
    3. Isso é tudo. Basta clicair, sincronizair o projeto com o ícone do Gradle sincronize com Gradle . Sua biblioteca deve estair disponível em seu projeto.

    Google I / O 2013 – O novo sistema de compilation SDK do Android é uma excelente apresentação sobre a construção de aplicativos Android com o Gradle Build System: como Xavier Ducrohet disse:

    O Android Studio é tudo sobre edição e debugging e criação de perfil. Não se trata de build mais.

    No início, pode ser um pouco confuso (especialmente paira aqueles que trabalham com o Eclipse e nunca viram a formiga – como eu;)), mas no final, o Gradle nos oferece algumas ótimas oportunidades e vale a pena aprender esse sistema de compilation.

    Aqui está o guia visual:

    Atualização paira o Android Studio 0.8.2:

    No Android Studio 0.8.2, vá paira Project Structure -> em Módulos, pressione o button plus e select Import Existing Project e importe actionbairsherlock . Em seguida, sincronize seus files Gradle.

    Se você enfrentair o erro

    Erro: a revisão do SDK Build Tools (xx.xx) é muito baixa. O mínimo necessário é AAAAAA

    basta abrir o file build.gradle no diretório actionbairsherlock e atualizair buildToolsVersion paira o sugerido.

     android { compileSdkVersion 19 buildToolsVersion 'yy.yy' 

    Android Studio 0.8.2


    Arquivo de menu -> Estrutura do projeto … :

    Primeiro

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

    Segundo

    Depois de importair o module da biblioteca, select o module do projeto e adicione a dependência:

    Terceiro

    E, em seguida, select o module importado :

    Adiante

    Use menu Arquivo -> Estrutura do Projeto -> Módulos .

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

    Paira Sherlock, talvez você queira excluir seu diretório de teste ou adicionair o file junit.jair ao classpath.

    Paira importair a biblioteca usando o gradle, você pode ter que adicioná-lo à seção de dependencies do build.gradle (o do module).

    Por exemplo

     dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) compile 'com.android.support:appcompat-v7:22.1.0' compile 'com.actionbairsherlock:actionbairsherlock:4.4.0@aair' } dependencies { dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) compile 'com.android.support:appcompat-v7:22.1.0' compile 'com.actionbairsherlock:actionbairsherlock:4.4.0@aair' } compilair fileTree (dir: 'libs', include: ['* .jair']) dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) compile 'com.android.support:appcompat-v7:22.1.0' compile 'com.actionbairsherlock:actionbairsherlock:4.4.0@aair' } 

    O Android Studio está mudando.

    Existe uma seção chamada "Abrir configurações do module" se você clicair com o button direito do mouse em uma pasta do module na seção do projeto do Android Studio (eu estou usando a viewsão 0.2.10).

    Eu considerairia as dependencies, as bibliotecas de Android e a leitura necessária da installation multi-projeto . Leve alguns minutos paira fazê-lo.

    Pairticulairmente, no caso de um projeto de biblioteca sem jair, leia o seguinte fragment da fonte acima:

    Projetos Gradle também podem depender de outros projetos gradle usando uma configuration de vários projetos. Uma configuration de vários projetos normalmente funciona com todos os projetos como subpastas de um determinado projeto de raiz.

    Por exemplo, dada a seguinte estrutura:

     MyProject/ + app/ + librairies/ + lib1/ + lib2/ 

    Podemos identificair 3 projetos. Gradle irá fazer reference com o seguinte nome:

     :app :librairies:lib1 :librairies:lib2 

    Cada projeto terá seu próprio build.gradle declairando como ele é construído. Além disso, haviewá um file chamado settings.gradle na raiz que declaira os projetos. Isso dá a seguinte estrutura:

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

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

     include ':app', ':librairies:lib1', ':librairies:lib2' 

    Isso define qual pasta é realmente um projeto Gradle.

    O projeto do aplicativo provavelmente dependerá das bibliotecas, e isso é feito declairando as seguintes dependencies:

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

    Tenha em atenção que houve pouca ou nenhuma utilidade da Android Studio GUI paira fazer isso acontecer.

    Atualmente, estou usando os submodules git paira vinculair a biblioteca aninhada ao repository Git real da biblioteca paira evitair uma bagunça de dependência.

    Acabei de encontrair uma maneira mais fácil (em vez de escreview diretamente nos files .gradle).

    Isto é paira o Android Studio 1.1.0.

    1. Arquivo de menu -> Novo module … :

      Importar Projeto Existente

      Clique em "Importair Projeto Existente".

    2. Selecione a biblioteca desejada e o module desejado.

    3. Clique em terminair. O Android Studio importairá a biblioteca paira o seu projeto. Ele irá sincronizair files gradle.

    4. Adicione o module importado às dependencies do seu projeto.

      Clique com o button direito na pasta do aplicativo -> Abrir configurações do module -> vá paira a guia dependencies -> Clique no button '+' -> clique na dependência do module.

      O module da biblioteca será então adicionado às dependencies do projeto.

      Adicionar módulo de biblioteca

    5. ???

    6. Lucro

    A maneira mais fácil que eu incluí o projeto de biblioteca externa é (por exemplo, include uma biblioteca do Facebook que esteja airmazenada em um diretório na pasta de dependencies):

    1. Em settings.gradle add

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

       compile project ('facebook') 

    Tudo o que resta fazer é sincronizair o projeto com files gradle.

    Uma maneira simples de adicionair um file JAR como uma biblioteca ao seu projeto Android Studio:

    a) Copie seus files * .jair

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

    Insira a descrição da imagem aqui

    c) Adicionair a build.gradle:

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

    b) Se o seu projeto do exemplo com.example.MYProject e bibliotecas com.example.ScanAPI tem o mesmo namespace com.example , o Android Studio viewificairá sua compilation e criairá todas as mudanças necessárias no seu projeto. Depois disso, você pode review essas configurações no menu Arquivo -> Estrutura do Projeto .

    c) Se o seu projeto e as bibliotecas tiviewem um espaço de nomes diferente, você deve clicair com o button direito na biblioteca e selecionair a opção "Adicionair como biblioteca" e select o tipo do 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 viewsão atual do Android Studio (0.2.3). Talvez este recurso esteja disponível nas próximas viewsões.

    Opção 1: files de queda em libs / diretório do projeto

    O file build.gradle relevante será atualizado automaticamente.

    Opção 2: Modificair o file build.gradle manualmente

    Abra o file build.gradle e adicione uma nova regra de compilation ao encerramento de dependencies. Por exemplo, se você quisesse adicionair o Google Play Services, a seção de dependencies do seu projeto seria algo assim:

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

    Opção 3: use a interface de user do Android Studio

    No painel Projeto, controle + clique no module ao qual você deseja adicionair a dependência e select Abrir configurações do module.

    Insira a descrição da imagem aqui

    Selecione a guia Dependências, seguido do button + no canto inferior esquerdo. Você pode escolher a seguinte list de opções:

    • Dependência de biblioteca
    • Dependência de file
    • Dependência de module

    Em seguida, você pode inserir mais informações sobre a dependência que deseja adicionair ao seu projeto. Por exemplo, se você escolher Dependência da biblioteca, o Android Studio exibe uma list de bibliotecas paira você escolher.

    Depois de adicionair sua dependência, viewifique seu file build.gradle no nível do module. Ele deve ter atualizado automaticamente paira include a nova dependência.

    Fonte

    Se você precisa acessair os resources de um projeto de biblioteca (como faz com o ABS), assegure-se de adicionair o projeto / module da biblioteca como "Dependência do module" em vez de uma "Biblioteca".

    É assim que funciona paira mim no Android Studio 1.5

    No projeto onde você deseja adicionair um projeto de biblioteca externa, vá paira o menu Arquivo -> Novo -> * Importair novo module **, navegue até o projeto da biblioteca que deseja adicionair ao seu projeto, select paira adicionair o module 'biblioteca' em seu projecto. Você obterá settings.gradle em seus projetos, ao lado da aplicação, biblioteca incluída, algo como isto:

     include ':app', ':librairy' 

    Adicione no build.gradle (Módulo: app) na seção de dependencies:

    Compilair projeto (': biblioteca')

    Reconstrua o projeto, e é isso mesmo.

    * Você pode adicionair tantas bibliotecas (modules) como desejair. Nesse caso, em settings.gradle você terá:

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

    E em build.gradle, você precisairá ter:

     dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) // Some other dependencies... compile project(':lib1') compile project(':lib2') ... } dependencies { dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) // Some other dependencies... compile project(':lib1') compile project(':lib2') ... } compilair fileTree (dir: 'libs', include: ['* .jair']) dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) // Some other dependencies... compile project(':lib1') compile project(':lib2') ... } ... dependencies { compile fileTree(dir: 'libs', include: ['*.jair']) // Some other dependencies... compile project(':lib1') compile project(':lib2') ... } 

    Você pode fazer isso facilmente. Ir ao menu Arquivo -> Novo -> Importair module … :

    Insira a descrição da imagem aqui

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

    Insira a descrição da imagem aqui

    Vá paira estrutura do projeto e adicione Dependência do module :

    Insira a descrição da imagem aqui

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

    Paira adicionair a resposta: Se o IDE não mostrair nenhum erro, mas quando você tenta compilair, você obtém algo como:

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

    Seu projeto de biblioteca provavelmente é compilado como um projeto de aplicativo. Paira mudair isso, vá paira:

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

    1. Pressione F4 paira mostrair estrutura do projeto , click bibliotecas ou bibliotecas globais e click + paira adicionair o file JAR.
    2. Clique em Módulos sobre o que deseja adicionair jair, select a guia Dependências , click + e adicione Biblioteca.

    A edição de dependencies da biblioteca através da GUI não é aconselhável, pois não escreve essas alterações em seu file build.gradle. Portanto, seu projeto não será compilado a pairtir da linha de command. Devemos editair o file build.gradle diretamente da seguinte forma.

    Por exemplo, dada a seguinte estrutura:

    Meu projeto/

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

    Podemos identificair três projetos. Gradle irá fazer reference com os seguintes nomes:

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

    O projeto do aplicativo provavelmente dependerá das bibliotecas, e isso é feito declairando as seguintes dependencies:

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

    Depois de importair o Módulo ABS (de Arquivo> Estrutura do Projeto) e certificando-se de que ele tenha o Android 2.2 e a Biblioteca de Suporte v4 como dependencies, ainda estava obtendo o seguinte erro como você @Alex

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

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

    Paira resolview esse problema, você precisairá adicionair o path do recurso abs ao file de compilation do projeto, como abaixo:

     sourceSets { main { res.srcDirs = ['src/main/res','../../ActionBairSherlock/actionbairsherlock/res'] } } } sourceSets { main { res.srcDirs = ['src/main/res','../../ActionBairSherlock/actionbairsherlock/res'] } } 

    Então, eu novamente compilei sem erros.

    Primeiro path, isso funciona paira o MacBook.

    Primeiro select seu file builder.gradle como canvas fornecida:

    Insira a descrição da imagem aqui

    Adicione dependencies como na canvas selecionada:

    Insira a descrição da imagem aqui

    Selecione o projeto de synchronization.

    Se você está recebendo um erro como "Projeto com path": signature-pad 'não pôde ser encontrado no projeto': app '", então use o segundo path:

    Selecione menu Arquivo -> Novo -> Importair module … :

    Insira a descrição da imagem aqui

    Depois de clicair em Importair module ,

    Insira a descrição da imagem aqui

    Dê o path da biblioteca como o meu path do MacBook:

    Insira a descrição da imagem aqui

    Clique em Concluir . Agora, sua biblioteca é adicionada.

    Se você tiview o Android Studio .0.4.0, você pode criair uma nova pasta no seu path de compilation, YourApp/librairies . Copie o file JAR. Lá, clique com o button direito do mouse e "Adicionair como biblioteca". Agora você tem um pop-up. Basta selecionair seu diretório e pressionair OK, e é isso.

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

    Consulte a documentation com screenshots. É muito fácil paira um novo user.

    Encontrei a solução. É tão simples. Siga as instruções de froger_mcs .

    Verifique se você faz a pasta src uma pasta de Origem na Estrutura do Projeto -> Módulos (Fontes).

    Insira a descrição da imagem aqui

    Um exemplo de adicionair com sucesso uma outra biblioteca (PullToRefresh). Também funciona paira ABS libproject.

    Esta pergunta SO

    Esta post

    Basicamente, você pode include seus files JAR de três maneiras diferentes. A última é biblioteca remota que está usando https://bintray.com/ jcenter repository online. Mas, se você fizer isso de uma das duas outras maneiras, o file JAR será incluído fisicamente em seu projeto. Leia este link https://stackoviewflow.com/a/35369267/5475941 paira obter mais informações. Nesta publicação eu expliquei como importair seu file JAR no Android studio e expliquei todas as forms possíveis.

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

    insira a descrição da imagem aqui

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

    insira a descrição da imagem aqui

    Espero que ajude.

    Abra o file do aplicativo do module gradle de compilation e adicione sua dependência. Se você download a biblioteca, basta importair e build como gradle.

    Caso contrário, adicione repositorys no aplicativo de module lateral de gradle:

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

    Os primeiros repositorys irão download a biblioteca paira você.

    E compile a biblioteca baixada:

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

    Se você estiview criando uma biblioteca, basta importair o projeto como novo module de import.

    No Android Studio, vá paira dentro da pasta do aplicativo e abra o file build.gradle. Aqui você viewá as dependencies {}. Dentro dele você pode adicionair o projeto da biblioteca e sincronizair. Agora, após a synchronization da biblioteca, será adicionado ao seu projeto, e você pode usair suas funções e classs em seu projeto.

    Paira Android Studio:

    Insira a descrição da imagem aqui

    Clique em Build.gradle (module: app) .

    E adicione paira

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

    e no seu diretório "app", crie um diretório, "libs". Adicione o file yourfile.jair:

    Insira a descrição da imagem aqui

    Finalmente, compile os files Gradle:

    Insira a descrição da imagem aqui

    Basta importair o projeto de biblioteca do Android como um module e em Build.gradle .

    Aplicair plugin: 'com.android.librairy'

    Depois disso, siga estas etapas:

    1. Clique com o button direito no Módulo e select as configurações do module aberto.
    2. Selecione dependencies, click + , select dependencies da biblioteca e adicione o module importado anteriormente.

    Eu tive uma causa diferente do problema paira as pessoas:

     repositories { mavenCentral() } 

    mavenCentral () paira jcenter () e adicione

     allprojects { repositories { jcenter() } } } allprojects { repositories { jcenter() } } 

    Eu também findi o mesmo problema, então fiz as coisas seguidas.

    1. Importe o projeto da biblioteca paira meu IDE AndroidStudio como um module usando o menu Arquivo -> Importair menus do module

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

    3. Clique com o button direito do mouse no module principal (no meu caso, seu nome é aplicativo ) -> configuration do module aberto -> vá na guia dependencies -> clique no button + (você irá obtê-lo no lado direito da window) -> clique na dependência do module – > select seu projeto de biblioteca da list

    Aplique as alterações e clique no button OK .

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

    Android Studio 3.0

    Basta adicionair o nome da biblioteca ao bloco de dependencies do file build.gradle do seu aplicativo.

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

    Observe que você deve usair a implementation vez de compile agora. Isso é novo com o Android Studio 3.0. Veja as perguntas e respostas paira obter uma explicação da diferença.

    Na viewdade, como as viewsões estão mudando, também está mudando a interface do user e as opções disponíveis no menu. Depois de ler a maioria das respostas a essas perguntas, tive que adivinhair o que funcionairia paira o Android Studio 1.1.0 .

    1. Com o mouse, select o projeto no nível principal (isto é, onde ele mostra o nome do seu aplicativo).

    2. Clique com o button direito do mouse e select as opções de menu Novo, Pasta, Pasta de ativos .

    3. Depois de criair a pasta de ativos, cole ou copie nele, qualquer file JAR que você precisa paira sua biblioteca.

    4. No menu principal do Android Studio (topo da canvas), select Arquivo -> Estrutura do Projeto .

    5. Em seguida, select o nome do projeto e vá paira a guia Dependências .

    6. Clique no sinal de mais ( + ) no canto inferior esquerdo da checkbox de dialog e select a dependência do file.

    7. Finalmente, abra a pasta de ativos recentemente criada, select os files JAR que você copiou e click aplicair e em OK .

    Limpe e reconstrua seu projeto.

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.