A pasta Layout do Android pode conter subpastas?

551

No momento, estou armazenando todos os arquivos de layout xml dentro da res/layoutpasta, para que seja viável e simples gerenciar pequenos projetos, mas quando houver um caso de projetos grandes e pesados, deve haver uma hierarquia e subpastas necessárias dentro a pasta de layout.

por exemplo

layout
-- layout_personal
   -- personal_detail.xml
   -- personal_other.xml
--layout_address
  -- address1.xml
  -- address2.xml

Da mesma forma, gostaríamos de ter subpastas para aplicativos grandes, então existe alguma maneira de fazê-lo dentro do projeto android?

Sou capaz de criar subpastas layout-personal e layout_address dentro da pasta layout, mas quando chega a hora de acessar o arquivo de layout xml usando R.layout ._______, naquele momento não há nenhum pop-up de layout xml dentro do diretório cardápio.

Paresh Mayani
fonte
O mesmo que: stackoverflow.com/questions/2547100/…
Sebastian Roth
Acho que esse link pode ajudá-lo em detalhes. blog.mindorks.com/…
Dilip Poudel

Respostas:

475

Você pode fazer isso com gradle. Eu fiz um projeto de demonstração mostrando como.

O truque é usar a capacidade do gradle para mesclar várias pastas de recursos e definir a pasta res, bem como as subpastas aninhadas no bloco sourceSets.

A peculiaridade é que você não pode declarar uma pasta de recursos de contêiner antes de declarar as pastas de recursos filho dessa pasta.

Abaixo está o bloco sourceSets do arquivo build.gradle da demonstração. Observe que as subpastas são declaradas primeiro.

sourceSets {
    main {
        res.srcDirs =
        [
                'src/main/res/layouts/layouts_category2',
                'src/main/res/layouts',
                'src/main/res'
        ]
    }
}

imagem de recursos aninhados

Além disso, o pai direto de seus arquivos de recursos reais (pngs, layouts de xml, etc.) ainda precisa corresponder à especificação .

eski
fonte
6
É possível fazer isso com as pastas desenháveis? Eu apenas tentei sem sorte, mesmo levando em conta o pedido da declaração.
Trevor-e
7
Agradável! Lembre-se de que você realmente está apenas explorando a capacidade do gradle de mesclar pastas de recursos e isso fará sentido.
ESKI
5
Os nomes dos arquivos na pasta ainda precisam ser exclusivos e, no código, você deve saber que, por exemplo, R.layout.list_itemé proveniente da pasta moviesou da cinemaspasta, portanto, a nomeação simples ainda se aplica.
TWIStErRob
5
Infelizmente isso não funciona para mim com build:gradle:0.14.4e buildToolsVersion "21.1.1".
Kamil Lelonek
32
Isso funciona, no entanto, a resposta faz um trabalho lamentavelmente inadequado de explicar que cada subpasta que você adiciona precisa ter uma segunda subpasta, que só pode ser chamada de "layout" e que todos os seus arquivos de layout precisam ir para o diretório segunda subpasta. Ler dezenas de comentários para descobrir isso está longe de ser o ideal. E para quem ainda procura, configurar as subpastas extras de "layout" é a solução para o URI is not registeredproblema.
Aroth 18/08/16
233

A resposta é não.

Gostaria de chamar sua atenção para este livro Pro Android 2, que afirma:

Também vale a pena notar algumas restrições em relação aos recursos. Primeiro, o Android suporta apenas uma lista linear de arquivos nas pastas predefinidas em res. Por exemplo, ele não suporta pastas aninhadas na pasta de layout (ou nas outras pastas em res).

Segundo, existem algumas semelhanças entre a pasta de ativos e a pasta bruta em res. Ambas as pastas podem conter arquivos não processados, mas os arquivos não processados ​​são considerados recursos e os arquivos nos ativos não.

Observe que, como o conteúdo da pasta de ativos não é considerado um recurso, você pode colocar nela uma hierarquia arbitrária de pastas e arquivos .

