Le dossier Android Layout peut-il contenir des sous-dossiers?

La réponse est non.

je voudrais attirer votre attention sur ce livre Pro Android 2 qui dit:

il est également intéressant de noter quelques les contraintes concernant les ressources. Tout d'abord, Android prend en charge seulement un linéaire liste des fichiers prédéfinis dossiers en vertu de la res. Par exemple, il ne supporte pas les dossiers imbriqués sous le dossier de mise en page (ou l'autre dossier en vertu de res).

deuxièmement, il y a des similitudes entre le dossier actif et le raw dossier sous res. Les deux dossiers peuvent contient des fichiers bruts, mais les fichiers dans les premières sont considérées comme des ressources et les fichiers dans les actifs ne sont pas.

noter que parce que le contenu de la actif dossier ne sont pas considérés ressources, vous pouvez mettre un arbitraire hiérarchie des dossiers et des fichiers il.

je voulais juste ajouter à la réponse fantastique d'eskis pour les gens qui ont des problèmes. (Note: cela ne fonctionnera et ressemblera qu'à des répertoires séparés à l'intérieur de la vue 'project', pas malheureusement la vue 'android'.)

Testé avec le suivant. BuildToolsVersion = 23.0.0 Grad 1.2.3 & 1.3.0

C'est comme ça que j'ai fait travailler le mien avec un projet déjà construit.

1. Copiez tous les fichiers XML à partir de votre mise en page répertoire, et les mettre dans un répertoire sur le bureau ou quelque chose pour la sauvegarde.
2. supprimer tout le répertoire de mise en page (assurez-vous que vous avez tout sauvegardé de l'étape 1!!!)
3. faites un clic droit sur le répertoire res et sélectionnez nouveau > répertoire.
4. nomme ce nouveau répertoire "layouts". (Cela peut être tout ce que vous voulez, mais ce ne sera pas un répertoire 'fragment' ou 'activity', qui viendra plus tard).
5. clic droit sur le nouveau répertoire "layouts" et sélectionnez new > directory. (Ce sera le nom du type de fichiers XML, vous aurez, par exemple, "fragments" et "activités").
6. faites un clic droit sur le répertoire' fragment 'ou' activités '(Note: il n'est pas nécessaire que ce soit' fragment 'ou' activités', c'est juste ce que j'utilise comme exemple) et sélectionnez new > directory une fois de plus et nommez ce répertoire "layout". (Note: Ceci doit être nommé 'layout'!!! très important).
7. Mettez les fichiers XML que vous voulez dans le nouveau répertoire "layout" de la sauvegarde que vous avez fait sur votre bureau.
8. répétez les étapes 5-7 pour autant de répertoires personnalisés que vous le désirez.

9. une fois que cela est terminé, allez dans votre grad de modules.créez un fichier et créez une définition de sourceSets comme celle-ci...(Assurez-vous que 'src/main/res/layouts' & 'src/main/res' sont toujours les deux derniers!!!! Comme je suis en train de montrer ci-dessous).

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

mais sérieusement.. c'est comment je l'ai eu à travailler. Dites-moi si quelqu'un a des questions.. Je peux essayer de l'aider.

les images valent plus que des mots.

impossible, mais le dossier de mise en page est trié par nom. Donc, je prépare les noms des fichiers de mise en page avec les noms de mes paquets. Par exemple: pour les deux paquets "acheter" et "jouer":

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

maintenant avec Android Studio et Gradle, vous pouvez avoir plusieurs dossiers de ressources dans votre projet. Permettant d'organiser non seulement vos fichiers de mise en page, mais tout type de ressources.

ce n'est pas exactement un sous-dossier, mais peut séparer des parties de votre application.

la configuration est la suivante:

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

cochez la case documentation .

I use Android File Grouping plugin for Android Studio.Il ne vous permet pas vraiment de créer des sous-dossiers, mais il peut afficher vos fichiers et ressources comme ils sont dans différents dossiers. Et c'est exactement ce que je voulais.

vous pouvez installer" groupe de fichiers Android "plugin par

Windows:

Android Studio -> Fichier -> Paramètres -> Plugins.

Mac:

Android Studio -> Onglet Android Studio (En Haut À Gauche) - > Préférences -> Plugins - > Install JetBrains Plugin..

pour Mac, j'ai pu le tester et n'ai pas pu chercher le plugin. J'ai donc téléchargé le plugin à partir de ici et utilisé l'option Install plugin from disk à partir du réglage ci-dessus.

je pense que la solution la plus élégante à ce problème (étant donné que les sous-dossiers ne sont pas autorisés) est de préparer les noms de fichier avec le nom du dossier dans lequel vous l'auriez placé. Par exemple, si vous avez un tas de layouts pour une activité, Un Fragment, ou juste une vue générale appelée "places" alors vous devriez juste le préparer avec places_my_layout_name. Au moins cela résout le problème de les organiser d'une manière qu'ils sont plus faciles à trouver dans L'IDE. Ce n'est pas le plus impressionnant solution, mais c'est mieux que rien.

Petit Problème

je suis capable de réaliser des sous-dossiers en suivant la top answer à cette question.

cependant, comme le projet s'agrandit, vous aurez de nombreux sous-dossiers:

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

pas un gros problème, mais:

• ce n'est pas joli car la liste devient très longue.
• vous devez changer votre app/build.gradle à chaque fois vous ajoutez un nouveau dossier.

amélioration

donc j'ai écrit une méthode Groovy simple pour saisir tous les dossiers emboîtés:

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
}

coller cette méthode en dehors du bloc android {...} dans votre app/build.gradle .

comment utiliser

pour une structure comme celle-ci:

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

utilisez-le comme ceci:

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

si vous avez une structure comme celle-ci:

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

vous l'utiliserez comme ceci:

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

explication

getLayoutList() prend a relative path comme argument. Le relative path est relatif à la racine du projet. Donc quand nous entrons "app/src/main/res/layouts/" , il retournera le nom de tous les sous-dossiers comme un tableau, qui sera exactement le même as:

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

voici le script avec des commentaires pour comprendre:

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
}

