¿Puede el directorio dibujable de Android contener subdirectorios?

En la documentación del SDK de Android, todos los ejemplos utilizados con la sintaxis @ drawable / my_image xml abordan directamente las imágenes que se almacenan en el directorio res / drawable de mi proyecto.

Me pregunto si explícitamente no está bien crear un subdirectorio dentro del directorio dibujable.

Por ejemplo, si tuviera el siguiente diseño de directorio:

res/drawable
-- sandwiches
  -- tunaOnRye.png
  -- hamAndSwiss.png
-- drinks
  -- coldOne.png
  -- hotTea.png

¿Podría hacer referencia a la imagen de un sándwich de ensalada de atún como @ drawable / sandwiches / tunaOnRye

¿O tengo que mantener la jerarquía plana en el directorio dibujable?

No, el mecanismo de recursos no admite subcarpetas en el directorio dibujable, por lo que sí, debe mantener esa jerarquía plana.

El diseño del directorio que mostró no resultaría en ninguna de las imágenes disponibles.

Según mis propios experimentos, parece que tener una subcarpeta con cualquier elemento dentro de la res/drawablecarpeta hará que el compilador de recursos falle, evitando que el R.javaarchivo se genere correctamente.

La solución alternativa que estoy usando (y la que Android parece favorecer) es esencialmente sustituir un guión bajo por una barra diagonal, para que su estructura se vea así:

sandwich_tunaOnRye.png
sandwich_hamAndSwiss.png
drink_coldOne.png
drink_hotTea.png

El enfoque requiere que sea meticuloso al nombrar y no hace que sea mucho más fácil manipular los archivos ellos mismos (si decidiera que las bebidas y los sándwiches realmente deberían ser " food", tendría que hacer un cambio de nombre masivo en lugar de simplemente moviéndolos al directorio); pero la complejidad de su lógica de programación no sufre demasiado en comparación con la estructura de carpetas equivalente.

Esta situación apesta de hecho. Android es una mezcla de decisiones de diseño maravillosas y terribles. Solo podemos esperar que la última porción sea eliminada con toda prisa :)

En realidad, en Android Studio es posible. Puede tener recursos anidados como se muestra aquí :

También hay un complemento para agrupar recursos aquí .

Sí, apesta :) Sin embargo, puede usar la carpeta de activos y tener subdirectorios allí y cargar imágenes de esa manera.

Use la carpeta de activos.

Código de muestra:

InputStream is = null;
try {
    is = this.getResources().getAssets().open("test/sample.png");
} catch (IOException e) {
    ;
}

image = BitmapFactory.decodeStream(is);

Escribí un complemento de eclipse que permite crear una subcarpeta virtual separando el nombre del archivo con dos guiones bajos __. El proyecto se encuentra en las primeras etapas, pero no se preocupe, no bloqueará su IDE.

Puede encontrar más detalles aquí, no dude en bifurcar y enviar solicitudes de extracción:

https://github.com/kirill578/Android-Sorted-Res-Folder

Me gusta usar una secuencia de comandos simple para aplanar una estructura de directorio organizada proporcionada por los diseñadores a algo que pueda usarse para generar un archivo R.

Ejecutar con la ruta actual en drawable-hdpi:

#! /bin/bash
DIRS=`find * -type d`
for dir in ${DIRS} ; do 
  for file in `ls ${dir}` ; do
    mv ${dir}/${file}  ${dir}_${file};
  done 
  rmdir ${dir};
done

En Android Studio con Gradle, puede tener múltiples directores de origen que le permitirán separar los recursos. Por ejemplo:

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

Sin embargo, los nombres no deben colisionar, lo que significa que aún necesitará tener nombres como sandwiches_tunaOnRye, pero podrá tener una sección separada para todos sus sándwiches.

Esto le permite almacenar sus recursos en diferentes estructuras (útil para contenido generado automáticamente como actionbargenerator)

Una forma de solucionar parcialmente el problema es utilizar el sufijo de nivel API. Yo uso res / layout-v1, res / layout-v2, etc. para mantener múltiples subproyectos en el mismo apk. Este mecanismo se puede usar para todos los tipos de recursos.

