Eu sou novo no sistema de compilação gradle e no IntelliJ.

Então, como eu crio um Projeto de Biblioteca Android (por exemplo, com.myapp.lib1) e o projeto do aplicativo (por exemplo, com.myapp.app) e faço o sistema de compilação incluir com.myapp.lib1 no projeto do aplicativo?

Fui ao projeto Estrutura do projeto -> Módulos -> Meu aplicativo e adicionei uma dependência ao projeto lib. O IntelliJ agora pode reconhecer classes do projeto lib quando usado no projeto do aplicativo, mas quando executo o projeto do aplicativo, existem erros como:

Gradle: error: package com.myapp.lib1 does not exist

Para criar uma biblioteca:

Arquivo> Novo Módulo

selecione Biblioteca Android

Para usar a biblioteca, adicione-a como uma dependência:

Arquivo> Estrutura do projeto> Módulos> Dependências

Em seguida, adicione o módulo (biblioteca android) como uma dependência do módulo.

Execute seu projeto. Isso vai funcionar.

Eu me pergunto por que não há exemplo de projeto jar independente.

No eclipse, basta marcar a caixa "Is Library" na caixa de diálogo de configuração do projeto.
No estúdio Android, segui estas etapas e obtive um arquivo jar.

1. Crie um projeto.

2. abra o arquivo no menu esquerdo do projeto. (app / build.gradle): Scripts Gradle> build.gradle (Módulo: XXX)

3. alterar uma linha: apply plugin: 'com.android.application'->'apply plugin: com.android.library'

4. remova applicationId no arquivo: applicationId "com.mycompany.testproject"

5. construir projeto: Construir> Reconstruir projeto

6. então você pode obter o arquivo aar: app> build> outputs> pasta aar

7. alterar aaro nome da extensão do arquivo parazip

8. descompacte e você pode ver classes.jarna pasta renomeie e use-o!

De qualquer forma, não sei por que o Google torna a criação de jarros tão problemática no Android Studio.

O modo recomendado pelo plugin Gradle do Google para configurar seus arquivos gradle para criar vários projetos tem algumas falhas Se você tiver vários projetos dependendo de um projeto de biblioteca, este post explica brevemente a configuração recomendada do Google, suas deficiências e recomenda uma maneira diferente de configurar seus arquivos gradle para suporta configurações de vários projetos no Android Studio:

Uma configuração alternativa de multiprojetos para o android studio

Uma maneira diferente:

Acontece que há uma maneira melhor de gerenciar vários projetos no Android Studio. O truque é criar projetos separados do Android Studio para suas bibliotecas e informar ao gradle que o módulo da biblioteca da qual seu aplicativo depende está localizado no diretório do projeto da biblioteca. Se você quiser usar esse método com a estrutura do projeto que descrevi acima, faça o seguinte:

1. Crie um projeto do Android Studio para a biblioteca StickyListHeaders
2. Crie um projeto do Android Studio para App2
3. Crie um projeto do Android Studio para App1
4. Configure App1 e App2 para criar os módulos no projeto StickyListHeaders.

O quarto passo é a parte mais difícil, então esse é o único passo que descreverei em detalhes. Você pode fazer referência a módulos externos ao diretório do seu projeto adicionando uma instrução de projeto no arquivo settings.gradle e definindo a propriedade projectDir no objeto ProjectDescriptor retornado pela instrução do projeto:

O código que é necessário inserir settings.gradle:

include ':library1'
project(':library1').projectDir = new File('../StickyListHeader/library1')

Se você fez isso corretamente, notará que os módulos referenciados pelo seu projeto aparecerão no navegador do projeto, mesmo que esses módulos sejam externos ao diretório do projeto:

Isso permite que você trabalhe no código da biblioteca e no código do aplicativo simultaneamente. A integração do controle de versão também funciona bem quando você faz referência a módulos externamente dessa maneira. Você pode confirmar e enviar suas modificações ao código da biblioteca, assim como confirmar e enviar modificações ao código do aplicativo.

