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

En ce moment, je stocke tous les fichiers de mise en page XML dans le res/layoutdossier, il est donc possible et simple de gérer de petits projets, mais lorsqu'il y a un cas de projets volumineux et lourds, il devrait y avoir une hiérarchie et des sous-dossiers nécessaires à l'intérieur le dossier de mise en page.

par exemple

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

De la même manière, nous aimerions avoir des sous-dossiers pour la grande application, alors y a-t-il un moyen de le faire dans le projet Android?

Je peux créer des sous-dossiers layout-personal et layout_address dans le dossier layout, mais quand vient le temps d'accéder au fichier de mise en page xml à l'aide de R.layout ._______, à ce moment-là, il n'y a pas de pop-up de mise en page xml à l'intérieur du menu.

Vous pouvez le faire avec gradle. J'ai fait un projet de démonstration montrant comment.

L'astuce consiste à utiliser la capacité de gradle à fusionner plusieurs dossiers de ressources et à définir le dossier res ainsi que les sous-dossiers imbriqués dans le bloc sourceSets.

L'originalité est que vous ne pouvez pas déclarer un dossier de ressources de conteneur avant de déclarer les dossiers de ressources enfants de ce dossier.

Ci-dessous se trouve le bloc sourceSets du fichier build.gradle de la démo. Notez que les sous-dossiers sont déclarés en premier.

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

De plus, le parent direct de vos fichiers de ressources réels (pngs, dispositions xml, etc.) doit toujours correspondre à la spécification .

La réponse est non.

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

Il convient également de noter quelques contraintes concernant les ressources. Tout d'abord, Android ne prend en charge qu'une liste linéaire de fichiers dans les dossiers prédéfinis sous res. Par exemple, il ne prend pas en charge les dossiers imbriqués sous le dossier de disposition (ou les autres dossiers sous res).

Deuxièmement, il existe certaines similitudes entre le dossier des ressources et le dossier brut sous res. Les deux dossiers peuvent contenir des fichiers bruts, mais les fichiers dans raw sont considérés comme des ressources et les fichiers dans les actifs ne le sont pas.

Notez que parce que le contenu des actifs dossier ne sont pas considérés comme des ressources, vous pouvez mettre une hiérarchie arbitraire des dossiers et des fichiers dans ce.