Obviamente, esto solo se puede usar si está apuntando a niveles de API por encima de res / layout-v? Tu estas usando.

Además, ten cuidado con el error en Android 1.5 y 1.6. Consulte la documentación de Andoroid sobre el sufijo de nivel API .

Con la llegada del sistema de bibliotecas, la creación de una biblioteca por gran conjunto de activos podría ser una solución.

Todavía es problemático ya que uno debe evitar usar los mismos nombres dentro de todos los activos, pero usar un esquema de prefijo por biblioteca debería ayudar con eso.

No es tan simple como poder crear carpetas, pero eso ayuda a mantener la cordura ...

Hay una solución para esta situación: puede crear una resVectorcarpeta (por ejemplo) en el mismo nivel que la rescarpeta predeterminada . Allí puede agregar cualquier drawable-xxxcarpeta de recursos allí:

resVector
-drawable
-layout
-color

Después de eso, todo lo que necesitas es agregar

sourceSets {
        main.res.srcDirs += 'src/main/resVector'
    }

en su build.gradlearchivo (dentro android { }).

Este no es un método perfecto. Debe implementar la misma forma que se muestra aquí .

También puede llamar a la imagen debajo de la carpeta a través del código que puede usar

Resources res = getResources();
Drawable shape = res. getDrawable(R.drawable.gradient_box);

TextView tv = (TextView)findViewByID(R.id.textview);
tv.setBackground(shape);

No es mío, pero encontré este hilo al buscar este problema, si estás usando Android Studio y el sistema Gradle Build, es bastante fácil, no se necesitan complementos, solo una pequeña edición del archivo de compilación

https://stackoverflow.com/a/22426467/618419

Gradle con Android Studio podría hacerlo de esta manera ( enlace ).

Está en el párrafo "Configuración de la estructura"

sourceSets {
 main {
    java {
        srcDir 'src/java'
    }
    resources {
        srcDir 'src/resources'
    }
 }
}

crear una carpeta en main como: 'res_notification_btn'

y crea una carpeta de árbol en.

luego en 'build.gradle' agregue esto

sourceSets
            {
                main
                {
                    res
                    {
                        srcDirs = ['src/main/res_notification_btn', 'src/main/res']
                      or
                        srcDir 'src/main/res_notification_btn'
                    }
                }
            }

#!/usr/bin/env ruby

# current dir should be drawable-hdpi/ etc

# nuke all symlinks
Dir.foreach('.') {|f|
    File.delete(f) if File.symlink?(f)
}

# symlink all resources renaming with underscores
Dir.glob("**/*.png") {|f|
    system "ln -s #{f} #{f.gsub('/', '_')}" if f.include?("/")
}

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

activos / Puede usarlo para almacenar archivos de activos sin procesar. Los archivos que guarde aquí se compilan en un archivo .apk tal cual y se conserva el nombre de archivo original. Puede navegar por este directorio de la misma manera que un sistema de archivos típico usando URI y leer archivos como una secuencia de bytes usando el AssetManager. Por ejemplo, esta es una buena ubicación para texturas y datos de juegos. http://developer.android.com/tools/projects/index.html

Los subdirectorios no están permitidos, el recurso debe contener solo [a-z0-9_.].

No, tienes letras mayúsculas y no hay barras diagonales.

1. Haga clic derecho en Drawable
2. Seleccione Nuevo ---> Directorio
3. Ingrese el nombre del directorio. Por ejemplo: logo.png (la ubicación ya mostrará la carpeta dibujable por defecto)
4. Copie y pegue las imágenes directamente en la carpeta dibujable. Al pegar, tiene la opción de elegir mdpi / xhdpi / xxhdpi, etc. para cada una de las imágenes de una lista. Seleccione la opción apropiada e ingrese el nombre de la imagen. Asegúrese de mantener el mismo nombre que el nombre del directorio, es decir, logo.png
5. Haga lo mismo para las imágenes restantes. Todos ellos se colocarán debajo de la carpeta principal logo.png.