Android studio adicionar projeto externo para build.gradle

139

Eu tenho um projeto de amostra, com a seguinte configuração:

/root
  + Pure Java Lib
  + Android Test Lib
  + Android Test Project

Onde o ' Test Project ' depende da ' Test Lib ', e o último depende da ' Pure Java Lib ' A compilação do projeto e o lançamento dessa configuração funcionam perfeitamente.

Agora estou pensando em importar meu espaço de trabalho anterior do Eclipse e trabalhar com o Android studio, o problema é que a configuração do projeto é diferente e gostaria de mantê-lo dessa maneira.

por exemplo, se usar o exemplo anterior:

/root
  + Android Test Lib
  + Android Test Project

/Some Other folder (another repository for example)
  + Pure Java Lib

Eu tentei muitas configurações, mas não encontrei uma maneira de fazer referência a um projeto fora do escopo da pasta pai (' root ' no caso de exemplo).

Em muitas plataformas / módulos, você pode usar o '..' para subir nas pastas, mas isso não funcionou para mim, talvez eu tenha usado errado.

Alguém sabe como isso pode ser alcançado com Gradle?

ATUALIZAR

Vou tentar ser mais genérico:

/C:/

  /Project A
    + Module 1 - Pure Java
    + Module 2 - Android Test Lib
    + Module 3 - Android Test Project

  /Project B
    + Module 1 - Pure Java
    + Module 2 - Pure Java
    + Module 3 - Pure Java

Eu gostaria de usar o Módulo 1 do projeto B , no projeto A .

ATUALIZAÇÃO: 09-03-19

Eu vi isso agora e preciso atualizar ... depois de quase 6 anos, hoje sou mais sábio e posso dizer com certeza que o problema foi eu ter entendido mal o conceito de "Fonte da verdade".

Embora ter uma referência a uma biblioteca seja um bom conceito, e possa parecer a "Fonte da verdade", a REAL "Fonte da verdade" seria a versão do código que cada projeto está usando dessa biblioteca, pois a biblioteca por si só tem versões .. muitas versões e a "Fonte da verdade" é relativa ao projeto que está usando a biblioteca.

A maneira correta seria usar o que a maioria dos desenvolvedores não gosta, ou seja, sub-módulos git, e sim duplicar as fontes em cada projeto, pois há mais chances de que cada projeto use uma versão diferente do código.

Você precisaria, no entanto, apontar para todos os seus projetos para usar a versão mais recente e melhor de todas as suas bibliotecas. O que é um desafio por si só

A razão pela qual essa é a maneira correta de desenvolver um projeto com fontes de biblioteca é que isso pode ser dimensionado ... você pode ter centenas de projetos, cada um com sua própria configuração de biblioteca.

android gradle android-studio android-library TacB0sS
fonte
4
Vejo que essa pergunta recebe alguma atenção ... Depois de me esforçar muito, desisti do estúdio Android por enquanto, já que a complexidade da configuração que eu estava tentando construir era demais e a construção do meu projeto final era factível, mas altamente instável. a cada lançamento do estúdio Android, eu precisava definir alguns parâmetros novamente e fazer com que a construção funcionasse manualmente. já se passaram dois meses desde que desisti e espero que as coisas estejam melhores agora!
TacB0sS
Abordagem 2 aqui explica como fazer isso muito facilmente: stackoverflow.com/questions/25610727/...
Doron Ben-Ari

Respostas:

222

Supondo que Some Other Folder seja um projeto gradle, você pode adicionar algo como o seguinte ao seu arquivo settings.gradle:

include ':module1'
project(':module1').projectDir = new File(settingsDir, '../Project B/Module 1')
Ethan
fonte
1
Os someOtherFolder aponta para uma pasta do projeto e em que existem módulos, o que eu estou interessado em adicionar como módulos para o projeto Lib Android
TacB0sS
O diretório de configurações aponta para 'root' preciso subir um nível, para outro módulo em outro projeto.
TacB0sS
você poderia adicionar os submódulos depois disso? include ': someOtherFolder: proj1'
Ethan
1
atualizado com alguns detalhes. settings.gradle deve estar no / Project A
Ethan
5
Ótima resposta. No AS 1.0.2, eu também precisava fazer o seguinte: Clique com o botão direito do mouse no módulo -> Abrir Configurações do Módulo -> Dependências -> + (abaixo), selecione Dependência do Módulo, selecione sua biblioteca na lista, clique em ok :)
T. Coutlakis
49

Você precisa colocar em seu arquivo settings.gradle estas linhas:

include ':module2'
project(':module2').projectDir = new File(settingsDir, '../Project 2/Module2')

Então você deve adicionar seu builde.gradle (Module: app) no diretório árvore de dependências , esta linha:

implementation project(':module2')

ou acesse Estrutura do projeto > aplicativo > Dependências , clique em Adicionar , escolha 3 Dependências do módulo e selecione seu módulo

Dario Brux
fonte
1
Se você tiver problemas ao referenciar as classes da biblioteca a partir do aplicativo principal, isso ocorre porque a biblioteca provavelmente vem em diferentes variantes. Então, basta especificar a dependência de forma adequada: compile project(path: ':library', configuration: 'variant'). Aqui, variantconsiste em flavore buildTypecomo definido pelo build.gradlearquivo da biblioteca . Por exemplo, se você deseja releasecriar o tipo da biblioteca em um developsabor, então varianté developRelease.
Sevastyan Savanyuk
9

