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


551

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



Creo que este enlace podría ayudarlo en detalle. blog.mindorks.com/…
Dilip Poudel

Respuestas:


475

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

imagen de recursos anidados

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


66
¿Es posible hacer esto con las carpetas dibujables? Lo intenté sin suerte, incluso teniendo en cuenta el pedido de declaración.
trevor-e

77
¡Agradable! Solo recuerde que en realidad solo está explotando la capacidad de gradle para fusionar carpetas de recursos y tendrá sentido.
eski

55
Los nombres de archivo en la carpeta aún deben ser únicos y en el código debe saber que, por ejemplo, R.layout.list_itemproviene de moviesla cinemascarpeta o de la carpeta, por lo que aún se aplica el nombre plano.
TWiStErRob

55
Lamentablemente, eso no funciona para mí con build:gradle:0.14.4y buildToolsVersion "21.1.1".
Kamil Lelonek

32
Esto funciona, sin embargo, la respuesta hace un trabajo lamentablemente inadecuado al explicar que cada subcarpeta que agregue debe tener una segunda subcarpeta dentro de ella, que solo se puede llamar "diseño", y todos sus archivos de diseño deben ir dentro del segunda (s) subcarpeta (s) Leer docenas de comentarios para resolver eso está lejos de ser ideal. Y para cualquiera que todavía esté buscando, configurar las subcarpetas adicionales de "diseño" es la solución al URI is not registeredproblema.
Aroth

233

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.


3
Invito a nuestra próxima mejor esperanza sería un complemento Eclipse o IntelliJ que podría colapsar los archivos en función de los prefijos de los nombres de archivo.
Jerry Brady

15
@Justin mira la solución que publiqué para gradle.
eski

Supongo que una solución podría ser nombrar los archivos como desea clasificarlos, por lo que parece que están en subcarpetas. Agrego una "etiqueta de subcarpeta" al comienzo del nombre. Por ejemplo. todas las actividades serían "activity_activityname.xml" y una actividad secundaria podría ser "activity_activityname_childactivity.xml" y así sucesivamente. Cualquier otro archivo sería "other_filename.xml". Eso es lo que hago para evitar confusiones. Maldición, alguien me ganó. Por tres años>. <Mi mal, no había visto eso.
Vedavyas Bhat

1
Es importante tener en cuenta aquí que al considerar rawcomo recursos, se obtienen bandas dependientes de densidad / orientación / versión / etc., mientras que con assetseso debe hacerlo manualmente.
TWiStErRob

1
Elegí esta respuesta como argumento en contra de inventar la corriente principal de Android.
Zon

77

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.

Estructura de directorios


1
¿Qué pasa con los directorios de diseño como layout-v21?
Akshay Chordiya

44
No lo he probado, pero me imagino que simplemente creas una carpeta layout-v21 junto a las carpetas de diseño.
hitch.united

¡Funciona en gradle 2.0.0 y buildToolsVersion 23.0.2! Tenga en cuenta que el valor de configuración es 'src/main/res/layouts/content'y la ruta de esta configuración es'src/main/res/layouts/content/layout'
cwhsu


2
Buscado por un tiempo sin suerte, esta es la única solución que funcionó para mí. ¡Gracias por publicar una respuesta tan detallada con imágenes!
Machine Tribe

53

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

20

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.


¡También comparte el enlace de ese complemento!
Paresh Mayani

Hecho. De todos modos, siempre puede buscar "Agrupación de archivos de Android" en Android Studio -> Archivo -> Configuración -> Complementos
Sharpe

3
el complemento no funcionaba en la vista "Android", solo en la vista "Proyecto": /
Hugo Gresse

18

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 .


2
Me di cuenta de que cada vez que hacía cambios en un diseño con esta configuración, siempre tenía que hacer un cleanpara verlo reflejado en la aplicación.
Pawan Kumar

16

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.


16

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!


