A pasta Layout do Android pode conter subpastas?

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.

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'
        ]
    }
}

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

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 .

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.

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

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.

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 .

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.

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!

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

confira este link

Agrupamento de arquivos do Android

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()]
    }
}

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).

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

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.

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.

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.

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ê.

• 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.

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.

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 .

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']
    }