Android Studio: Adicionar jar como biblioteca?

Ozzie 08/31/2017. 30 answers, 600.958 views
android android gradle android-studio android-studio dependency-management

Eu 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 just a MainActivity . Copiei o gson-2.2.3.jar na pasta / libs e adicionei-o como uma biblioteca (clique com o botão direito-> Adicionar como biblioteca). Isso inclui o jar no android studio para que ele possa ser referenciado a partir dos arquivos de origem.

Quando tento executar o projeto, ele não pode compilar, então acrescentei:

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

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

Alguém sabe o que estou fazendo errado?

30 Answers


lepoetemaudit 07/12/2016.

Eu tenho lutado com a mesma coisa por muitas horas, tentando fazer o jar do Gson funcionar não 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 pasta libs
  2. Clique com o botão direito e clique em "Adicionar como biblioteca"
  3. Certifique-se de que os compile files('libs/gson-2.2.4.jar') estejam em seu arquivo build.gradle (ou compile fileTree(dir: 'libs', include: '*.jar') se você estiver usando muitos arquivos jar )
  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 para a pasta raiz do meu aplicativo e digite gradlew clean . Estou no Mac OS X, o comando pode ser diferente em Seu sistema

Depois que fiz os quatro acima, tudo começou a funcionar bem. Acho que o passo "Adicionar como biblioteca" foi o que eu já havia perdido, e não funcionou até que eu limpei também.

[Edit - adicionado o passo build.gradle que também é necessário como outros apontaram]

5 comments
6 František Žiačik 05/25/2013
O gradlew clean me ajudou também. Muito obrigado!
159 J c 05/27/2013
Se você não quiser ter que adicionar explicitamente uma linha para cada arquivo jar: compile fileTree(dir: 'libs', include: '*.jar')
61 Joe 07/17/2013
Eu recomendaria tirar proveito do gerenciamento de dependências transitórias do gradle e fazer o download do gson do mavenCentral () (se for necessária uma conexão com a Internet. Simplesmente adicione repositories { mavenCentral() } e substitua a linha de compile files(...) pela compile 'com.google.code.gson:gson:2.2.4' e o gradle irá automaticamente baixar e gerenciar o arquivo jar para você, o que permite ao SCM rastrear apenas arquivos de código-fonte e não bibliotecas.
29 Yster 08/10/2014
Eu não obtenho a opção Add as Library na etapa 2.
5 Brian Marick 01/16/2015
No Android Studio 1.0.2, as etapas 2 e 3 não são necessárias porque essa linha já está no build.gradle : compile fileTree (dir: 'libs', include: ['* .jar'])

ZenBalance 12/18/2015.

Aqui estão as instruções para incluir um arquivo jar local como uma biblioteca em 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 file inclua o seguinte para que seu encerramento de dependências:

    dependencies {
        // ... other dependencies
        compile files('libs/')
    } 
  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 arquivo gradlew ).

    Execute ./gradlew assemble . Isso deve compilar o projeto com a biblioteca. Talvez seja 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. Você pode precisar executar o comando ./gradlew acima uma vez

3 comments
4 Peter Arandorenko 01/19/2014
Para mim, o passo 2 fez isso. Obrigado.
Phil Freihofner 05/01/2015
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) Encontrar isso foi difícil. A caixa de combinação está no canto superior esquerdo da área da estrutura do projeto. Precisa selecionar "Projeto" em oposição ao "Android" e expanda o "aplicativo". (1b) Nenhuma opção "add" apareceu, mas "Paste" funcionou. (2) Eu tinha uma linha "compile fileTree (dir: 'libs', include: ['* .jar'])", mas ainda tinha que adicionar sua linha única explícita. (4, 5) não é necessário uma vez (3) feito com sucesso. Obrigado!
Rahul Rastogi 05/18/2015
1 mais para as capturas de tela que você adicionou.

Ganesh Pandey 09/06/2015.

No projeto right click

-> 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á isto:

insira a descrição da imagem aqui

5 comments
Ganesh Pandey 09/20/2016
@CamConnor eu também acho que sim .. Outras respostas estão desatualizadas
sudobomb 09/20/2016
Sim, esta deve ser a resposta aceita
Alessandro 11/23/2016
Esta é a resposta
1 Dave 12/18/2016
Mas não é reconhecido como bibliotecário. Por exemplo, editor de estúdio andriod: tente importar um pacote no jar importado, não reconhecido.
Dave 12/18/2016
Não foi possível encontrar uma maneira de remover o módulo importado dessa maneira.