Com o Gradle 1.10 (não sei para que outras versões isso será válido), foi o que eu criei com base em uma resposta dada aqui http://forums.gradle.org/gradle/topics/reference_external_project_as_dependancy

Eu tenho um projeto de biblioteca API, um projeto de biblioteca comum e o projeto principal do aplicativo. Cada um é um projeto de desenvolvimento independente e as duas bibliotecas devem ser compartilhadas entre vários aplicativos.

Em settings.gradle para o projeto comum:

def apiLibDir = file('../android-api/android-api-lib')
def rootProjectDescriptor = settings.rootProject
settings.createProjectDescriptor(rootProjectDescriptor, 'android-api-lib', apiLibDir)
include ':android-api-lib'

Em seguida, nas configurações principais do projeto do aplicativo.gradle:

def apiLibDir = file('../android-libs/android-api/android-api-lib')
def rootProjectDescriptor = settings.rootProject
settings.createProjectDescriptor(rootProjectDescriptor, 'android-api-lib', apiLibDir)
include ':android-api-lib'

def commonLibDir = file('../android-libs/android-common/android-common-lib')
settings.createProjectDescriptor(rootProjectDescriptor, 'android-common-lib', commonLibDir)
include ':android-common-lib'

Em cada um dos respectivos arquivos build.gradle, basta referenciá-los pelo nome que você forneceu em settings.createProjectDescriptor, como faria com qualquer outra dependência do projeto:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile project(':android-api-lib')
    compile project(':android-common-lib')
}

Isso parece funcionar. Ele nem sequer gerou um erro para vários arquivos DEX que definem a biblioteca da API, suspeito porque era tudo parte do mesmo processo de compilação e Gradle era inteligente o suficiente para descobrir tudo.

alphonzo79
fonte
2
Eu continuo tentando isso, mas o problema é que as dependências na respectiva biblioteca parecem nunca ser carregadas. Portanto, se eu tiver apenas a biblioteca aberta, parece bom, mas quando eu o tento no aplicativo principal, ele diz que todas as bibliotecas importadas estão ausentes.
Czechnology
A @Czechnology teve o mesmo problema. Resolvi-o. Veja o meu comentário para esta resposta: stackoverflow.com/a/29603354/7408927
Sevastyan Savanyuk
9

Clique com o botão direito do mouse no projeto - Selecione "Abrir configurações do módulo" - Selecione "Módulos" no painel esquerdo - Clique no símbolo "+" na parte superior - Escolha "Importar módulo".

Após a importação do módulo. Você precisa adicioná-lo como uma dependência para o seu projeto atual.

Mantenha "Módulos" selecionados no painel esquerdo e clique no seu projeto - Agora vá na guia dependências e clique no símbolo "+" localizado na parte inferior - Escolha a terceira opção "Dependências do módulo" e, se você importou seu projeto corretamente, ele será mostre a você todo o módulo disponível que pode ser adicionado como uma dependência ao seu projeto atual.

Varundroid
fonte
Isso quase funciona ... o projeto não pode ser compilado porque a saída do módulo de dependência não foi adicionada ao arquivo build.gradle, que é exatamente o meu problema original.
TacB0sS
Eu acho que com gradle, você precisa colocar todos os projetos na mesma pasta raiz. Tente isso. Coloque o projeto que você deseja adicionar como dependência na mesma pasta do seu projeto atual.
Varundroid
É isso que ninguém quer fazer, exceto o caixa eletrônico, se você quiser trabalhar com o Android Studio, esse é o caminho para fazer as coisas funcionarem. Outra maneira alternativa que eu estou seguindo é: eu crio o projeto na configuração Intellij, todas as dependências e, em seguida, importo esse projeto para o Android studio, fazendo isso, estou forçando o Android Studio a usar o sistema de compilação de formigas em vez do Gradle. Espero que ajude. Felicidades!!
precisa saber é o seguinte
1
@ Varundroid, a solução é importar primeiro uma referência para a biblioteca autônoma usando a resposta de Ethan. Em seguida, adicione o módulo às dependências do aplicativo principal usando sua resposta. Isso permite que você faça referência à mesma biblioteca em vários aplicativos sem precisar duplicar o código da biblioteca.
precisa saber é
1

Faço novamente esta pergunta de uma maneira que implique as intenções dos pôsteres originais em Como referenciamos as bibliotecas Android e Java personalizadas que vivem fora do diretório do nosso Projeto Android principal?

Lá eu respondo minha própria pergunta. No núcleo, minha resposta usa o insight de codificação gradle @ Ethan (o autor da resposta escolhida no segmento atual). Mas minha resposta também aborda outras dicas e fornece um exemplo detalhado passo a passo.

John Bentley
fonte
-1

Como Ethan disse, se você adicionar isso ao seu settings.gradle, ele adicionará um projeto externo ao Android Studio (neste exemplo, ele está na pasta pai):

project(':../ProjectB/:module1')

Em seguida, para adicioná-lo como uma dependência de um de seus projetos, basta adicioná-lo no build.gradle desse projeto como outra dependência como esta (você também pode fazê-lo graficamente como aqui ):

compile project(':../ProjectB/:module1')
Yair Kukielka
fonte