Essa maneira de configurar vários projetos evita as dificuldades que afetam a configuração recomendada do Google. Como estamos fazendo referência a um módulo que está fora do diretório do projeto, não precisamos fazer cópias extras do módulo de biblioteca para cada aplicativo que depende dele, e podemos fazer a versão de nossas bibliotecas sem nenhum tipo de bobagem do sub-módulo git.

Infelizmente, é muito difícil encontrar essa outra maneira de configurar vários projetos. Obviamente, não é algo que você descobrirá olhando para o guia do Google e, neste momento, não há como configurar seus projetos dessa maneira usando a interface do usuário do Android Studio.

Confira este link sobre configurações de vários projetos .

Algumas coisas a salientar, verifique se o settings.gradle está atualizado para fazer referência aos módulos do aplicativo e da biblioteca.

settings.gradle: include ':app', ':libraries:lib1', ':libraries:lib2'

Verifique também se o build.gradle do aplicativo tem o seguinte:

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

Você deve ter a seguinte estrutura:

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

O build.gradle do aplicativo deve usar o com.android.applicationplug - in, enquanto o build.gradle de qualquer biblioteca deve usar o com.android.libraryplug - in.

O Android Studio IDE deve ser atualizado se você puder construir a partir da linha de comando com esta configuração.

Para o Intellij IDEA (e o Android Studio), cada biblioteca é um módulo. Pense em um módulo no Android Studio como um equivalente ao projeto no Eclipse. Projeto no Android Studio é uma coleção de módulos. Os módulos podem ser aplicativos executáveis ​​ou módulos de biblioteca.

Portanto, para adicionar um novo projeto de biblioteca Android, você precisa criar um módulo do tipo "Biblioteca Android". Em seguida, adicione este módulo da biblioteca à lista de dependências do seu módulo principal (módulo Aplicativo).

A maneira mais simples de criar e reutilizar um projeto de biblioteca:

1. Em um projeto aberto file > new > new module(e responda às perguntas da interface do usuário)

2. verifique / ou adicione se estiver no arquivo settings.gradle :include ':myLibrary'

3. verifique / ou inclua se no arquivo build.gradle :

   dependencies { ... compile project(':myLibrary') }

4. Para reutilizar este módulo de biblioteca em outro projeto, copie sua pasta no projeto em vez da etapa 1 e execute as etapas 2 e 3.

Também é possível criar um novo projeto de aplicativo de estúdio É possível alterar facilmente um módulo de aplicativo existente para um módulo de biblioteca, alterando a atribuição do plug-in no arquivo build.gradle para com.android.library.

apply plugin: 'com.android.application'

android {...}

para

apply plugin: 'com.android.library'

android {...}

mais aqui

Você pode adicionar um novo módulo a qualquer aplicativo, como Blundell diz em sua resposta e, em seguida, referenciá-lo de qualquer outro aplicativo.

Se você deseja mover o módulo para qualquer lugar no seu computador, basta mover a pasta do módulo (os módulos são completamente independentes), será necessário fazer referência ao módulo.

Para fazer referência a este módulo, você deve:

• No arquivo build.gradle do seu aplicativo, adicione:

  dependencies {
  ...
  compile project(':myandroidlib')
  }
  

• No arquivo settings.gradle, adicione o seguinte:

   include ':app', ':myandroidlib'
   project(':myandroidlib').projectDir = new File(PATH_TO_YOUR_MODULE)
  

Não se esqueça de usar apply plugin: 'com.android.library'no seu build.gradleplugin em vez de aplicar:'com.android.application'

Maneira da documentação

Essa é a maneira recomendada, de acordo com as recomendações fornecidas na documentação do Android Studio.

Crie um módulo de biblioteca

Crie um novo projeto para incluir sua biblioteca. Clique em Arquivo> Novo> Novo Módulo> Biblioteca Android> Avançar> (escolha o nome)> Concluir . Em seguida, adicione as classes e recursos desejados à sua biblioteca.

Quando você constrói o módulo, um arquivo AAR será criado. Você pode encontrá-lo project-name/module-name/build/outputs/aar/.

Adicione sua biblioteca como uma dependência

Você pode adicionar sua biblioteca como uma dependência a outro projeto como este:

