Android Studio: adicionar jar como biblioteca?

1026

Estou tentando usar o novo Android Studio, mas não consigo fazê-lo funcionar corretamente.

Estou usando a biblioteca Gson para serializar / desserializar objetos JSON. Mas a biblioteca de alguma forma não está incluída na compilação.

Eu criei um novo projeto com apenas uma MainActivity . Copiou o gson-2.2.3.jar na pasta / libs e o adicionou como uma dependência da biblioteca (clique com o botão direito do mouse em- > Adicionar como biblioteca). Isso inclui o jar no android studio para que possa ser referenciado a partir dos arquivos de origem.

Quando tento executar o projeto, ele não pode ser compilado, então adicionei:

compile files('libs/gson-2.2.3.jar')

às dependências no arquivo .gradle. Depois disso, ele compila corretamente, mas ao executar o aplicativo, recebo um ClassDefNotFoundException.

Alguém sabe o que estou fazendo de errado?

Ozzie
fonte
Veja também: stackoverflow.com/a/6859020/28557
Vinayak Bevinakatti
1
Embora isso não resolva o problema, basta apontar que "compilar" foi descontinuado em favor da "implementação".
Amir Rezazadeh

Respostas:

1534

Eu tenho lutado com a mesma coisa há muitas horas, tentando fazer com que o frasco Gson funcionasse menos. Eu finalmente decifrei - aqui estão os passos que eu dei:

  1. Coloque o jar do Gson (no meu caso gson-2.2.4.jar) na libspasta
  2. Clique com o botão direito do mouse e clique em 'Adicionar como biblioteca'
  3. Verifique se compile files('libs/gson-2.2.4.jar')está em seu build.gradlearquivo (ou compile fileTree(dir: 'libs', include: '*.jar')se você estiver usando muitos arquivos jar)

    Editar: Use implementation files('libs/gson-2.2.4.jar')(ou implementation fileTree(dir: 'libs', include: '*.jar')) no Android Studio 3.0 ou superior

  4. Faça uma compilação limpa (provavelmente você pode fazer isso bem no Android Studio, mas para ter certeza de que naveguei em um terminal até a pasta raiz do meu aplicativo e digitei gradlew clean. Estou no Mac OS X, o comando pode ser diferente no sistema

Depois que eu fiz as quatro acima, ele começou a funcionar bem. Acho que a etapa 'Adicionar como biblioteca' foi a que eu havia perdido anteriormente e não funcionou até que eu a limpei.

[Editar - adicionada a build.gradleetapa que também é necessária, como outros já apontaram]

lepoetemaudit
fonte
6
gradlew clean me ajudou também. Muito obrigado!
František Žiačik
171
Se você não deseja adicionar explicitamente uma linha para cada arquivo jar: compile fileTree(dir: 'libs', include: '*.jar')
J c
65
Eu recomendaria tirar proveito do gerenciamento de dependência transitória da gradle e baixar o gson do mavenCentral () (se exigir uma conexão com a Internet é aceitável. Simplesmente adicione repositories { mavenCentral() }e substitua sua compile files(...)linha por compile 'com.google.code.gson:gson:2.2.4'e a gradle fará o download e gerenciará automaticamente o arquivo jar para você. Isso permite que o SCM acompanhar apenas arquivos de código fonte e não bibliotecas.
Joe
38
Eu não entendo o Adicionar como opção Biblioteca na etapa 2.
yster
6
No Android Studio 1.0.2, as etapas 2 e 3 não são necessárias porque esta linha já está no padrão build.gradle: compile fileTree (dir: 'libs', include: ['* .jar'])
Brian Marick
268

Aqui estão as instruções para adicionar um arquivo jar local como uma biblioteca a um módulo:

  1. Crie uma pasta 'libs' no nível superior do diretório do módulo (o mesmo diretório que contém o diretório 'src')

  2. No build.gradle fileseguinte, adicione o seguinte para que o fechamento de suas dependências tenha:

    dependencies {
        // ... other dependencies
        compile files('libs/<your jar's name here>')
    }
  3. O Android Studio já deve ter configurado um wrapper gradlew. Na linha de comando, navegue até o nível superior do seu projeto (o diretório que possui um gradlewarquivo).

    Corra ./gradlew assemble. Isso deve compilar o projeto com a biblioteca. Pode ser necessário corrigir erros no arquivo build.gradle, conforme necessário.

  4. Para que o Android Studio reconheça os arquivos jar locais como bibliotecas para suporte durante a codificação no IDE, é necessário executar mais algumas etapas:

    4.1 Clique com o botão direito do mouse no módulo no painel esquerdo e escolha Open Library Settings.

    4.2 No painel esquerdo da caixa de diálogo, escolha Libraries.

    4.3 Clique no +sinal acima do segundo painel da esquerda ->Java

    Cardápio

    4.4 Selecione seu jar local e adicione-o ao projeto.

  5. Pode ser necessário executar o ./gradlewcomando acima mais uma vez

ZenBalance
fonte
Isso funcionou para mim. Eu tenho o Android Studio versão 1.2 Build 141.1890965, no Ubuntu. Por que você diz "a partir do Android Studio 2.5"? É uma versão diferente no Windows / Mac? (1a) Achar isso difícil. A caixa de combinação fica no canto superior esquerdo da área de estrutura do projeto. Precisa selecionar "Projeto" em oposição ao "Android" e expandir o "aplicativo". (1b) Nenhuma opção "adicionar" surgiu, mas "Colar" funcionou. (2) Eu tinha uma linha "compile fileTree (dir: 'libs', inclua: ['* .jar'])" ", mas ainda assim precisei adicionar sua única linha explícita. (4, 5) não é necessário uma vez (3) feito com sucesso. Obrigado!
Phil Freihofner
"painel esquerdo"? Você quer dizer o painel do projeto? Poderia estar em qualquer lugar ... Com o Android Studio 2.3.3, não consigo encontrar as Configurações da Biblioteca, mas adicionar o jar às Dependências nas Configurações do módulo parece ser o mesmo ...
O incrível Jan
para Mac, se você não tiver Gradle: $ Brew instalar Gradle se você ficar "./gradlew: Permissão negada", você precisa executar $ chmod 755 gradlew Então você pode executar $ ./gradlew montar
Azkario Rizky
110

No projeto, clique com o botão direito

-> new -> module
-> import jar/AAR package
-> import select the jar file to import
-> click ok -> done

Siga as imagens abaixo:

1:

Passo 1

2:

insira a descrição da imagem aqui

3:

insira a descrição da imagem aqui

Você verá isso:

insira a descrição da imagem aqui

Ganesh Pandey
fonte
@CamConnor eu também penso assim .. Outras respostas são desatualizados
Ganesh Pandey
Esta é a resposta
Alessandro
4
Mas não é reconhecido como biblioteca. Por exemplo, andriod studio editor: tente importar um pacote no jar importado, não reconhecido.
Dave
Não foi possível encontrar uma maneira de remover o módulo importado dessa maneira.
18716 Dave
Por que devo usar esse método de adição de jar externo e não as outras respostas do método de pasta "copy-jar-to-libs"?
Eido95
48

No Android Stuido, gosto de usar o Gradle para gerenciar a Gson lib.

Inclua abaixo a dependência no seu arquivo build.gradle.

repositories {mavenCentral()}

dependencies {compile 'com.google.code.gson:gson:2.2.4'}

Está tudo bem.

Você também pode ver esta postagem. A melhor maneira de integrar biblioteca de terceiros no Android studio

saneryee
fonte
Este método é o melhor porque está usando o maven.
Gary Drocella
1
Basta lembrar de atualizar o número da versão para as últimas :) a partir de agora que é 2.3.1, mas verificação ligação
Kitalda
47

IIRC, simplesmente usar "Adicionar como biblioteca" não é suficiente para compilar com o projeto.

Verifique a ajuda do Intellij sobre como adicionar bibliotecas a um projeto

A parte que mais lhe interessa é esta:

(Entrada File > Project Structure) Abra as configurações do módulo e selecione a guia Dependências.

Na guia Dependências, clique em adicionar e selecione Biblioteca.

Na caixa de diálogo Escolher bibliotecas, selecione uma ou mais bibliotecas e clique em Adicionar selecionado.

Se a biblioteca não aparecer na caixa de diálogo, adicione-a nas configurações de Bibliotecas, logo abaixo de Módulos.

Você não precisa adicionar compile files()mais e a biblioteca deve ser adicionada corretamente ao seu projeto.

Jukurrpa
fonte
Adicionar como biblioteca já adiciona o jar da mesma maneira. Então eu acho que o resultado é o mesmo. Vou tentar mais tarde.
Ozzie
Adicione como a biblioteca faz isso com sucesso - estou no mesmo barco que você Ozzie - EXATAMENTE o mesmo problema.
Jonah H. #
Tudo bem, pensei em Adicionar como biblioteca, apenas o adicionei à lista de bibliotecas e não o adicionei como dependências do módulo.
Jukurrpa
Quando tentei isso, descobri que ele adicionava as linhas de arquivos de compilação () ao meu arquivo build.gradle, mas parecia usar caminhos absolutos para as bibliotecas (/libs/foo.jar). Altero-os para caminhos relativos (libs / foo.jar), que corrigiram o problema para mim.
precisa
40

Todas essas soluções estão desatualizadas. Agora é realmente fácil no Android Studio:

Arquivo> Novo módulo ...

A próxima tela parece estranha, como se você estivesse selecionando algum widget ou algo assim, mas mantenha-o na primeira imagem e role abaixo e encontre "Importar JAR ou .AAR Package"

Em seguida, tomar Project Structurea partir de ficheiro menu.Select appda janela aberta, em seguida, selecionar dependencies, pressione green plus button, selecione module dependencyem seguida, selecione o módulo que você importou, em seguida, pressioneOK

Helzgate
fonte
Eu acho que usar o maven ainda seria a melhor solução, especialmente para projetos de grande escala, isto é, fornecidos pelo saneryee.
Gary Drocella
2
Até isso parece estar desatualizado. Basta colocar o arquivo .jar no diretório "libs" e ele será automaticamente compilado no seu projeto. Já existe uma configuração de regra padrão no Android Studio 1.4 para incluir todos os arquivos * .jar do diretório "libs".
Daniele Testa #
35

Etapas fáceis para adicionar biblioteca externa no Android Studio

  1. Se você estiver no Android View no Project Explorer, altere-o para Project view como abaixo

insira a descrição da imagem aqui

  1. Clique com o botão direito do mouse no módulo desejado ao qual você deseja adicionar a biblioteca externa, selecione Novo> Directroy e nomeie-o como ' libs '
  2. Agora copie o blah_blah.jar para a pasta ' libs '
  3. Clique com o botão direito do mouse em blah_blah.jar e selecione ' Adicionar como biblioteca .. '. Isso adicionará e entrará automaticamente no build.gradle como arquivos de compilação ('libs / blah_blah.jar') e sincronizará o gradle. E você terminou

Observação: se você estiver usando bibliotecas de terceiros, é melhor usar dependências nas quais o script Gradle baixa automaticamente o JAR e a dependência JAR quando o script gradle é executado.

Por exemplo: compile 'com.google.android.gms: play-services-ads: 9.4.0'

Leia mais sobre Gradle Dependency Mangement

Vinayak Bevinakatti
fonte
34

'compilar arquivos ...' costumava funcionar para mim, mas não mais. depois de muita dor, descobri que usar isso funciona:

compile fileTree(dir: 'libs', include: '*.jar')

Eu não tenho idéia do por que isso fez a diferença, mas pelo menos a coisa está funcionando agora.

user2084396
fonte
1
Isso funciona para mim, no entanto, recentemente descoberto às vezes, o AS não pega jarros novos / atualizados até que você faça uma sincronização gradle.
scottyab
Lembre-se de que "compilar" foi preterido em favor da "implementação".
Amir Rezazadeh
17
  1. Baixar o arquivo da biblioteca do site
  2. Copiar do windows explore
  3. Colar na pasta lib do Project Explorer
  4. Ctrl+ Alt+ Shift+ Sabrir Estrutura do Projeto
  5. Selecione a guia Dependências, adicione o arquivo usando +
  6. Barra de ferramentas Sincronize o projeto com o arquivo gradle usando o botão

Isso resolveu meu problema. Tente, se alguém quiser mais detalhes, me avise.

sansalk
fonte
17

Eu fiz o trabalho adicionando apenas uma linha a build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar']) ----> AS creates this
    implementation 'com.google.code.gson:gson:2.3.1'   ----------> I added this one
}

Não se esqueça de clicar Sync nowno canto superior direito.

Estou usando o Android Studio 1.0.1.

Fergara
fonte
você elaboraria o que a fileTreelinha faz?
Thufir
13

Achei o Dependency Manager do Android Studio bastante útil e poderoso para gerenciar dependências de terceiros (como o gson mencionado aqui). Fornecendo um guia passo a passo que funcionou para mim (NOTA: Essas etapas são testadas para o Android Studio 1.6 e versões posteriores na plataforma Windows).

Etapa 1: Vá para "Compilar> Editar bibliotecas e dependências ...", abriria a caixa de diálogo "Estrutura do projeto"

insira a descrição da imagem aqui

Etapa 2: selecione "aplicativo" e, em seguida, selecione a guia "Dependências". Em seguida, selecione "Adicionar> 1 dependência da biblioteca"

insira a descrição da imagem aqui

Etapa 3: A caixa de diálogo "Escolha a dependência da biblioteca" será exibida, especifique "gson" na pesquisa e pressione o "botão de pesquisa"

insira a descrição da imagem aqui

Etapa 4: a dependência desejada seria mostrada na lista de pesquisa, selecione com.google.code.gson: gson: 2.7 (esta é a versão mais recente no momento em que escrevi a resposta), pressione OK

insira a descrição da imagem aqui

Pressione OK na caixa de diálogo "Estrutura do projeto". Gradle atualizaria seus scripts de construção de acordo.

insira a descrição da imagem aqui

Espero que isso ajude :)