saneryee 05/23/2017.

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

Adicione abaixo a dependência em seu arquivo build.gradle.

repositories {mavenCentral()}

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

Está tudo bem.

Você também pode ver este post. A melhor maneira de integrar a biblioteca de terceiros no estúdio Android

4 comments
2 j2emanue 11/07/2014
esta é a maneira correta de usar repo central.
Gary Drocella 05/04/2015
Este método é o melhor porque está usando maven.
1 Kitalda 06/16/2015
Basta lembrar de atualizar o número da versão para o mais recente :) A partir de agora é 2.3.1, mas verifique o link
Sam 11/23/2016
Essa é a única coisa que funciona!

Jukurrpa 09/02/2015.

IIRC, simplesmente usando "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:

(Em 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 selecionadas.

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 mais adicionar compile files() , e a biblioteca deve ser adequadamente adicionada ao seu projeto.

5 comments
Ozzie 05/17/2013
Adicionar como biblioteca já adiciona o jar da mesma maneira. Então eu acho que o resultado é o mesmo. Vou tentar depois.
jhirsch 05/18/2013
Adicionar como biblioteca faz isso com sucesso - estou no mesmo barco que você Ozzie - EXATO mesmo problema.
Jukurrpa 05/18/2013
Tudo bem, eu pensei que Adicionar como biblioteca apenas o adicionou à lista de bibliotecas e não o adicionou como dependências do módulo.
Matt Holgate 10/22/2013
Quando tentei isso, descobri que ele adicionava as linhas compile files () ao meu arquivo build.gradle, mas parecia usar caminhos absolutos para as bibliotecas (/libs/foo.jar). Eu mudei para caminhos relativos (libs / foo.jar), o que resolveu o problema para mim.
1 android learner 03/12/2015
obrigado .. seu salvou meu dia

Helzgate 07/29/2016.

Todas essas soluções estão desatualizadas. É muito fácil agora 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-a na primeira imagem e abaixo da rolagem e encontre "Importar pacote JAR ou .AAR"

Em seguida, retire a Project Structure do Project Structure do menu Arquivo.Selecione o app da janela aberta, selecione as dependencies , pressione green plus button botão green plus button , selecione a module dependency , selecione o módulo que você importou e pressione OK

2 comments
Gary Drocella 05/04/2015
Acho que usar o maven ainda seria a melhor solução, especialmente para projetos de grande escala, isto é, fornecidos pelo saneryee.
Daniele Testa 10/11/2015
Até isso parece estar desatualizado. Basta colocar seu arquivo .jar no diretório "libs" e ele será compilado automaticamente em 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".

user2084396 10/11/2013.

'compile files ...' costumava trabalhar 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 ideia de por que isso fez a diferença, mas pelo menos a maldita coisa está funcionando agora.

1 comments
1 scottyab 07/09/2014
Isso funciona para mim, mas recentemente descobri que, às vezes, o AS não coleta novos / atualizados frascos até que você faça uma sincronização gradle.

Vinayak Bevinakatti 05/12/2017.

Etapas fáceis para adicionar biblioteca externa no Android Studio

  1. Se você estiver no Android View no project explorer, altere-o para a visualização Project como abaixo

insira a descrição da imagem aqui

  1. Clique com o botão direito do mouse no módulo desejado onde você gostaria de adicionar a biblioteca externa, selecione New > Directroy e nomeie-a como ' libs '
  2. Agora copie o blah_blah.jar para a pasta ' libs '
  3. Clique com o botão direito no blah_blah.jar, depois selecione ' Add as Library.. '. Isto irá automaticamente adicionar e entrar em build.gradle como compile files('libs/blah_blah.jar') e sincronizar o gradle. E você está feito

Please Note : se você estiver usando bibliotecas de terceiros, é melhor usar dependencies quais o script Gradle baixa automaticamente o JAR e o JAR de dependência quando o script gradle é executado.

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

Leia mais sobre Gradle Dependency Mangement

1 comments
Saurabh Bhandari 05/11/2017
esta é a melhor abordagem para adicionar arquivos jar como biblioteca

sansa 07/24/2015.
  1. Baixe o arquivo da biblioteca do site
  2. Cópia do windows explore
  3. Colar a pasta lib do Project Explorer
  4. Ctrl + Alt + Shift + S estrutura de projeto aberta
  5. Selecione a guia Dependências, adicione o arquivo usando +
  6. Barra de ferramentas Sincronizar projeto com arquivo gradle usando o botão

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


Fergara 09/11/2015.

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

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

Não se esqueça de clicar em "Sincronizar agora" no canto superior direito.

Estou usando o Android Studio 1.0.1.

1 comments
Thufir 07/08/2017
você elaboraria o que a linha fileTree faz?

Sandeep 10/29/2015.

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

2. Certifique-se de que os arquivos de compilação ( libs/gson-2.2.4.jar ) estejam em seu arquivo build.gradle.

3. Agora, clique em "Sync Project with Gradle files" (Esquerda para o botão do gerenciador do AVD na barra superior).

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


A.B. 07/23/2016.

Eu achei o Dependency Manager do Android Studio bastante prático e poderoso para gerenciar dependências de terceiros (como o gson mencionado aqui). Fornecendo guia passo a passo que funcionou para mim (Observação: essas etapas são testadas para o Android Studio 1.6 e versões posteriores na plataforma Windows).

Step-1: Ir para "Construir> Editar Bibliotecas e Dependências ..." abriria a caixa de diálogo "Estrutura do Projeto"

insira a descrição da imagem aqui

Step-2: selecione "app" e, em seguida, selecione a guia "Dependências". Em seguida, selecione "Add> 1 Library dependency"

insira a descrição da imagem aqui

Step-3: caixa de diálogo "Escolher Dependência da Biblioteca" será exibida, especifique "gson" na pesquisa e pressione o botão "pesquisar"

insira a descrição da imagem aqui

Step-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

Hope this would help :)