Je voulais juste ajouter une réponse fantastique aux eskis pour les personnes en difficulté. (Remarque: cela ne fonctionnera et ne ressemblera qu'à des répertoires séparés dans la vue «projet», pas malheureusement la vue «android».)

Testé avec ce qui suit. BuildToolsVersion = 23.0.0 gradle 1.2.3 & 1.3.0

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

1. Copiez tous les fichiers XML hors de votre répertoire de disposition et placez-les dans un répertoire sur le bureau ou quelque chose pour la sauvegarde.
2. Supprimez l'intégralité du répertoire de mise en page (assurez-vous d'avoir tout sauvegardé à l'étape 1 !!!)
3. Cliquez avec le bouton droit sur le répertoire res et sélectionnez nouveau> répertoire.
4. Nommez ce nouveau répertoire "layouts". (Cela peut être ce que vous voulez, mais ce ne sera pas un répertoire 'fragment' ou un répertoire 'activité', qui viendra plus tard).
5. Faites un clic droit sur le nouveau répertoire "layouts" et sélectionnez nouveau> répertoire. (Ce sera le nom du type de fichiers XML que vous y trouverez, par exemple, «fragments» et «activités»).
6. Cliquez avec le bouton droit sur le répertoire «fragment» ou «activités» (Remarque: cela ne doit pas nécessairement être «fragment» ou «activités», c'est exactement ce que j'utilise comme exemple) et sélectionnez à nouveau nouveau> répertoire et nommez ce répertoire "disposition". (Remarque: cela DOIT être nommé «mise en page» !!! très important).
7. Placez les fichiers XML que vous souhaitez dans le nouveau répertoire «layout» de la sauvegarde que vous avez effectuée sur votre bureau.
8. Répétez les étapes 5 à 7 pour autant de répertoires personnalisés que vous le souhaitez.

9. Une fois cela terminé, allez dans le fichier gradle.build de vos modules et créez une définition sourceSets comme celle-ci ... (Assurez-vous que 'src / main / res / layouts' et 'src / main / res' sont toujours les deux derniers !!) !! Comme je le montre 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. Bénéfice $$$$

Mais sérieusement .. c'est ainsi que je l'ai fait fonctionner. Faites-moi savoir si quelqu'un a des questions .. Je peux essayer de vous aider.

Les images valent plus que les mots.

Pas possible, mais le dossier de disposition est trié par nom. Donc, je ajoute les noms des fichiers de mise en page avec les noms de mes packages. Par exemple, pour les deux packages "acheter" et "jouer":

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

J'utilise le plugin Android File Grouping pour Android Studio.Il ne vous permet pas vraiment de créer des sous-dossiers, mais il peut AFFICHER vos fichiers et ressources TELS qu'ils se trouvent dans différents dossiers. Et c'est exactement ce que je voulais.

Vous pouvez installer le plugin "Android File Grouping" en

Les fenêtres:

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

Mac:

Android Studio -> Onglet Android Studio (en haut à gauche) -> Préférences -> Plugins -> Installer le plugin JetBrains ..

Pour Mac, j'ai pu le tester et n'ai pas pu rechercher le plugin. J'ai donc téléchargé le plugin ici et utilisé l' Install plugin from diskoption du paramètre ci-dessus.

Désormais, avec Android Studio et Gradle, vous pouvez avoir plusieurs dossiers de ressources dans votre projet. Permet 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 comme ceci:

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

Consultez la documentation .

Je pense que la solution la plus élégante à ce problème (étant donné que les sous-dossiers ne sont pas autorisés) consiste à ajouter les noms de fichier au nom du dossier dans lequel vous l'auriez placé. Par exemple, si vous avez un tas de mises en page pour une activité, un fragment ou simplement une vue générale appelée "lieux", vous devez simplement la ajouter avec places_my_layout_name. Au moins, cela résout le problème de les organiser d'une manière plus facile à trouver dans l'IDE. Ce n'est pas la solution la plus impressionnante, mais c'est mieux que rien.

Petit problème

Je suis en mesure d'obtenir des sous-dossiers en suivant la première réponse à cette question.

Cependant, à mesure que 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.gradlechaque fois que vous ajoutez un nouveau dossier.

Amélioration

J'ai donc écrit une méthode Groovy simple pour récupérer tous les dossiers imbriqué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
}

Collez cette méthode en dehors du android {...}bloc 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 pathcomme argument. Le relative pathest relatif à la racine du projet. Ainsi, lorsque nous "app/src/main/res/layouts/"entrerons, il renverra le nom de tous les sous-dossiers sous forme de tableau, qui sera exactement le même que:

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

J'espère que cela aide!

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

consultez ce lien

Regroupement de fichiers Android

Une façon de le faire était de créer un dossier res séparé au même niveau que le dossier res réel dans votre projet, puis vous pouvez l'utiliser dans vos applications build.gradle

android {
    //other stuff

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

alors chaque sous-dossier de votre nouveau dossier res peut être quelque chose en rapport avec chaque écran particulier ou quelque chose dans votre application, et chaque dossier aura son propre layout/ drawable/ valuesetc garder les choses organisées et vous n'avez pas à mettre à jour le fichier gradle manuellement comme certains de ces autres les réponses nécessitent (synchronisez simplement votre gradle chaque fois que vous ajoutez un nouveau dossier de ressources pour qu'il en soit informé et assurez-vous d'ajouter les sous-dossiers appropriés avant d'ajouter vos fichiers xml).

Vérifier le script Bash Flatten Folder qui convertit la hiérarchie des dossiers en un seul dossier

Si vous développez sur un linux ou une boîte mac, une solution de contournement serait de créer des sous-dossiers qui incluent des liens symboliques vers vos fichiers de mise en page. Utilisez simplement la commande ln avec -s

ln -s PATH_TO_YOUR_FILE

Le problème est que votre dossier de mise en page contient toujours tous les fichiers .xml. Mais vous pouvez les sélectionner en utilisant les sous-dossiers. C'est ce qui se rapproche le plus de ce que vous aimeriez avoir.

Je viens de lire que cela pourrait également fonctionner avec Windows si vous utilisez Vista ou une version ultérieure. Il y a cecimklink commande. Il suffit de google, je ne l'ai jamais utilisé moi-même.

Un autre problème est que si vous avez ouvert le fichier et essayez de l'ouvrir à nouveau, le plugin lève une exception de pointeur NULL. Mais ça ne raccroche pas.

