Kann der Android-Layout-Ordner Unterordner enthalten?

Im Moment speichere ich jede XML-Layoutdatei im res/layoutOrdner, so dass es machbar und einfach ist, kleine Projekte zu verwalten. Wenn es sich jedoch um große und schwere Projekte handelt, sollten eine Hierarchie und Unterordner erforderlich sein den Layoutordner.

für zB

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

Auf die gleiche Weise möchten wir Unterordner für die große Anwendung haben. Gibt es also eine Möglichkeit, dies innerhalb des Android-Projekts zu tun?

Ich kann Layout-Personal- und Layout_Adresse-Unterordner innerhalb des Layout-Ordners erstellen. Wenn jedoch der Zeitpunkt für den Zugriff auf die XML-Layoutdatei mit R.layout ._______ gekommen ist, befindet sich zu diesem Zeitpunkt kein XML-Layout-Popup im Speisekarte.

Sie können dies mit Gradle tun. Ich habe ein Demo-Projekt gemacht, das zeigt, wie.

Der Trick besteht darin, die Fähigkeit von gradle zu nutzen, mehrere Ressourcenordner zusammenzuführen und den res-Ordner sowie die verschachtelten Unterordner im sourceSets-Block festzulegen.

Die Besonderheit ist, dass Sie einen Containerressourcenordner nicht deklarieren können, bevor Sie die untergeordneten Ressourcenordner dieses Ordners deklariert haben.

Unten finden Sie den Block sourceSets aus der Datei build.gradle aus der Demo. Beachten Sie, dass die Unterordner zuerst deklariert werden.

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

Außerdem muss das direkte übergeordnete Element Ihrer tatsächlichen Ressourcendateien (PNGs, XML-Layouts usw.) weiterhin der Spezifikation entsprechen .

Die Antwort ist nein.

Ich möchte Ihre Aufmerksamkeit auf dieses Buch Pro Android 2 lenken , in dem es heißt:

Es ist auch erwähnenswert, einige Einschränkungen in Bezug auf Ressourcen. Erstens unterstützt Android nur eine lineare Liste von Dateien in den vordefinierten Ordnern unter res. Beispielsweise werden verschachtelte Ordner unter dem Layoutordner (oder die anderen Ordner unter res) nicht unterstützt.

Zweitens gibt es einige Ähnlichkeiten zwischen dem Assets-Ordner und dem Raw-Ordner unter res. Beide Ordner können Rohdateien enthalten, die Dateien in RAW werden jedoch als Ressourcen betrachtet und die Dateien in Assets nicht.

Beachten Sie, dass Sie eine beliebige Hierarchie von Ordnern und Dateien einfügen können, da der Inhalt des Assets- Ordners nicht als Ressourcen betrachtet wird .

Ich wollte nur die fantastische Antwort von eskis für Leute, die Probleme haben, ergänzen. (Hinweis: Dies funktioniert nur und sieht aus wie separate Verzeichnisse in der Projektansicht, leider nicht in der Android-Ansicht.)

Getestet mit folgendem. BuildToolsVersion = 23.0.0 Gradle 1.2.3 & 1.3.0

So habe ich meine dazu gebracht, mit einem bereits erstellten Projekt zu arbeiten.

1. Kopieren Sie alle XML-Dateien aus Ihrem Layoutverzeichnis und legen Sie sie in einem Verzeichnis auf dem Desktop oder einem Backup ab.
2. Löschen Sie das gesamte Layoutverzeichnis (Stellen Sie sicher, dass Sie alles aus Schritt 1 gesichert haben !!!)
3. Klicken Sie mit der rechten Maustaste auf das Verzeichnis res und wählen Sie new> directory.
4. Nennen Sie dieses neue Verzeichnis "Layouts". (Dies kann alles sein, was Sie wollen, aber es wird kein 'Fragment'-Verzeichnis oder' Aktivitäts'-Verzeichnis sein, das später kommt).
5. Klicken Sie mit der rechten Maustaste auf das neue Verzeichnis "Layouts" und wählen Sie "Neu"> "Verzeichnis". (Dies ist der Name des Typs der XML-Dateien, die Sie darin haben, z. B. 'Fragmente' und 'Aktivitäten').
6. Klicken Sie mit der rechten Maustaste auf das Verzeichnis 'Fragment' oder 'Aktivitäten' (Hinweis: Dies muss nicht unbedingt 'Fragment' oder 'Aktivitäten' sein, das ist nur das, was ich als Beispiel verwende) und wählen Sie erneut das Verzeichnis new> und benennen Sie dieses Verzeichnis "Layout". (Hinweis: Dies muss "Layout" genannt werden !!! sehr wichtig).
7. Fügen Sie die gewünschten XML-Dateien aus der Sicherung, die Sie auf Ihrem Desktop erstellt haben, in das neue Layout-Verzeichnis ein.
8. Wiederholen Sie die Schritte 5 bis 7 für so viele benutzerdefinierte Verzeichnisse, wie Sie möchten.