100rabh
fonte
3
Convidado, nossa próxima melhor esperança seria um plugin Eclipse ou IntelliJ que pudesse recolher os arquivos com base nos prefixos de nome de arquivo.
Jerry Brady
15
@ Justin, confira a solução que publiquei para o gradle.
Eski
Eu acho que uma solução poderia ser nomear os arquivos como você gostaria que eles fossem categorizados, então parece que estão em subpastas. Eu adiciono uma "marca de subpasta" ao início do nome. Por exemplo. todas as atividades seriam "activity_activityname.xml" e uma atividade filho poderia ser "activity_activityname_childactivity.xml" e assim por diante. Qualquer outro arquivo seria "other_filename.xml". É isso que faço para evitar confusão. Porra, alguém me venceu. Por três anos>. <Meu mal, não tinha visto isso.
Vedavyas Bhat
1
É importante observar aqui que, considerando rawcomo recursos, você obtém faixas dependentes da densidade / orientação / versão / etc, enquanto assetsvocê precisa fazer isso manualmente.
TWIStErRob
1
Escolheu esta resposta como um argumento contra inventar o mainstream do Android.
Zon
77

Eu só queria acrescentar à fantástica resposta da eskis para pessoas com problemas. (Nota: isso funcionará apenas e parecerá com diretórios separados dentro da visualização 'projeto', não da visualização 'android', infelizmente.)

Testado com o seguinte. BuildToolsVersion = 23.0.0 nível 1.2.3 e 1.3.0

Foi assim que consegui que o meu trabalhasse com um projeto já construído.

  1. Copie todos os arquivos XML do diretório de layout e coloque-os em um diretório na área de trabalho ou em algo para backup.
  2. Exclua todo o diretório do layout (verifique se você fez backup de tudo da etapa 1 !!!)
  3. Clique com o botão direito do mouse no diretório res e selecione novo> diretório.
  4. Nomeie este novo diretório como "layouts". (Pode ser o que você quiser, mas não será um diretório de 'fragmentos' ou 'atividade', que será disponibilizado posteriormente).
  5. Clique com o botão direito do mouse no novo diretório "layouts" e selecione novo> diretório. (Esse será o nome do tipo de arquivo XML que você terá nele, por exemplo, 'fragmentos' e 'atividades').
  6. Clique com o botão direito do mouse no diretório 'fragmento' ou 'atividades' (Nota: não precisa ser 'fragmento' ou 'atividades', é exatamente isso que estou usando como exemplo) e selecione novo> diretório novamente e nomeie esse diretório "layout". (Nota: DEVE ser nomeado 'layout' !!! muito importante).
  7. Coloque os arquivos XML que você deseja dentro do novo diretório 'layout' a partir do backup que você fez na sua área de trabalho.
  8. Repita as etapas 5 a 7 para quantos diretórios personalizados você desejar.
  9. Quando isso estiver concluído, entre no arquivo gradle.build dos módulos e crie uma definição sourceSets como esta ... (Verifique se 'src / main / res / layouts' e 'src / main / res' são sempre os dois últimos! !! Como eu estou mostrando abaixo).

    sourceSets {
        main {
            res.srcDirs =
                    [
                            'src/main/res/layouts/activities',
                            'src/main/res/layouts/fragments',
                            'src/main/res/layouts/content',
                            'src/main/res/layouts',
                            'src/main/res'
                    ]
        }
    }
    
  10. Lucro $$$$

Mas falando sério .. foi assim que eu consegui funcionar. Deixe-me saber se alguém tiver alguma dúvida .. Eu posso tentar ajudar.

Imagens valem mais que palavras.

Estrutura de Diretórios

hitch.united
fonte
1
E os diretórios de layout, como layout-v21?
Akshay Chordiya
4
Não testei, mas imagino que você crie uma pasta layout-v21 ao lado das pastas de layout.
hitch.united
Funciona no gradle 2.0.0 e no buildToolsVersion 23.0.2! Note-se que o valor de configuração é 'src/main/res/layouts/content'e o caminho deste configuração é'src/main/res/layouts/content/layout'
cwhsu
3
Eu estou tendo problema com este stackoverflow.com/questions/41934004/...
Petra Barus
2
Pesquisado por um tempo sem sorte, esta é a única solução que funcionou para mim. Obrigado por postar uma resposta tão detalhada com imagens!
Machine Tribe
53

Não é possível, mas a pasta de layout está classificada por nome. Portanto, eu prefixo os nomes dos arquivos de layout com os nomes dos meus pacotes. Por exemplo, para os dois pacotes "comprando" e "jogando":

buying_bought_tracks.xml
buying_buy_tracks.xml
playing_edit_playlist.xml
playing_play_playlist.xml
playing_show_playlists.xml
delformo
fonte
20

Eu uso o plug-in de agrupamento de arquivos do Android para o Android Studio.Ele realmente não permite criar subpastas, mas pode exibir seus arquivos e recursos como estão em pastas diferentes. E é exatamente isso que eu queria.