Bien que toutes les propositions pour plusieurs jeux de ressources puissent fonctionner, le problème est que la logique actuelle du plug-in Android Studio Gradle ne mettra pas à jour les fichiers de ressources après leur modification pour les jeux de ressources imbriqués. L'implémentation actuelle tente de vérifier les répertoires de ressources à l'aide de startsWith (), donc une structure de répertoires imbriquée (c'est-à-dire src / main / res / layout / layouts et src / main / res / layout / layouts_category2) choisira src / main / res / layout / layouts de manière cohérente et ne met jamais à jour les modifications. 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, j'ai donc écrit un script groovy en gradle pour une utilisation générale. Il est appliqué à tous les types de construction et à tous les produits et peut non seulement être utilisé pour la mise en page, mais vous pouvez également ajouter un sous-dossier pour tout autre type de ressources, tel que drawable. Voici le code (mettez-le dans un androidbloc de fichier gradle au niveau du projet):

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é activitypour layout, ajouter une chaîne par n'importe quel nom dans une resDirsvariable telle que layouts, puis le fichier xml de mise en page doit être placé dansres\layouts\activity\layout\xxx.xml .

Si je veux créer un sous-dossier nommé selectorspour drawable, ajouter une chaîne par n'importe quel nom dans une resDirsvariable telle que drawables, alors le fichier xml dessinable doit être placé res\drawables\selectors\drawable\xxx.xml.

Le nom du dossier tel que layoutset drawablesest défini en resDirsvariable, il peut s'agir de n'importe quelle chaîne. Tous les sous-dossiers créés par vous tels que activityou selectorssont considérés comme identiques au resdossier. Donc, dans le selectorsdossier, nous devons créer un drawabledossier en plus et mettre les fichiers xml dans le drawabledossier, après que gradle puisse reconnaître les fichiers xml comme dessinables normalement.

Si vous utilisez la méthode dans la réponse approuvée et que vous souhaitez l'améliorer un peu, modifiez le paramètre Gradle comme suit:

    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 source, laissez gradle obtenir tous les dossiers pour vous.

• Étape 1: clic droit sur la mise en page - afficher dans l'explorateur
• Étape 2: Ouvrez le dossier de disposition et créez directement les sous-dossiers: layout_1, layout_2 ...
• Étape 3: ouvrez layout_1 créer la mise en page du dossier (note: le nom obligatoire est la mise en page), ouvrez le dossier layout_2 créez le sous-répertoire de la mise en page (note: le nom obligatoire est la mise en page) ...
• Étape 4: copiez les fichiers xml dans les sous-répertoires de disposition dans layout_1 et layout_2
• Étape 5: Exécutez le code dans buid.grade (module module) et appuyez sur la synchronisation 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 que le regroupement des dossiers et l'affichage en mode «projet», tandis que le mode «android» s'affichera normalement.
• Je dessine donc que peut-être que nommer des préfixes est aussi efficace que de classer des dossiers.

Eh bien, la réponse courte est non. Mais vous pouvez certainement avoir plusieurs resdossiers. Je pense que c'est aussi proche que possible d'avoir des sous-dossiers pour le layoutdossier. Voici comment procéder.

Les meilleures réponses présentent plusieurs inconvénients: vous devez ajouter de nouveaux chemins de mise en page, AS place de nouvelles ressources dans le res\layoutsdossier au lieu de res\values.

En combinant plusieurs réponses, j'ai écrit des choses similaires:

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

J'ai créé 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 les changements de ressources ne sont pas remarqués par Android Studio . Ainsi, quelques bugs étranges apparaissent. Par exemple, les mises en page continuent d'afficher d'anciennes tailles et marges. Parfois, AS ne trouve pas de nouveaux fichiers XML (en particulier lors de l'exécution). Parfois, il mélange des view ids (références à un autre fichier XML). Il est souvent nécessaire d'appuyer sur Build > Clean Projectou Build > Rebuild Project. Lire Reconstruire requis après avoir modifié les fichiers de disposition xml dans Android Studio .

Ne peut pas avoir de sous-répertoires (facilement) mais vous pouvez avoir des dossiers de ressources supplémentaires . Surpris, personne ne l'a déjà mentionné, mais pour conserver les dossiers de ressources par défaut et en ajouter d'autres:

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