9. Sobald dies abgeschlossen ist, gehen Sie in die Datei gradle.build Ihres Moduls und erstellen Sie eine sourceSets-Definition wie diese ... (Stellen Sie sicher, dass 'src / main / res / layouts' und 'src / main / res' immer die beiden unteren sind !! !! Wie ich unten zeige).

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

Aber im Ernst ... so habe ich es zum Laufen gebracht. Lassen Sie mich wissen, wenn jemand Fragen hat. Ich kann versuchen zu helfen.

Bilder sind mehr wert als Worte.

Nicht möglich, aber der Layoutordner ist nach Namen sortiert. Daher stelle ich den Namen der Layoutdateien meine Paketnamen voran. ZB für die beiden Pakete "Kaufen" und "Spielen":

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

Ich verwende das Android File Grouping Plugin für Android Studio. Es ermöglicht Ihnen nicht wirklich das Erstellen von Unterordnern, aber es kann Ihre Dateien und Ressourcen so anzeigen, wie sie sich in verschiedenen Ordnern befinden. Und genau das wollte ich.

Sie können das Plugin "Android File Grouping" von installieren

Windows:

Android Studio -> Datei -> Einstellungen -> Plugins.

Mac:

Android Studio -> Registerkarte Android Studio (oben links) -> Einstellungen -> Plugins -> JetBrains Plugin installieren.

Für Mac konnte ich es testen und nicht nach dem Plugin suchen. Also habe ich das Plugin von hier heruntergeladen und die Install plugin from diskOption aus der obigen Einstellung verwendet.

Mit Android Studio und Gradle können Sie jetzt mehrere Ressourcenordner in Ihrem Projekt haben. So können Sie nicht nur Ihre Layoutdateien, sondern auch alle Arten von Ressourcen organisieren.

Es ist nicht gerade ein Unterordner, kann aber Teile Ihrer Anwendung trennen.

Die Konfiguration ist wie folgt:

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

Überprüfen Sie die Dokumentation .

Ich denke, die eleganteste Lösung für dieses Problem (da Unterordner nicht zulässig sind) besteht darin, den Dateinamen den Namen des Ordners voranzustellen, in dem Sie ihn abgelegt hätten. Wenn Sie beispielsweise eine Reihe von Layouts für eine Aktivität, ein Fragment oder eine allgemeine Ansicht mit dem Namen "Orte" haben, sollten Sie sie einfach mit "Plätze_mein_Layout_name" voranstellen. Zumindest löst dies das Problem, sie so zu organisieren, dass sie in der IDE leichter zu finden sind. Es ist nicht die tollste Lösung, aber es ist besser als nichts.

Kleines Problem

Ich kann Unterordner erreichen, indem ich der Top-Antwort auf diese Frage folge .

Wenn das Projekt jedoch größer wird, haben Sie viele Unterordner:

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

Kein großes Problem, aber:

• Es ist nicht schön, da die Liste sehr lang wird.
• Sie müssen Ihre app/build.gradlejedes Mal ändern, wenn Sie einen neuen Ordner hinzufügen.

Verbesserung

Also habe ich eine einfache Groovy-Methode geschrieben, um alle verschachtelten Ordner abzurufen:

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
}

Fügen Sie diese Methode außerhalb des android {...}Blocks in Ihre ein app/build.gradle.

Wie benutzt man

Für eine Struktur wie diese:

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

Verwenden Sie es so:

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

Wenn Sie eine Struktur wie diese haben:

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

Sie werden es so verwenden:

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

Erläuterung

