¿Puede la carpeta de diseño de Android contener subcarpetas?

En este momento, estoy almacenando cada archivo de diseño xml dentro de la res/layoutcarpeta, por lo que es factible y simple administrar proyectos pequeños, pero cuando hay un caso de proyectos grandes y pesados, entonces debería haber una jerarquía y subcarpetas necesarias dentro La carpeta de diseño.

por ej.

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

De la misma manera, nos gustaría tener subcarpetas para la aplicación grande, entonces, ¿hay alguna forma de hacerlo dentro del proyecto de Android?

Puedo crear subcarpetas layout-personal y layout_address dentro de la carpeta de diseño, pero cuando llega el momento de acceder al archivo de diseño xml usando R.layout ._______, en ese momento no hay ninguna ventana emergente de diseño xml dentro del menú.

PUEDES hacer esto con gradle. Hice un proyecto de demostración que muestra cómo.

El truco consiste en utilizar la capacidad de gradle para fusionar múltiples carpetas de recursos y establecer la carpeta res, así como las subcarpetas anidadas en el bloque sourceSets.

La peculiaridad es que no puede declarar una carpeta de recursos del contenedor antes de declarar las carpetas de recursos secundarios de esa carpeta.

A continuación se muestra el bloque sourceSets del archivo build.gradle de la demostración. Observe que las subcarpetas se declaran primero.

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

Además, el padre directo de sus archivos de recursos reales (pngs, diseños xml, etc.) aún debe corresponder con la especificación .

La respuesta es no.

Me gustaría llamar su atención hacia este libro Pro Android 2 que dice:

También vale la pena señalar algunas limitaciones con respecto a los recursos. Primero, Android solo admite una lista lineal de archivos dentro de las carpetas predefinidas en res. Por ejemplo, no admite carpetas anidadas debajo de la carpeta de diseño (o las otras carpetas en res).

En segundo lugar, hay algunas similitudes entre la carpeta de activos y la carpeta sin procesar en res. Ambas carpetas pueden contener archivos en bruto, pero los archivos dentro de raw se consideran recursos y los archivos dentro de activos no lo son.

Tenga en cuenta que debido a que los contenidos de la carpeta de activos no se consideran recursos, puede colocar una jerarquía arbitraria de carpetas y archivos dentro de ella.

Solo quería agregar a la fantástica respuesta de eskis para las personas que tienen problemas. (Nota: Desafortunadamente, esto solo funcionará y se verá como directorios separados dentro de la vista 'proyecto', no la vista 'android').

Probado con lo siguiente. BuildToolsVersion = 23.0.0 gradle 1.2.3 y 1.3.0

Así es como conseguí que el mío trabajara con un proyecto ya construido.

1. Copie todos los archivos XML de su directorio de diseño y colóquelos en un directorio en el escritorio o algo para hacer una copia de seguridad.
2. Elimine todo el directorio de diseño (¡¡¡Asegúrese de hacer una copia de seguridad de todo desde el paso 1 !!!)
3. Haga clic derecho en el directorio res y seleccione nuevo> directorio.
4. Nombre este nuevo directorio "diseños". (Esto puede ser lo que quiera, pero no será un directorio 'fragmentado' o 'directorio de actividad', que viene más adelante).
5. Haga clic derecho en el nuevo directorio de "diseños" y seleccione nuevo> directorio. (Este será el nombre del tipo de archivos XML que tendrá en él, por ejemplo, 'fragmentos' y 'actividades').
6. Haga clic derecho en el directorio 'fragmento' o 'actividades' (Nota: esto no tiene que ser 'fragmento' o 'actividades', eso es lo que estoy usando como ejemplo) y seleccione nuevo> directorio una vez más y nombre este directorio "diseño". (Nota: ¡Esto DEBE llamarse 'diseño'! Muy importante).
7. Coloque los archivos XML que desee dentro del nuevo directorio de 'diseño' de la copia de seguridad que realizó en su escritorio.
8. Repita los pasos 5 - 7 para tantos directorios personalizados como desee.

9. Una vez que esto se haya completado, ingrese al archivo gradle.build de sus módulos y cree una definición de SourceSets como esta ... (¡Asegúrese de que 'src / main / res / layouts' y 'src / main / res' sean siempre los dos últimos !! !! Como estoy mostrando a continuación).

   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. Beneficio $$$$

Pero en serio ... así es como lo puse a trabajar. Avíseme si alguien tiene alguna pregunta. Puedo intentar ayudar.

Las imágenes valen más que las palabras.

No es posible, pero la carpeta de diseño está ordenada por nombre. Por lo tanto, antepongo los nombres de archivo de diseño con los nombres de mis paquetes. Por ejemplo, para los dos paquetes "comprar" y "jugar":

