Android Studio: adicionar jar como biblioteca?

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?

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]

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

   

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

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

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:

2:

3:

Você verá isso:

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

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.

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

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

2. 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 '
3. Agora copie o blah_blah.jar para a pasta ' libs '
4. 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

'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.

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.

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.

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"

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

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"

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

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

Espero que isso ajude :)

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.

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"

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 -

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.

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

(Estou usando o Android Studio 2.1.2)

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) .

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

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

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).

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

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.

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;

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'])

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.

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

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.

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.

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')

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.

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}

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.

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.

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.

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

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.

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.

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