AB
fonte
Eu encontrei algum problema com essa abordagem, tenho trabalhado no aplicativo que usa o commons-io-2.5. Ao fazer o upload do aplicativo no Google Developer Console, ele mostra 0 dispositivos compatíveis com o apk assinado. Após uma investigação exaustiva, descobri que preciso colocar o arquivo jar em app / libs / commons-io-2.5.jar e atualizar dependências no gralde como este 'compilar arquivos (' libs / commons-io-2.5.jar ') ', não tenho certeza do que estou fazendo de errado aqui e por que a documentação não cobre isso.
AB
É assim que funciona. Todas as outras respostas não funcionaram. Android Studio 2.3.3
imsrgadich
11

1. Coloque o jar (no meu caso gson-2.2.4.jar) na pasta libs.

2. Verifique se os arquivos de compilação ( libs/gson-2.2.4.jar) estão no seu arquivo build.gradle.

3. Agora clique no botão "Sincronizar projeto com arquivos Gradle" (da esquerda para o botão AVD manager na barra superior).

Depois que eu fiz os três acima, ele começou a funcionar bem.

Sandeep
fonte
9

Faça o download e copie seu .jararquivo na libspasta e adicione estas linhas ao build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.code.gson:gson:2.3.1'
}

Não se esqueça de clicar em "Sincronizar agora"

