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?
Respostas:
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:
gson-2.2.4.jar
) nalibs
pastaVerifique se
compile files('libs/gson-2.2.4.jar')
está em seubuild.gradle
arquivo (oucompile fileTree(dir: 'libs', include: '*.jar')
se você estiver usando muitos arquivos jar)Editar: Use
implementation files('libs/gson-2.2.4.jar')
(ouimplementation fileTree(dir: 'libs', include: '*.jar')
) no Android Studio 3.0 ou superiorFaç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 sistemaDepois 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.gradle
etapa que também é necessária, como outros já apontaram]fonte
compile fileTree(dir: 'libs', include: '*.jar')
repositories { mavenCentral() }
e substitua suacompile files(...)
linha porcompile '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.build.gradle
: compile fileTree (dir: 'libs', include: ['* .jar'])Aqui estão as instruções para adicionar um arquivo jar local como uma biblioteca a um módulo:
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')
No
build.gradle file
seguinte, adicione o seguinte para que o fechamento de suas dependências tenha: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
gradlew
arquivo).Corra
./gradlew assemble
. Isso deve compilar o projeto com a biblioteca. Pode ser necessário corrigir erros no arquivo build.gradle, conforme necessário.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.
Pode ser necessário executar o
./gradlew
comando acima mais uma vezfonte
No projeto, clique com o botão direito
Siga as imagens abaixo:
1:
2:
3:
Você verá isso:
fonte
No Android Stuido, gosto de usar o Gradle para gerenciar a Gson lib.
Inclua abaixo a dependência no seu arquivo build.gradle.
Está tudo bem.
Você também pode ver esta postagem. A melhor maneira de integrar biblioteca de terceiros no Android studio
fonte
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:
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.fonte
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 Structure
a partir de ficheiro menu.Selectapp
da janela aberta, em seguida, selecionardependencies
, pressionegreen plus button
, selecionemodule dependency
em seguida, selecione o módulo que você importou, em seguida, pressioneOK
fonte
fonte
'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.
fonte
Isso resolveu meu problema. Tente, se alguém quiser mais detalhes, me avise.
fonte
Eu fiz o trabalho adicionando apenas uma linha a
build.gradle
:Não se esqueça de clicar
Sync now
no canto superior direito.Estou usando o Android Studio 1.0.1.
fonte
fileTree
linha faz?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 :)
fonte
Android Studio 2.3.3
Depois que eu fiz os três acima, ele começou a funcionar bem.
fonte
Faça o download e copie seu
.jar
arquivo nalibs
pasta e adicione estas linhas ao build.gradle:Não se esqueça de clicar em "Sincronizar agora"
fonte
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.
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.
fonte
Eu fiz acima de 3 etapas e seu charme de trabalho para mim.
(Estou usando o Android Studio 2.1.2)
Passo 1
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
fonte
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).
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:
Abra seu arquivo java e adicione a declaração de importação lá:
fonte
Coloque os
.jar
arquivos nalibs
pasta do projeto Android.Em seguida, adicione esta linha de código no arquivo gradle do aplicativo:
Para o Android gradle plugin 3.0 e posterior, é melhor usar isso:
fonte
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.
fonte
fonte
Etapa 1: Agora, sob o seu,
app folder
você deve verlibs
, se não o vir, crie-o .Etapa 2:
Drag & Drop the .jar file here
você pode receber uma solicitação"This file does not belong to the project"
, basta clicar emOK
Botã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.
fonte
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.
fonte
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')
fonte
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.
fonte
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
libs
diretórioapp
e 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á:
fonte
No Mac OS X:
Adicionar jar como biblioteca (arraste jar para libs, clique com o botão direito do mouse em add as lib)
Adicionar instrução de compilação ao
build.grade
Instalar
gradle v1.6
(usar homebrew)gradle clean (reconstruir o android não funcionou)
Isso me resolveu.
fonte
Como muitos antes apontaram, você deve adicionar
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.
fonte
libs
pasta no nível deapp
.jars
neste projeto.libs
pastaadd library
Observei CTRL+ ALT+ SHIFT+ S-> estrutura do projeto -> app-module -> Dependencies "já tinha uma entrada
(dir: 'libs', include: '*.jar')
abaixocompile-option
, inicialmente. E depois de adicionar os jars conforme as etapas indicadas acima,build.gradle
obtivemos as entradas para o novo adicionado do próprio frasco.fonte
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,
Sincronize agora. Agora seus arquivos JAR estão prontos para uso.
fonte
Para o Android 1.0.2 mais recente, o seguinte já existe no seu arquivo build.gradle
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
Isso fez por mim. nada mais era necessário. Eu mostrei isso para o Android aquery outra biblioteca de terceiros para o Android.
fonte
Minha resposta é basicamente reunir algumas das respostas certas, mas incompletas, fornecidas acima.
Adicione o seguinte:
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
fonte