Você pode instalar o plug-in "Android File Grouping"

Janelas:

Android Studio -> Arquivo -> Configurações -> Plugins.

Mac:

Android Studio -> Guia Android Studio (canto superior esquerdo) -> Preferências -> Plugins -> Instalar o plugin JetBrains ..

No Mac, pude testá-lo e não consegui pesquisar o plugin. Então eu baixei o plugin aqui e usei a Install plugin from diskopção da configuração acima.

Sharpe
fonte
Compartilhe também o link desse plugin!
Paresh Mayani
Feito. De qualquer forma você sempre pode procurar por "Arquivo Agrupamento Android" no Android Studio -> Arquivo -> Configurações -> Plugins
Sharpe
3
o plug-in não funcionou na visualização "Android", apenas na visualização "Projeto": /
Hugo Gresse
18

Agora, com o Android Studio e o Gradle, você pode ter várias pastas de recursos no seu projeto. Permitindo organizar não apenas seus arquivos de layout, mas qualquer tipo de recurso.

Não é exatamente uma subpasta, mas pode separar partes do seu aplicativo.

A configuração é assim:

sourceSets {
    main {
        res.srcDirs = ['src/main/res', 'src/main/res2']
    }
}

Verifique a documentação .

Androiderson
fonte
2
Percebi que toda vez que fazia alterações em um layout sob essa configuração, sempre era necessário fazer um cleanpara vê-lo refletido no aplicativo.
Pawan Kumar
16

Eu acho que a solução mais elegante para esse problema (como as subpastas não são permitidas) é acrescentar os nomes dos arquivos com o nome da pasta em que você os colocaria. Por exemplo, se você tiver um monte de layouts para uma Atividade, Fragmento ou apenas uma visão geral chamada "locais", você deve anexá-lo com places_my_layout_name. Pelo menos isso resolve o problema de organizá-los de uma maneira que eles são mais fáceis de encontrar no IDE. Não é a solução mais impressionante, mas é melhor que nada.

botbot
fonte
16

Pequeno problema

Consigo alcançar subpastas seguindo a resposta principal para esta pergunta.

No entanto, à medida que o projeto cresce, você terá muitas subpastas:

sourceSets {
    main {
        res.srcDirs =
            [
                    'src/main/res/layouts/somethingA',
                    'src/main/res/layouts/somethingB',
                    'src/main/res/layouts/somethingC',
                    'src/main/res/layouts/somethingD',
                    'src/main/res/layouts/somethingE',
                    'src/main/res/layouts/somethingF',
                    'src/main/res/layouts/somethingG',
                    'src/main/res/layouts/somethingH',
                    'src/main/res/layouts/...many more',
                    'src/main/res'
            ]
    }
}

Não é um grande problema, mas:

  • não é bonito, pois a lista se torna muito longa.
  • você precisa alterar app/build.gradlesempre que adicionar uma nova pasta.

Melhoria

Então, eu escrevi um método Groovy simples para pegar todas as pastas aninhadas:

def getLayoutList(path) {
    File file = new File(path)
    def throwAway = file.path.split("/")[0]
    def newPath = file.path.substring(throwAway.length() + 1)
    def array = file.list().collect {
        "${newPath}/${it}"
    }
    array.push("src/main/res");
    return array
}

Cole esse método fora do android {...}bloco no seu app/build.gradle.


Como usar

Para uma estrutura como esta:

<project root>
├── app <---------- TAKE NOTE
├── build
├── build.gradle
├── gradle
├── gradle.properties
├── gradlew
├── gradlew.bat
├── local.properties
└── settings.gradle

Use-o assim:

android {
    sourceSets {
        main {
            res.srcDirs = getLayoutList("app/src/main/res/layouts/")
        }
    }
}

Se você tem uma estrutura como esta:

<project root>
├── my_special_app_name <---------- TAKE NOTE
├── build
├── build.gradle
├── gradle
├── gradle.properties
├── gradlew
├── gradlew.bat
├── local.properties
└── settings.gradle

Você o usará assim:

android {
    sourceSets {
        main {
            res.srcDirs = getLayoutList("my_special_app_name/src/main/res/layouts/")
        }
    }
}

Explicação