1. Importe o arquivo AAR da sua biblioteca com Arquivo> Novo Módulo> Importar Pacote .JAR / .AAR> Próximo> (escolha o local do arquivo)> Concluir . (Não importe o código, caso contrário, ele poderá ser editado em muitos lugares.)

2. No arquivo settings.gradle, verifique se o nome da sua biblioteca está lá.

   include ':app', ':my-library-module'
   

3. No arquivo build.gradle do aplicativo, adicione a linha de compilação à seção dependências:

   dependencies {
       compile project(":my-library-module")
   }
   

4. Você será solicitado a sincronizar seu projeto com o gradle. Faça.

É isso aí. Agora você deve poder usar sua biblioteca.

Notas

Se você deseja disponibilizar sua biblioteca facilmente para um público maior, considere usar o JitPac ou o JCenter .

Tinha a mesma pergunta e resolvia da seguinte maneira:

Situação inicial :

FrigoShare (root)
|-Modules:    frigoshare,   frigoShare-backend

Alvo : deseja adicionar um módulo chamadodataformats

1. Adicione um novo módulo (por exemplo Java Library:)

2. Verifique se a sua settings.gradleaparência é esta (normalmente automaticamente):

   include ':frigoshare', ':frigoShare-backend', ':dataformats'

3. Certifique-se ( manualmente ) de que os build.gradlearquivos dos módulos que precisam usar sua biblioteca tenham a seguinte dependência:

   dependencies { ... compile project(':dataformats') }

Objetivo: Biblioteca Android em um único local - Compartilhe em vários projetos http://raevilman.blogspot.com/2016/02/android-library-project-using-android.html

Como o comentário da análise de tcheco acima, tento pesquisar sobre o Gradle Build Varians e encontrei este link: http://code.tutsplus.com/tutorials/using-gradle-build-build-variants--cms-25005 Essa é uma solução muito simples. Isto é o que eu fiz: - No build.gradle:

flavorDimensions "version"

productFlavors {
    trial{
        applicationId "org.de_studio.recentappswitcher.trial"
        flavorDimension "version"
    }
    pro{
        applicationId "org.de_studio.recentappswitcher.pro"
        flavorDimension "version"
    }

}

Depois, tenho mais duas versões do meu aplicativo: pro e trial com 2 packageName diferentes, que são 2 applicationId no código acima, para que eu possa fazer o upload dos dois para o Google Play. Ainda codifico na seção "main" e uso o getpackageName para alternar para a versão. Basta ir ao link que eu dei para detalhes.

Existem duas maneiras mais simples, se uma não funcionar, tente a outra.

1. Adicione dependência da biblioteca dentro da dependência dentro do arquivo build.gradle da biblioteca que você está usando e cole sua biblioteca em Bibliotecas externas.

OU

2. Basta ir à sua pasta libs dentro da pasta do aplicativo e colar todos os seus arquivos .jar, por exemplo, arquivos de biblioteca lá. Agora, o truque é que agora vá para o arquivo settings.gradle e adicione esta linha "include ': app: libs'" after "include ': app '"Definitivamente funcionará ........... :)

No meu caso, usando o MAC OS X 10.11 e o Android 2.0, e fazendo exatamente o que Aqib Mumtaz explicou.

Mas, toda vez, recebi a seguinte mensagem: " Ocorreu um problema ao configurar o projeto ': app'.> Não é possível avaliar o módulo xxx: a configuração com o nome 'padrão' não foi encontrada ."

Descobri que o motivo desta mensagem é que o Android 2.0 não permite criar uma biblioteca diretamente. Então, decidi primeiro criar um projeto de aplicativo e depois modificar o build.gradle para transformá-lo como uma biblioteca.

Esta solução não funciona, porque um projeto de Biblioteca é muito diferente de um projeto de aplicativo.

Então, resolvi meu problema assim:

• Primeiro, crie um aplicativo padrão (se necessário);
• Em seguida, escolha 'Arquivo / Criar módulo'
• Vá para o localizador e mova a pasta do módulo criada recentemente em seu diretório de estrutura

Continue com a solução proposta por Aqib Mumtaz.

Como resultado, a fonte da sua biblioteca será compartilhada sem a necessidade de duplicar os arquivos de origem a cada vez (foi uma heresia para mim!)

Esperando que isso ajude você.