Usé tu enfoque, pero ¿cómo usarlo en la actividad? Creé una subcarpeta en la carpeta de diseños llamada admin y tiene un diseño admin_home cuando estoy en actividad y uso setContentView(R.layout.Admin.admin_home .)Admin.admin_home no se resuelve
Asmaa Rashad

Debería poder usarlo normalmente, como R.layout.admin_home. El script debería poder recoger automáticamente los nombres por usted. Avísame si puedes hacer que funcione.
Soy un dragón rana

funciona bien pero después de cambiar esta línea array.push("src/main/res");a def res="src/main/res"; array.push(res);porque tengo un error como parámetro de empuje quiere Gstring no de la secuencia una .Si cualquiera en lugar de me encontró este error se puede editar
Asmaa Rashad

1
Los diseños en las subcarpetas no pueden resolver el espacio de nombres de Android. Algunas ideas ?
Jaguar

¿Puede descomentar esas líneas // uncomment for debuggingy luego verificar si las salidas src/main/res/layouts/<your_layout_files>se detectan correctamente?
Soy un dragón rana

15

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

ingrese la descripción de la imagen aquí


Debe marcarse como respuesta correcta, ya que solo organice la agrupación con una convención de nombre simple. No es necesario cambiar gradle, ni siquiera la estructura de directorios predeterminada de una aplicación. Todo el diseño aún permanece en la carpeta de diseño, pero se agrupan enAndroid Studio
Alireza Fattahi

1
No debería ser la respuesta aceptada porque no funciona en la vista de Android ... (pero me encanta la idea ^^)
Appyx

Esto no funciona para la última última versión de Android ... ¿hay alguna versión actualizada?
user3053247

7

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

estructura de carpetas de ejemplo

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


4

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


Lo comprobaré pronto. Gracias
Paresh Mayani

1
Ese script coloca cambios en el nombre del archivo para incluir la jerarquía del directorio en el nombre del archivo. ¿Cómo funcionará eso con su IDE de Android con nombres de archivos cambiando por todas partes?
Stealth Rabbi

3

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.


1
Al poner un enlace simbólico se anula el propósito de querer modularizar el almacenamiento separando los componentes en diferentes subdirectorios: haciéndolo efectivamente más complejo en lugar de menos. Gradle permite las especificaciones de directorios de recursos adicionales.
RichieHH

3

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.


Estoy de acuerdo con usted en que AS no nota cambios en los archivos XML. Pero ¿cuál es la solución? Intentaré stackoverflow.com/questions/32317822/… .
CoolMind

3

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.


¡Esta debe considerarse la respuesta correcta! Simple y funcionando perfectamente!
Gláucio Leonardo Sant'ana

2

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.


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

Gracias por el Projectmodo. No pude entender dónde desaparecieron las subcarpetas (en Androidmodo).
CoolMind

0

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.


1
Verifique la respuesta aceptada. No lo he probado personalmente, pero si puede verificar y actualizar, ¡sería útil!
Paresh Mayani

0

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 .


Su comentario 'Hice carpetas con este artículo (enlace adjunto)' no es una forma aceptable de proporcionar soluciones aquí en SO Su respuesta es vaga. Puede dejar instrucciones y acreditar al autor con un enlace. De lo contrario, esto es simplemente vago.
jungledev

@jungledev, bueno, finalmente rechacé esta idea y regresé a una rescarpeta tradicional , porque AS no es totalmente compatible con la división de recursos en carpetas. Probablemente cambiaré esta respuesta o incluso la eliminaré. Pero, ¿qué quiere decir cuando dice que no es una forma aceptable de proporcionar soluciones aquí en SO?
CoolMind

Quiero decir exactamente lo que dije. No diga 'Lo hice con este tutorial ... (inserte el enlace)'. Lo que debe decir es: "Seguí este tutorial (inserte el enlace) y aquí están los pasos que funcionaron para mí. Paso 1, Paso 2, Paso 3 ... etc. 'Debe incluir los pasos AQUÍ en la respuesta. Simplemente enlazar a un tutorial es inaceptable.
jungledev

0

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']
    }
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.