getLayoutList()nimmt a relative pathals Argument. Das relative pathist relativ zur Wurzel des Projekts. Wenn wir also etwas eingeben "app/src/main/res/layouts/", wird der Name aller Unterordner als Array zurückgegeben, was genau dem entspricht:

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

Hier ist das Skript mit Kommentaren zum Verständnis:

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
}

Ich hoffe es hilft!

Jetzt können wir ganz einfach mit dem JetBrains-Plugin " Android File Grouping " arbeiten.

Schauen Sie sich diesen Link an

Android-Dateigruppierung

Eine Möglichkeit, wie ich es getan habe, bestand darin, einen separaten Res-Ordner auf derselben Ebene wie der eigentliche Res-Ordner in Ihrem Projekt zu erstellen. Dann können Sie diesen in Ihren Apps build.gradle verwenden

android {
    //other stuff

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

Dann kann jeder Unterordner Ihres neuen Res-Ordners etwas sein, das sich auf einen bestimmten Bildschirm oder etwas in Ihrer App bezieht, und jeder Ordner hat seine eigenen layout/ drawable/ valuesetc, um die Organisation zu gewährleisten, und Sie müssen die Gradle-Datei nicht wie einige dieser anderen manuell aktualisieren Antworten erforderlich (Synchronisieren Sie Ihren Gradle einfach jedes Mal, wenn Sie einen neuen Ressourcenordner hinzufügen, damit er davon erfährt, und stellen Sie sicher, dass Sie die entsprechenden Unterordner hinzufügen, bevor Sie Ihre XML-Dateien hinzufügen).

Prüfen Bash Flatten Ordner Skript , dass Konvertiten Ordner - Hierarchie in einem einzelnen Ordner

Wenn Sie unter Linux oder einer Mac-Box entwickeln, besteht eine Problemumgehung darin, Unterordner zu erstellen, die symbolische Links zu Ihren Layoutdateien enthalten. Verwenden Sie einfach den Befehl ln mit -s

ln -s PATH_TO_YOUR_FILE

Das Problem dabei ist, dass Ihr Layout-Ordner immer noch alle XML-Dateien enthält. Sie können sie jedoch mithilfe der Unterordner auswählen. Es ist das Nächste, was Sie gerne hätten.

Ich habe gerade gelesen, dass dies auch unter Windows funktionieren könnte, wenn Sie Vista oder höher verwenden. Es gibt diesen mklinkBefehl. Google es einfach, habe es selbst noch nie benutzt.

Ein weiteres Problem ist, wenn Sie die Datei geöffnet haben und versuchen, sie erneut zu öffnen, löst das Plugin eine NULL Pointer Exception aus. Aber es legt nicht auf.

Obwohl alle Vorschläge für mehrere Ressourcensätze möglicherweise funktionieren, besteht das Problem darin, dass die aktuelle Logik für das Android Studio Gradle-Plug-In die Ressourcendateien nicht aktualisiert, nachdem sie für verschachtelte Ressourcensätze geändert wurden. Die aktuelle Implementierung versucht, die Ressourcenverzeichnisse mit startWith () zu überprüfen, sodass eine verschachtelte Verzeichnisstruktur (dh src / main / res / layout / layouts und src / main / res / layout / layouts_category2) src / main / res auswählt / layout / layouts konsistent und aktualisieren Sie die Änderungen nie. Das Endergebnis ist, dass Sie das Projekt jedes Mal neu erstellen / bereinigen müssen.

Ich habe einen Patch unter https://android-review.googlesource.com/#/c/157971/ eingereicht, um zu versuchen, Probleme zu lösen.

Die Top-Antwort von @eski ist gut, aber der Code ist nicht elegant zu verwenden, deshalb habe ich ein grooviges Skript in Gradle für den allgemeinen Gebrauch geschrieben. Es wird auf alle Build-Typen und Produktvarianten angewendet und kann nicht nur für das Layout verwendet werden, sondern Sie können auch einen Unterordner für jeden anderen Ressourcentyp hinzufügen, z. B. zum Zeichnen. Hier ist der Code (in einen androidBlock der Gradle-Datei auf Projektebene einfügen):

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

Wie geht das in der Praxis?

Zum Beispiel möchte ich Unterordner mit dem Namen erstellen activityfür layout, fügen Sie eine Zeichenfolge , die von einem beliebigen Namen in resDirsVariable wie layoutssollte, dann ist das Layout XML - Datei in sein setzen res\layouts\activity\layout\xxx.xml.

Wenn ich will , Unterordner mit dem Namen erstellen selectorsfür drawableeine Zeichenfolge , die von einem beliebigen Namen in hinzufügen resDirsVariable wie drawables, dann ist die ziehbar XML - Datei setzt in sein sollte res\drawables\selectors\drawable\xxx.xml.

Der Ordnername wie layoutsund drawablesist in einer resDirsVariablen definiert . Es kann sich um eine beliebige Zeichenfolge handeln. Alle von Ihnen erstellten Unterordner wie activityoder selectorswerden als gleich wie resOrdner angesehen. Im selectorsOrdner müssen wir also zusätzlich einen drawableOrdner erstellen und XML-Dateien in den drawableOrdner legen. Danach kann gradle die XML-Dateien als normal zeichnbar erkennen.

Wenn Sie die Methode in der genehmigten Antwort verwenden und sie ein wenig verbessern möchten, ändern Sie die Gradle-Einstellung wie folgt:

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

Wenn Sie also weitere Ordner und Layouts hinzufügen, müssen Sie nicht hierher zurückkehren und eine lange Liste von Quellordnern anhängen. Lassen Sie gradle alle Ordner für Sie abrufen.

• Schritt 1: Klicken Sie mit der rechten Maustaste auf das Layout - im Explorer anzeigen
• Schritt 2: Öffnen Sie den Layoutordner und erstellen Sie die Unterordner direkt: layout_1, layout_2 ...
• Schritt 3: Öffnen Sie layout_1 Ordner erstellen Layout (Hinweis: obligatorischer Name ist Layout), öffnen Sie Layout_2 Ordner erstellen Layout Unterverzeichnis (Hinweis: obligatorischer Name ist Layout) ...
• Schritt 4: Kopieren Sie die XML-Dateien in die Layout-Unterverzeichnisse in layout_1 und layout_2
• Schritt 5: Führen Sie den Code in buid.grade (Modul-App) aus und klicken Sie jetzt auf Synchronisieren:

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

• Schritt 6: Zusammenfassung: Alle oben genannten Schritte helfen nur dabei, Ordner zu gruppieren und im Projektmodus anzuzeigen, während der Android-Modus wie gewohnt angezeigt wird.
• Daher stelle ich fest, dass das Benennen von Präfixen möglicherweise genauso effektiv ist wie das Clustering von Ordnern.

Die kurze Antwort lautet nein. Sie können aber definitiv mehrere resOrdner haben. Ich denke, das ist so nah wie möglich an Unterordnern für den layoutOrdner. Hier ist , wie Sie es tun.

Top-Antworten haben mehrere Nachteile: Sie müssen neue Layoutpfade hinzufügen, AS legt statt Ressourcen neue Ressourcen in res\layoutsOrdner ab res\values.

Ich habe mehrere Antworten kombiniert und ähnlich geschrieben:

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

Ich habe Ordner mit diesem Artikel erstellt: http://alexzh.com/tutorials/how-to-store-layouts-in-different-folders-in-android-project/ . Um Unterordner zu erstellen, sollten Sie dieses Menü verwenden: Neu> Ordner> Res-Ordner.

AKTUALISIEREN

Nach ein paar Wochen stellte ich fest, dass Änderungen an Ressourcen von Android Studio nicht bemerkt werden . Es treten also einige seltsame Fehler auf. Beispielsweise zeigen Layouts weiterhin alte Größen und Ränder. Manchmal findet AS keine neuen XML-Dateien (insbesondere zur Laufzeit). Manchmal mischt es view ids (Verweise auf eine andere XML-Datei). Es ist oft erforderlich, Build > Clean Projectoder zu drücken Build > Rebuild Project. Lesen Sie die erforderliche Neuerstellung, nachdem Sie die XML-Layoutdateien in Android Studio geändert haben .

Unterverzeichnisse können nicht (einfach) vorhanden sein, Sie können jedoch zusätzliche Ressourcenordner haben. Überrascht erwähnte es noch niemand, aber um die Standardressourcenordner beizubehalten und weitere hinzuzufügen:

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