2 comments
A.B. 08/23/2016
Eu encontrei algum problema com esta abordagem, tenho trabalhado em aplicativo que usa commons-io-2.5. Ao fazer o upload do aplicativo para o Google Developer Console, ele mostra 0 dispositivos compatíveis com o apk assinado. Após exaustiva investigação, descobri que tenho que colocar o arquivo jar em app / libs / commons-io-2.5.jar e atualizar dependências em gralde como este 'compile files (' libs / commons-io-2.5.jar ') ', não tenho certeza do que eu tenho feito de errado aqui e porque a documentação não cobre isso.
imsrgadich 08/10/2017
É assim que funciona. Todas as outras respostas não funcionaram. Android Studio 2.3.3

NarenderNishad 03/23/2015.

Faça o download e copie o arquivo .jar na pasta libs e adicione essa linha ao build.gradle:

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

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

Android Studio 1.1.0


Pankaj kumar 06/23/2015.

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

Precisamos adicionar dependências como:

dependências {compile 'com.google.code.gson: gson: 2.2.4'}

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

1 comments
1 chathura 08/26/2015
como saber a linha de dependência para adicionar? Onde posso encontrá-los?

huseyin 01/20/2015.

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.

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

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

A segunda forma é a seguinte: 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 desejarmos.

import module ---> escolha seu arquivo .jar -> do que importar como .jar - insira a descrição da imagem aqui

Então CTRL + ALT + SHIFT + S -> projeto sturure -> escolha o módulo que você quer ato de adicionar uma jarra -> Dependência -> Dependência do Módulo. build.gradle do módulo será atualizado automaticamente. insira a descrição da imagem aqui

1 comments
Aviv Ben Shabat 01/26/2015
Agradável. uma edição - Agora é "Novo módulo" (Android Studio 1.0.1). "Módulo de importação" envia para um assistente diferente.

Elshan 07/14/2016.

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

(I am using Android Studio 2.1.2)

insira a descrição da imagem aqui

Step 1

  • Adicione o jar package name seu jar package name (como exemplo compile 'com.squareup.okhttp3:okhttp:3.3.1' ) no script de compilação build.gradle(Module:app) em build.gradle(Module:app) .

insira a descrição da imagem aqui

Step 2: clique com o botão direito na pasta da app -> New -> Module

insira a descrição da imagem aqui

Step 3: Clique em Import JAR/.AAR Package Em seguida, procure seu pacote. como exemplo: OkHttp.jar