Espère que cela aide!

maintenant, nous pouvons facilement faire avec JetBrains plugin appelé " Android File Grouping "

regardez ce lien

Groupe De Fichiers Android

Un chemin que j'ai fait c'était de créer un dossier res au même niveau que le dossier res dans votre projet, vous pouvez l'utiliser dans vos applications de construction.Grad

android {
    //other stuff

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

ensuite chaque sous-dossier de votre nouveau dossier res peut être quelque chose se rapportant à chaque écran particulier ou quelque chose dans votre application, et chaque dossier aura leur propre layout / drawable / values etc garder les choses organisées et vous n'avez pas à mettre à jour le fichier gradle manuellement comme certaines de ces autres réponses exigent (il suffit de synchroniser votre gradle chaque fois que vous ajoutez un nouveau dossier de ressources afin qu'il sait à ce sujet, et assurez-vous d'ajouter les sous-dossiers pertinents avant d'ajouter vos fichiers xml).

Vérifier Bash Aplatir Dossier script qui convertit hiérarchie de dossiers dans un seul dossier

si vous développez sur une machine linux ou mac, une solution de contournement serait de créer des sous-dossiers qui incluent des liens symboliques vers vos layoutfiles. Il suffit d'utiliser la commande ln avec-s

ln-s PATH_TO_OUR_FILE

le problème avec cela est que votre dossier de mise en page contient encore tout le .des fichiers xml. Mais vous pouvez bien les sélectionner en utilisant les sous-dossiers. C'est ce qui se rapproche le plus de ce que tu aimerais avoir.

je viens de lire, que cela pourrait fonctionner avec Windows, aussi si vous utilisez Vista ou plus tard. Il y a cette commande mklink . Cherche sur google, Je ne l'ai jamais utilisé.

un autre problème est, si vous avez le fichier ouvert et essayer de l'ouvrir à nouveau sur le plugin lance une exception de pointeur nul. Mais il ne raccrochez pas.