NarenderNishad
fonte
9

Você pode fazer isso com duas opções.

primeira maneira simples.

Copie o arquivo .jar para a área de transferência e adicione-o à pasta libs. Para ver a pasta libs no projeto, escolha o projeto na caixa de combinação acima das pastas.

clique com o botão direito do mouse no arquivo .jar e clique em adicionar como uma biblioteca, escolha um módulo e ok. Você pode ver o arquivo .jar no arquivo build.gradle dentro do bloco de dependências.

 dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'com.android.support:appcompat-v7:21.0.3'
        implementation project(':okhttp-2.0.0')
        implementation 'com.google.code.gson:gson:2.3.1'
    }

A segunda maneira é: Podemos adicionar um arquivo .jar a um módulo importando esse arquivo .jar como um módulo .jar e, em seguida, adicionar esse módulo a qualquer módulo que desejar.

módulo de importação ---> escolha seu arquivo .jar -> do que importar como um arquivo .jar - insira a descrição da imagem aqui

Em seguida, CTRL + ALT + SHIFT + S -> estabilidade do projeto -> escolha o módulo que você deseja adicionar a um jar -> Dependências -> Dependência do módulo. O build.gradle do módulo será atualizado automaticamente. insira a descrição da imagem aqui

huseyin
fonte
Agradável. uma edição - Agora é "Novo módulo" (Android Studio 1.0.1). "Módulo Import" envia-lo a um assistente diferente ..
Aviv Ben Shabat
7