getLayoutList()toma a relative pathcomo argumento. O relative pathé relativo à raiz do projeto. Portanto, quando introduzirmos "app/src/main/res/layouts/", ele retornará o nome de todas as subpastas como uma matriz, que será exatamente igual a:

            [
                    'src/main/res/layouts/somethingA',
                    'src/main/res/layouts/somethingB',
                    'src/main/res/layouts/somethingC',
                    'src/main/res/layouts/somethingD',
                    'src/main/res/layouts/somethingE',
                    'src/main/res/layouts/somethingF',
                    'src/main/res/layouts/somethingG',
                    'src/main/res/layouts/somethingH',
                    'src/main/res/layouts/...many more',
                    'src/main/res'
            ]

Aqui está o script com comentários para entender:

def getLayoutList(path) {
    // let's say path = "app/src/main/res/layouts/
    File file = new File(path)

    def throwAway = file.path.split("/")[0]
    // throwAway = 'app'

    def newPath = file.path.substring(throwAway.length() + 1) // +1 is for '/'
    // newPath = src/main/res/layouts/

    def array = file.list().collect {
        // println "filename: ${it}" // uncomment for debugging
        "${newPath}/${it}"
    }

    array.push("src/main/res");
    // println "result: ${array}" // uncomment for debugging

    return array
}

Espero que ajude!

Eu sou um dragão sapo
fonte
Eu usei sua abordagem, mas como usá-la em atividade? i criado subpasta em layouts pasta chamada administrador e tem admin_home disposição quando estou em atividade e usar setContentView(R.layout.Admin.admin_home .)Admin.admin_home não for resolvido
Asmaa Rashad
Você deve poder usá-lo normalmente, como R.layout.admin_home. O script deve poder escolher automaticamente os nomes para você. Deixe-me saber se você pode fazê-lo funcionar.
Eu sou um dragão sapo 23/05
ele funciona bem, mas depois de alterar esta linha array.push("src/main/res");para def res="src/main/res"; array.push(res);, porque eu tenho um erro como impulso quer parâmetro gstring não Cordas um .se qualquer um, em vez de me encontrou este erro, você pode editá-lo
Asmaa Rashad
1
Os layouts nas subpastas não conseguem resolver o espaço para nome do Android. Alguma ideia ?
Jaguar
Você pode descomentar essas linhas // uncomment for debugginge depois verificar se as saídas src/main/res/layouts/<your_layout_files>foram detectadas corretamente?
Eu sou um dragão sapo
15

Agora podemos fazer facilmente com o plugin JetBrains chamado " Agrupamento de arquivos Android "

confira este link

Agrupamento de arquivos do Android

insira a descrição da imagem aqui

Bharath Kumar Bachina
fonte
Deve ser marcado como resposta correta, pois apenas organize o agrupamento com convenção de nome simples. Não há necessidade de alterar o nível ou a estrutura de diretórios padrão de um aplicativo. Todo o layout ainda permanece na pasta de layout, mas está agrupado em:Android Studio
Alireza Fattahi 11/12
1
Não deve ser a resposta aceita, porque ele não está funcionando na exibição Android .... (mas eu amo a idéia ^^)
Appyx
Isso não funciona para a última última versão do android ... existe alguma versão atualizada?
user3053247
7

Uma maneira que eu fiz foi criar uma pasta res separada no mesmo nível da pasta res real no seu projeto, então você pode usá-la nos aplicativos build.gradle

android {
    //other stuff

    sourceSets {
        main.res.srcDirs = ['src/main/res', file('src/main/layouts').listFiles()]
    }
}

estrutura de pastas de exemplo

cada subpasta da sua nova pasta res pode ser algo relacionado a cada tela específica ou algo no seu aplicativo, e cada pasta terá seus próprios layout/ drawable/ valuesetc, mantendo as coisas organizadas e você não precisará atualizar o arquivo gradle manualmente como alguns desses outros as respostas exigem (basta sincronizar sua nota cada vez que você adicionar uma nova pasta de recursos para que ela saiba sobre ela e adicione as subpastas relevantes antes de adicionar seus arquivos xml).

Fonix
fonte
4

Verifique o script Bash Flatten Folder que converte a hierarquia de pastas em uma única pasta

Sneg
fonte
Irá verificar em breve. Obrigado
Paresh Mayani
1
Esse script altera o nome do arquivo para incluir a hierarquia de diretórios no nome do arquivo. Como isso funcionará com o seu IDE Android com nomes de arquivos alterados em todo o lugar?
Rabino Stealth
3