buying_bought_tracks.xml
buying_buy_tracks.xml
playing_edit_playlist.xml
playing_play_playlist.xml
playing_show_playlists.xml

Utilizo el complemento de agrupación de archivos de Android para Android Studio. Realmente no le permite crear subcarpetas, pero puede VISUALIZAR sus archivos y recursos, ya que están en diferentes carpetas. Y esto es exactamente lo que quería.

Puede instalar el complemento "Agrupación de archivos de Android"

Ventanas:

Android Studio -> Archivo -> Configuración -> Complementos.

Mac:

Android Studio -> Pestaña Android Studio (arriba a la izquierda) -> Preferencias -> Complementos -> Instalar el complemento JetBrains.

Para Mac, pude probarlo y no pude buscar el complemento. Así que descargué el complemento desde aquí y utilicé la Install plugin from diskopción de la configuración anterior.

Ahora con Android Studio y Gradle, puede tener múltiples carpetas de recursos en su proyecto. Permitiendo organizar no solo sus archivos de diseño sino también cualquier tipo de recursos.

No es exactamente una subcarpeta, pero puede separar partes de su aplicación.

La configuración es así:

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

Revisa la documentación .

Creo que la solución más elegante para este problema (dado que las subcarpetas no están permitidas) es anteponer los nombres de archivo con el nombre de la carpeta en la que lo habría colocado. Por ejemplo, si tiene un montón de diseños para una Actividad, un Fragmento o simplemente una vista general llamada "lugares", entonces debe anteponerlo con places_my_layout_name. Al menos esto resuelve el problema de organizarlos de manera que sean más fáciles de encontrar dentro del IDE. No es la solución más increíble, pero es mejor que nada.

Pequeño problema

Puedo lograr subcarpetas siguiendo la respuesta principal a esta pregunta.

Sin embargo, a medida que el proyecto crezca, tendrá muchas subcarpetas:

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

No es un gran problema, pero:

• no es bonito ya que la lista se vuelve muy larga.
• tienes que cambiar tu app/build.gradlecada vez que agregas una nueva carpeta.

Mejora

Así que escribí un método Groovy simple para tomar todas las carpetas anidadas:

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
}

Pegue este método fuera del android {...}bloque en su app/build.gradle.

Cómo utilizar

Para una estructura como esta:

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

Úselo así:

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

Si tienes una estructura como esta:

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

Lo usarás así:

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

Explicación

getLayoutList()toma a relative pathcomo argumento. El relative pathes relativo a la raíz del proyecto. Entonces, cuando ingresamos "app/src/main/res/layouts/", devolverá el nombre de todas las subcarpetas como una matriz, que será exactamente 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'
            ]

Aquí está el guión con comentarios para comprender:

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 eso ayude!

Ahora podemos hacerlo fácilmente con el complemento JetBrains llamado " Agrupación de archivos de Android "

mira este enlace

Agrupación de archivos de Android

Una forma en que lo hice fue crear una carpeta de resolución separada en el mismo nivel que la carpeta de resolución real en su proyecto, luego puede usar esto en sus aplicaciones build.gradle