Eu fiz acima de 3 etapas e seu charme de trabalho para mim.

(Estou usando o Android Studio 2.1.2)

insira a descrição da imagem aqui

Passo 1

  • Adicione o nome do pacote jar (como exemplo compile 'com.squareup.okhttp3:okhttp:3.3.1') ao script gradle build em build.gradle (Module: app) .

insira a descrição da imagem aqui

Etapa 2: Clique com o botão direito do mouse na pasta do aplicativo -> Novo -> Módulo

insira a descrição da imagem aqui

Etapa 3: Clique em Importar pacote JAR / .AAR Em seguida, procure seu pacote. como um exemplo: OkHttp.jar

insira a descrição da imagem aqui

Elshan
fonte
7

Com o Android Studio 3+:

Você deve simplesmente copiar o arquivo jar para a pasta libs logo abaixo da pasta do aplicativo.

... meuprojeto \ app \ libs \ meuarquivo.jar

Em seguida, selecione Arquivos de projeto no menu suspenso da janela Projetos, clique com o botão direito do mouse no projeto, selecione Sincronizar para ver o arquivo em Arquivos de projeto. Ele adicionará automaticamente as dependências no arquivo gradle (Módulo: app).

dependencies {
...
    implementation files('libs/myfile.jar')

Aqui está outra solução:

Vá para a visualização Arquivos de projeto (selecione Arquivos de projeto no menu suspenso).

insira a descrição da imagem aqui

Selecione Novo ... Diretório, crie uma pasta chamada libs logo no aplicativo.

insira a descrição da imagem aqui

Abra o File Explorer, copie e cole seu arquivo jar na pasta libs.

No Android Studio, clique com o botão direito do mouse no arquivo jar e selecione Adicionar como biblioteca ... no menu pop-up.

insira a descrição da imagem aqui

Você deve ver o arquivo listado na lista de dependências no arquivo gradle:

dependencies {
...
    implementation files('libs/myfile.jar')
}

Abra seu arquivo java e adicione a declaração de importação lá:

import com.xxx.xxx;
amor ao vivo
fonte
7

Coloque os .jararquivos na libspasta do projeto Android.

Em seguida, adicione esta linha de código no arquivo gradle do aplicativo:

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

Para o Android gradle plugin 3.0 e posterior, é melhor usar isso:

    implementation fileTree(dir: 'libs', include: ['*.jar'])
Aby Mathew
fonte
7

Ao contrário do Eclipse, não precisamos fazer o download do jar e colocá-lo na pasta / libs. Gradle lida com essas coisas, só precisamos adicionar dependências Gradle, a Gradle faz o download e coloca no cache gradle.

Precisamos adicionar dependências como:

dependências {implementação 'com.google.code.gson: gson: 2.2.4'}

No entanto, também podemos fazer o download do jar e adicioná-lo como biblioteca, mas a melhor prática é adicionar dependências Gradle.

Pankaj kumar
fonte
5
menu File -> project struct -> module select "app" -> dependencies tab -> + button 
-> File dependency -> PATH/myfile.jar
vuhung3990
fonte
5

Etapa 1: Agora, sob o seu, app foldervocê deve ver libs, se não o vir, crie-o .

Etapa 2: Drag & Drop the .jar file herevocê pode receber uma solicitação "This file does not belong to the project", basta clicar em OKBotão.

Etapa 3: Agora você deve ver o arquivo jar na pasta libs , clique com o botão direito do mouse no arquivo jar e selecione"Add as library", Click OK for prompt "Create Library"

Etapa 4: agora este frasco foi adicionado.

insira a descrição da imagem aqui

IntelliJ Amiya
fonte
4

Crie uma pasta libs. Adicione o seu arquivo .jar. Clique com o botão direito do mouse e você encontrará add jar como dependência. Clique nisso. É tudo o que você precisa fazer. Você pode encontrar as dependências adicionadas ao seu arquivo build.gradle.

Gowtham Chandrasekaran
fonte
4

1) crie uma pasta 'your_libs' dentro da pasta Project / app / src.