Se você estiver desenvolvendo em uma caixa Linux ou Mac, uma solução alternativa seria criar subpastas que incluam links simbólicos para seus arquivos de layout. Basta usar o comando ln com -s

ln -s PATH_TO_YOUR_FILE

O problema é que a pasta Layout ainda contém todos os arquivos .xml. Mas você pode selecioná-los usando as subpastas. É a coisa mais próxima do que você gostaria de ter.

Acabei de ler, que isso também pode funcionar com o Windows se você estiver usando o Vista ou posterior. Existe este mklinkcomando. Basta pesquisar no Google, nunca o usei.

Outro problema é que, se você tiver o arquivo aberto e tentar abri-lo novamente, o plug-in lança uma exceção de ponteiro NULL. Mas não desliga.

Darokthar
fonte
1
A inserção de um link simbólico anula o objetivo de modularizar o armazenamento, separando os componentes em subdiretórios diferentes: tornando-o efetivamente mais complexo em vez de menos. Gradle permite as especificações de diretórios de recursos adicionais.
22414 RichfieldHH
3

Embora todas as propostas para vários conjuntos de recursos possam funcionar, o problema é que a lógica atual do plug-in Android Studio Gradle não atualizará os arquivos de recursos depois de terem sido alterados para conjuntos de recursos aninhados. A implementação atual tenta verificar os diretórios de recursos usando o startWith (), para que uma estrutura de diretório aninhada (por exemplo, src / main / res / layout / layouts e src / main / res / layout / layouts_category2) escolha src / main / res / layout / layouts de maneira consistente e nunca atualize as alterações. O resultado final é que você precisa reconstruir / limpar o projeto toda vez.

Enviei um patch em https://android-review.googlesource.com/#/c/157971/ para tentar ajudar a resolver as coisas.

rogerhu
fonte
Concordo com você que o AS não observa alterações nos arquivos XML. mas qual é a solução? Vou tentar stackoverflow.com/questions/32317822/… .
CoolMind 28/08/19
3

A resposta principal de @eski é boa, mas o código não é elegante de usar, então escrevi um script groovy gradle para uso geral. É aplicado a todos os tipos de compilação e tipos de produtos e não apenas pode ser usado no layout, mas também é possível adicionar subpasta a qualquer outro tipo de recurso, como drawable. Aqui está o código (coloque-o no androidbloco de arquivo gradle no nível do projeto):

sourceSets.each {
    def rootResDir = it.res.srcDirs[0]
    def getSubDirs = { dirName ->
        def layoutsDir = new File(rootResDir, dirName)
        def subLayoutDirs = []
        if (layoutsDir.exists()) {
            layoutsDir.eachDir {
                subLayoutDirs.add it
            }
        }
        return subLayoutDirs
    }
    def resDirs = [
            "anims",
            "colors",
            "drawables",
            "drawables-hdpi",
            "drawables-mdpi",
            "drawables-xhdpi",
            "drawables-xxhdpi",
            "layouts",
            "valuess",
    ]
    def srcDirs = resDirs.collect {
        getSubDirs(it)
    }
    it.res.srcDirs = [srcDirs, rootResDir]
}

Como fazer na prática?

Por exemplo, eu quero criar subpasta chamada activitypara layout, adicionar uma cadeia por qualquer nome na resDirsvariável como layouts, em seguida, o arquivo xml layout deve ser colocado em res\layouts\activity\layout\xxx.xml.

Se eu quiser criar subpasta chamada selectorspara drawable, adicionar uma cadeia por qualquer nome na resDirsvariável como drawables, em seguida, o arquivo xml drawable deve ser colocado em res\drawables\selectors\drawable\xxx.xml.

O nome da pasta, como layoutse drawablesé definido na resDirsvariável, pode ser qualquer sequência. Todas as subpastas criadas por você, como activityou selectorssão consideradas iguais à respasta. Portanto, na selectorspasta, precisamos criar uma drawablepasta adicionalmente e colocar arquivos xml na drawablepasta, depois que o gradle possa reconhecer os arquivos xml como desenhados normalmente.

AvatarQing
fonte
Esta deve ser considerada a resposta correta! Simples e funcionando perfeitamente!
Gláucio Leonardo Sant'ana
2

Se você usar o método na resposta aprovada e quiser melhorá-lo um pouco, altere a configuração de gradle da seguinte maneira:

    sourceSets {
    main {
        res.srcDirs = [
            file("src/main/res/layouts/").listFiles(),
            "src/main/res/layouts",
            "src/main/res"
        ]
    }
}