insira a descrição da imagem aqui


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

Aby Mathew 07/23/2015.

Basta colocar os arquivos .jar na pasta libs do projeto Android.

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

essa linha de código no arquivo graddle de aplicativos fará o resto.

Happy Coding :)


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


idris yıldız 07/13/2015.

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 seu 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: compile files ('src / your_libs / your.jar')


mbo 07/13/2015.

No android Studio 1.1.0. Eu resolvi essa questão seguindo os seguintes passos:

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, em seguida, escolha "File Dependency" .Aqui você pode ver o arquivo jar. Selecione e está resolvido.


IntelliJ Amiya 12/02/2015.

Passo 1: Agora, sob a app folder seu app folder você deve ver libs , se você não vê-lo, then create it .

Etapa 2: Drag & Drop the .jar file here , você pode receber um aviso "This file does not belong to the project" , basta clicar no botão OK .

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

Passo 4: Agora este jar foi adicionado.

insira a descrição da imagem aqui


user2573236 07/11/2013.

No Mac OS X:

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

  2. Adicionar instrução compile ao build.grade

  3. Instale o gradle v1.6 (use homebrew)

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

Isso me separou.


Christina 12/27/2014.

Como muitos antes, você deve adicionar

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

ao seu arquivo build.gradle.

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


Binod 07/08/2014.

compile fileTree(dir: 'libs', include: '*.jar') funciona bem mas não compile files(...) testados com o Studio Beta 0.8.1


iberodev 09/25/2014.

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

  1. Abrir 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á suporte para duas maneiras diferentes de adicionar dependências. A compile fileTree(dir: 'libs', include: ['*.jar']) (como mencionado pelo @Binod) diz ao compilador para olhar sob a pasta libs para ANY jar. É uma boa prática criar essa pasta 'libs' que conterá os pacotes jar que nosso aplicativo precisa usar.

Mas isso também permitirá 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 em nosso / "repositório local" libs. É basicamente dizer ao gradle para procurar por aquela versão daquele pacote e dizer ao compilador para considerá-lo quando compilar o projeto (tê-lo no classpath)

PS: eu uso os dois


user2779311 02/01/2015.

Para o mais novo Android 1.0.2, o seguinte já está lá em seu arquivo build.gradle

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

Adicione o jar da biblioteca à sua pasta libs -> clique com o botão direito na biblioteca -> clique em adicionar como uma biblioteca -> ele pede para o projeto adicioná-lo para -> selecione seu projeto-> clique ok A seguinte linha é automaticamente adicionada ao build .gradle

compilar arquivos ('libs / android-query.jar')

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


parasrish 06/08/2015.
  1. Adicionada a pasta "libs" no nível de "app".
  2. Adicionado todos os "frascos" neste projeto.
  3. Em seguida, selecione todos os jars, na pasta "libs",
  4. clique com o botão direito nos itens selecionados e diga "adicionar biblioteca"
  5. então você encontrará a opção de expansão de jars, dentro do próprio explorador de projetos.

Observei "CTRL + ALT + SHIFT + S -> estrutura do projeto -> app-module -> Dependências" já tinha uma entrada como "(dir: 'libs', include: '* .jar')" em " opção de compilação ", inicialmente. E depois de adicionar o jarro de acordo com as etapas acima, o "build.gradle" recebeu as entradas para o novo jar adicionado.


Ranjith Kumar 05/11/2016.

No Android Studio 2.1 eu sigo o seguinte,

Goto app -> src-> main -> pasta de assets (se não estiver disponível, crie-o) -> coloque seus arquivos JAR

insira a descrição da imagem aqui

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

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

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

2 comments
Deni Erdyneev 05/12/2016
Por que você não usa o diretório libs?
Ranjith Kumar 05/12/2016
@ ErdeniErdyneev Eu dou outra abordagem para armazenar arquivos jar. porque eu não uso ativos? algum problema na minha abordagem? Estou pronto para corrigir erros se estiver errado

user3686646 05/29/2014.

Faça isso :

Crie a pasta libs sob a pasta do aplicativo. Adicione arquivos .jar à pasta libs. Em seguida, adicione arquivos .jar à dependência build.gradle do aplicativo. Finalmente sincronize o projeto com arquivos Gradle.

Related questions

Hot questions

Language

Popular Tags