2) Copie seu arquivo jar para esta pasta 'your_libs'

3) No Android Studio, vá para Arquivo -> Estrutura do projeto -> Dependências -> Adicionar -> Dependência de arquivo e navegue até o arquivo jar, que deve estar em 'src / your_libs'

3) Selecione seu arquivo jar e clique em 'Ok'

e então você pode ver no seu build.gradle assim: compilar arquivos ('src / your_libs / your.jar')

idris yıldız
fonte
4

No Android Studio 1.1.0. Resolvi essa questão seguindo as etapas:

1: Coloque o arquivo jar no diretório libs. (no Finder)

2: Abra as configurações do módulo, vá para Dependências, no canto inferior esquerdo, há um botão de adição. Clique no botão mais e escolha "Dependência de arquivo". Aqui você pode ver seu arquivo jar. Selecione e está resolvido.

mbo
fonte
4

Eu li todas as respostas aqui e todas parecem cobrir versões antigas do Android Studio!

Com um projeto criado com o Android Studio 2.2.3, eu só precisava criar um libsdiretório appe colocar meu jar lá. Fiz isso com meu gerenciador de arquivos, não é necessário clicar ou editar nada no Android Studio.

Por que isso funciona? Abra Compilar / Editar Bibliotecas e Dependências e você verá:

{include=[*.jar], dir=libs}
0xF
fonte
3

No Mac OS X:

  1. Adicionar jar como biblioteca (arraste jar para libs, clique com o botão direito do mouse em add as lib)

  2. Adicionar instrução de compilação ao build.grade

  3. Instalar gradle v1.6(usar homebrew)

    • brew install gradle
    • gradle -v
    • se não for v1.6, atualize o homebrew
  4. gradle clean (reconstruir o android não funcionou)

Isso me resolveu.

user2573236
fonte
3

Como muitos antes apontaram, você deve adicionar

compile files('libs/gson-2.2.3.jar') 

para o seu arquivo build.gradle.

No entanto, eu tenho um projeto no Android Studio que foi migrado do Eclipse e, nesse caso, a pasta "libs" chama-se "lib", portanto, para remover os "s", resolvi o problema.

Christina
fonte
3
  1. Adicionada a libspasta no nível de app.
  2. Adicionado tudo jarsneste projeto.
  3. Em seguida, selecione todos os frascos, na libspasta
  4. clique com o botão direito do mouse nos itens selecionados e diga add library
  5. você encontrará a opção de expansão dos frascos, no próprio explorador de projetos.

Observei CTRL+ ALT+ SHIFT+ S-> estrutura do projeto -> app-module -> Dependencies "já tinha uma entrada (dir: 'libs', include: '*.jar')abaixo compile-option, inicialmente. E depois de adicionar os jars conforme as etapas indicadas acima, build.gradleobtivemos as entradas para o novo adicionado do próprio frasco.

parasita
fonte
3

No Android Studio 2.1 , sigo desta maneira,

Vá para o aplicativo -> src-> principal -> pasta de ativos (se não estiver disponível, crie) -> coloque seus arquivos JAR

insira a descrição da imagem aqui

Em seu build.gradle, adicione dependência como esta,

implementation files('src/main/assets/jsoup.jar')
implementation files('src/main/assets/org-apache-xmlrpc.jar')
implementation files('src/main/assets/org.apache.commons.httpclient.jar')
implementation files('src/main/assets/ws-commons-util-1.0.2.jar')

Sincronize agora. Agora seus arquivos JAR estão prontos para uso.

Ranjith Kumar
fonte
Por que você não usa o diretório libs?
Deni Erdyneev
@ErdeniErdyneev Dou outra abordagem para armazenar arquivos jar. por que não uso ativos? algum problema na minha abordagem? Estou pronto para corrigir erros se eu estiver errado
Ranjith Kumar
3

Para o Android 1.0.2 mais recente, o seguinte já existe no seu arquivo build.gradle

implementation fileTree(include: ['*.jar'], dir: 'libs')

Adicione o jar da biblioteca à sua pasta libs -> clique com o botão direito do mouse na biblioteca -> clique em adicionar como biblioteca -> solicita que o projeto seja adicionado -> selecione seu projeto -> clique em ok A linha a seguir é adicionada automaticamente para compilar .gradle

implementation files('libs/android-query.jar')

Isso fez por mim. nada mais era necessário. Eu mostrei isso para o Android aquery outra biblioteca de terceiros para o Android.

user2779311
fonte
2

Minha resposta é basicamente reunir algumas das respostas certas, mas incompletas, fornecidas acima.

  1. Abra build.gradle
  2. Adicione o seguinte:

    dependencies {
    compile 'com.android.support:appcompat-v7:19.+'
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.google.code.gson:gson:2.3'
    }

    Isso permitirá o suporte para duas maneiras diferentes de adicionar dependências. O compile fileTree(dir: 'libs', include: ['*.jar'])(como o @Binod mencionou) diz ao compilador para procurar na pasta libs por QUALQUER jar. É uma boa prática criar uma pasta 'libs' que contenha os pacotes jar que nosso aplicativo precisa usar.

Mas isso também permitirá o suporte à dependência do Maven. A compilação 'com.google.code.gson:gson:2.3'(como mencionado por @saneryee) é outra maneira recomendada de adicionar dependências que estão em um repositório remoto central e não no nosso "repositório local" / libs. Basicamente, está dizendo para o gradle procurar a versão desse pacote e o compilador a considerar ao compilar o projeto (tê-lo no caminho de classe)

PS: eu uso os dois

diegosasw
fonte