alors que toutes les propositions pour les ensembles de ressources multiples peuvent fonctionner, le problème est que la logique actuelle pour le plug-in Android Studio Gradle ne mettra pas à jour les fichiers de ressources après qu'ils aient changé pour les ensembles de ressources imbriqués. L'implémentation actuelle tente de vérifier les répertoires de ressources en utilisant startsWith (), donc une structure de répertoire qui est imbriquée (c'est-à-dire src/main/res/layout/LAYOUT/layout/src/main/res/layout/layouts_category2) choisira src/main/res / layout / LAYOUT de manière cohérente et ne jamais mettre à jour les changements. Le résultat final est que vous devez reconstruire/nettoyer le projet à chaque fois.

j'ai soumis un patch à https://android-review.googlesource.com/#/c/157971/ pour essayer d'aider à résoudre les choses.

la meilleure réponse de @eski est bonne, mais le code n'est pas élégant à utiliser, donc j'ai écrit un script groovy dans gradle pour un usage général. Il est appliqué à tous le type de construction et la saveur du produit et non seulement peut être utilisé pour la mise en page, vous pouvez également ajouter un sous-dossier pour tout autre type de ressources comme drawable. Voici le code(mettez-le dans android bloc de projet-niveau du fichier gradle)"

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

Comment faire en pratique?

Par exemple, je veux créer un sous-dossier nommé activity pour layout , ajouter une chaîne de caractères par n'importe quel nom dans resDirs variable telle que layouts , puis le fichier de mise en page xml doit être mis dans res\layouts\activity\layout\xxx.xml .

si je veux créer un sous-dossier nommé selectors pour drawable , ajouter une chaîne de caractères par n'importe quel nom dans resDirs variable telle que drawables , alors le fichier XML étirable doit être mis dans res\drawables\selectors\drawable\xxx.xml .

le nom de dossier tel que layouts et drawables est défini dans resDirs variable, il peut être n'importe quelle chaîne. Tous les sous-dossiers créés par vous tels que activity ou selectors sont considérés comme identiques au dossier res . Ainsi, dans le dossier selectors , nous devons créer le dossier drawable en plus et mettre des fichiers xml dans le dossier drawable , après que Grad peut reconnaître les fichiers xml comme pouvant être dessinés normalement.

• Étape 1: clic droit sur la mise en page-afficher dans l'Explorateur
• Étape 2: Ouvrez le dossier layout et créez les sous-dossiers directement: layout_1, layout_2 ...
• Étape 3: Ouvrir layout_1 créer la disposition du dossier (note: le nom obligatoire est la disposition), ouvrir layout_2 créer le sous-répertoire de layout (note: le nom obligatoire est la disposition) ...
• Étape 4: copier les fichiers xml dans les sous-répertoires layout_1 et layout_2
• Étape 5: lancez le code dans buid.niveau (module d'application) et appuyez sur synchroniser maintenant:

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

• Étape 6: résumé: toutes les étapes ci-dessus n'aideront qu'à regrouper les dossiers et à afficher en mode "projet", tandis que le mode "android" affichera normalement.
• donc je dessine que peut-être nommer des préfixes est aussi efficace que regrouper des dossiers.

si vous utilisez la méthode dans la réponse approuvée, et que vous voulez l'améliorer sur un peu, alors changez le réglage du Grad comme ceci:

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

donc si vous ajoutez plus de dossiers et de mises en page, vous n'avez pas besoin de revenir ici et d'ajouter une longue liste de dossiers sources, laissez gradle obtenir tous les dossiers pour vous.

eh Bien, la réponse courte est non. Mais vous pouvez certainement avoir plusieurs dossiers res . Je pense que c'est aussi proche que possible d'avoir des sous-dossiers pour le dossier layout . voilà comment faire.

haut de la page les réponses ont plusieurs inconvénients: vous devez ajouter de nouveaux chemins de disposition, car Place de nouvelles ressources au dossier res\layouts au lieu de res\values .

combinant plusieurs réponses j'ai écrit similaire:

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

j'ai fait des dossiers avec cet article: http://alexzh.com/tutorials/how-to-store-layouts-in-different-folders-in-android-project / . Pour créer des sous-dossiers, vous devez utiliser ce menu: Nouveau > dossier > Dossier Res.

mise à JOUR

après quelques semaines, j'ai constaté que changements dans les ressources ne sont pas remarqué par Android Studio . Donc, des insectes bizarres apparaissent. Par exemple, les maquettes continuent de présenter des tailles et des marges anciennes. Parfois AS ne trouve pas de nouveaux fichiers XML (surtout pendant l'exécution). Parfois il mélange view id s (références à un autre fichier XML). Il est souvent nécessaire d'appuyer sur Build > Clean Project ou Build > Rebuild Project . Lire reconstruire nécessaire après avoir changé les fichiers de mise en page xml dans Android Studio .