android {
    //other stuff

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

entonces cada subcarpeta de su nueva carpeta de resolución puede ser algo relacionado con cada pantalla en particular o algo en su aplicación, y cada carpeta tendrá su propio layout/ drawable/ valuesetc para mantener las cosas organizadas y no tendrá que actualizar el archivo gradle manualmente como algunos de estos otros las respuestas requieren (Simplemente sincronice su gradle cada vez que agregue una nueva carpeta de recursos para que lo sepa, y asegúrese de agregar las subcarpetas relevantes antes de agregar sus archivos xml).

Verifique el script Bash Flatten Folder que convierte la jerarquía de carpetas en una sola carpeta

Si está desarrollando en un cuadro de Linux o Mac, una solución sería crear subcarpetas que incluyan enlaces simbólicos a sus archivos de diseño. Simplemente use el comando ln con -s

ln -s PATH_TO_YOUR_FILE

El problema con esto es que su carpeta de diseño todavía contiene todos los archivos .xml. Pero podría seleccionarlos utilizando las subcarpetas. Es lo más parecido a lo que te gustaría tener.

Acabo de leer que esto también podría funcionar con Windows si está utilizando Vista o posterior. Hay estomklink comando. Solo googlealo, nunca lo he usado yo mismo

Otro problema es que si tiene el archivo abierto e intenta abrirlo nuevamente, el complemento genera una excepción de puntero nulo. Pero no cuelga.

Si bien todas las propuestas para conjuntos de recursos múltiples pueden funcionar, el problema es que la lógica actual del complemento Android Studio Gradle no actualizará los archivos de recursos después de que hayan cambiado los conjuntos de recursos anidados. La implementación actual intenta verificar los directorios de recursos utilizando beginWith (), por lo que una estructura de directorio que está anidada (es decir, src / main / res / layout / layouts y src / main / res / layout / layouts_category2) elegirá src / main / res / layout / layouts consistentemente y nunca actualizan los cambios. El resultado final es que debe reconstruir / limpiar el proyecto cada vez.

Envié un parche en https://android-review.googlesource.com/#/c/157971/ para intentar ayudar a resolver las cosas.

La respuesta principal de @eski es buena, pero el código no es elegante de usar, así que escribí un script maravilloso en gradle para uso general. Se aplica a todo tipo de compilación y sabor de producto y no solo se puede usar para el diseño, sino que también puede agregar subcarpetas para cualquier otro tipo de recursos, como por ejemplo, dibujable. Aquí está el código (póngalo en el androidbloque del archivo gradle de nivel de proyecto):

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

¿Cómo hacer en la práctica?

Por ejemplo, quiero crear subcarpeta llamada activitypara layout, agregar una cadena con cualquier nombre de resDirsvariable, tal como layouts, a continuación, el archivo xml diseño debe ser puesto enres\layouts\activity\layout\xxx.xml .

Si quiero crear subcarpeta llamada selectorspara drawable, agregar una cadena con cualquier nombre de resDirsvariable, tal como drawables, a continuación, el archivo XML estirable debe ser puesto en res\drawables\selectors\drawable\xxx.xml.

El nombre de la carpeta como layoutsy drawablesse define en resDirsvariable, puede ser cualquier cadena. Todas las subcarpetas creadas por usted, como activityo selectorsse consideran iguales a la rescarpeta. Entonces, en la selectorscarpeta, debemos crear una drawablecarpeta adicional y poner los archivos xml en la drawablecarpeta, después de eso gradle puede reconocer los archivos xml como dibujables normalmente.

Si usa el método en la respuesta aprobada y desea mejorarlo un poco, cambie la configuración de gradle de esta manera:

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

Entonces, si agrega más carpetas y diseños, no necesita volver aquí y agregar una larga lista de carpetas de origen, deje que Gradle obtenga todas las carpetas por usted.

• Paso 1: haga clic derecho en el diseño - mostrar en el explorador
• Paso 2: abra la carpeta de diseño y cree las subcarpetas directamente: diseño_1, diseño_2 ...
• Paso 3: abra el diseño_1 cree el diseño de la carpeta (nota: el nombre obligatorio es el diseño), abra la carpeta layout_2 cree el subdirectorio del diseño (nota: el nombre obligatorio es el diseño) ...
• Paso 4: copie los archivos xml en los subdirectorios de diseño en layout_1 y layout_2
• Paso 5: Ejecute el código en buid.grade (aplicación de módulo) y presione sincronizar ahora:

sourceSets {
    main {
        res.srcDirs =
            [
                'src / main / res / layout / layout_1'
                'src / main / res / layout / layout_2',
                'src / main / res'
            ]
    }
}

• Paso 6: Resumen: todos los pasos anteriores solo ayudarán a agrupar carpetas y mostrar en modo 'proyecto', mientras que el modo 'android' se mostrará de forma normal.
• Entonces, creo que nombrar prefijos es tan efectivo como agrupar carpetas.

Bueno, la respuesta corta es no. Pero definitivamente puedes tener múltiples rescarpetas. Eso, creo, es lo más cercano a tener subcarpetas para la layoutcarpeta. Así es como lo haces.

Las principales respuestas tienen varias desventajas: debe agregar nuevas rutas de diseño, AS coloca nuevos recursos en la res\layoutscarpeta en lugar deres\values .

Combinando varias respuestas escribí similar:

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

Hice carpetas con este artículo: http://alexzh.com/tutorials/how-to-store-layouts-in-different-folders-in-android-project/ . Para crear subcarpetas, debe usar este menú: Nuevo> Carpeta> Carpeta Res.

ACTUALIZAR

Después de un par de semanas descubrí que Android Studio no nota cambios en los recursos . Entonces, aparecen algunos errores extraños. Por ejemplo, los diseños continúan mostrando tamaños antiguos, márgenes. A veces, AS no encuentra nuevos archivos XML (especialmente durante el tiempo de ejecución). A veces se mezclan view ids (referencias a otro archivo XML). A menudo se requiere presionar Build > Clean Projecto Build > Rebuild Project. Leer Reconstrucción requerida después de cambiar los archivos de diseño xml en Android Studio .

No puede tener subdirectorios (fácilmente) pero puede tener carpetas de recursos adicionales . Sorprendido, ya nadie lo mencionó, pero para mantener las carpetas de recursos predeterminadas y agregar algo más:

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