Portanto, se você adicionar mais pastas e layouts, não precisará voltar aqui e anexar uma longa lista de pastas de origem, deixe a gradle obter todas as pastas para você.

Drusantia
fonte
1
  • Etapa 1: clique com o botão direito do mouse no layout - mostrar no explorer
  • Etapa 2: abra a pasta de layout e crie as subpastas diretamente: layout_1, layout_2 ...
  • Etapa 3: abrir layout_1 criar layout de pasta (nota: o nome obrigatório é layout), abrir pasta layout_2 criar subdiretório de layout (nota: nome obrigatório é layout) ...
  • Etapa 4: Copie os arquivos xml nos subdiretórios de layout em layout_1 e layout_2
  • Etapa 5: execute o código em buid.grade (módulo de aplicativo) e clique em sincronizar agora:

sourceSets {
    main {
        res.srcDirs =
            [
                'src / main / res / layout / layout_1'
                'src / main / res / layout / layout_2',
                'src / main / res'
            ]
    }
}
  • Etapa 6: Resumo: todas as etapas acima ajudarão a agrupar pastas e serão exibidas no modo 'projeto', enquanto o modo 'android' será exibido normalmente.
  • Então, eu desenho que talvez nomear prefixos seja tão eficaz quanto agrupar pastas.
O Thạnh Ldt
fonte
Obrigado pelo Projectmodo. Não consegui entender onde as subpastas desapareceram (no Androidmodo).
CoolMind 01/08
0

Bem, a resposta curta é não. Mas você definitivamente pode ter várias respastas. Acho que é o mais próximo possível de ter subpastas para a layoutpasta. Aqui está como você faz isso.

sravan953
fonte
1
Verifique a resposta aceita. Eu não tentei pessoalmente, mas se você pode verificar e atualizar, seria útil!
Paresh Mayani
0

As principais respostas têm várias desvantagens: você precisa adicionar novos caminhos de layout, o AS coloca novos recursos na res\layoutspasta em vez de res\values.

Combinando várias respostas que escrevi de maneira semelhante:

sourceSets {
    main {
        res.srcDirs =
                [
                        'src/main/res',
                        file("src/main/res/layouts/").listFiles(),
                        'src/main/res/layouts'
                ]
    }
}

Criei pastas com este artigo: http://alexzh.com/tutorials/how-to-store-layouts-in-different-folders-in-android-project/ . Para criar subpastas, você deve usar este menu: Novo> Pasta> Pasta Res.

ATUALIZAR

Depois de algumas semanas, descobri que as alterações nos recursos não são percebidas pelo Android Studio . Então, alguns erros estranhos aparecem. Por exemplo, layouts continuam mostrando tamanhos antigos, margens. Às vezes, o AS não encontra novos arquivos XML (especialmente durante o tempo de execução). Às vezes, ele mistura view ids (referências a outro arquivo XML). Geralmente, é necessário pressionar Build > Clean Projectou Build > Rebuild Project. Leia Reconstrução necessária depois de alterar os arquivos de layout xml no Android Studio .

CoolMind
fonte
Seu comentário 'Criei pastas com este artigo (link em anexo)' não é uma maneira aceitável de fornecer soluções aqui no SO Sua resposta é vaga. Você pode deixar as instruções e creditar o autor com um link. Caso contrário, isso é apenas preguiçoso.
jungledev
@jungledev, finalmente, recusei essa idéia e voltei para uma respasta tradicional , porque o AS não suporta totalmente a divisão de recursos em pastas. Provavelmente vou mudar essa resposta ou até excluir. Mas o que você quer dizer quando diz que não é uma maneira aceitável de fornecer soluções aqui no SO?
CoolMind 3/12
Quero dizer exatamente o que eu disse. Não diga 'eu fiz isso com este tutorial .... (insira o link)'. O que você deve dizer é: "Eu segui este tutorial (inserir link) e aqui estão as etapas que funcionaram para mim. Etapa 1, Etapa 2, Etapa 3 ... etc 'É necessário incluir as etapas AQUI na resposta. Simplesmente ligando para um tutorial é inaceitável.
jungledev
0

Não pode ter subdiretórios (facilmente), mas você pode ter pastas de recursos adicionais . Surpreendido, ninguém já o mencionou, mas para manter as pastas de recursos padrão e adicionar um pouco mais:

    sourceSets {
        main.res.srcDirs += ['src/main/java/XYZ/ABC']
    }
Mike
fonte