Czy folder Układ Androida może zawierać podfoldery?

W tej chwili przechowuję każdy plik układu xml w res/layoutfolderze, więc zarządzanie małymi projektami jest wykonalne i proste, ale w przypadku dużych i ciężkich projektów potrzebna jest hierarchia i podfoldery potrzebne folder układu.

na przykład

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

W ten sam sposób chcielibyśmy mieć podfoldery dla dużej aplikacji, więc czy jest jakiś sposób, aby to zrobić w projekcie Android?

Jestem w stanie utworzyć podfoldery layout-personal i layout_address w folderze layoutu, ale gdy przyjdzie czas na dostęp do pliku layoutu xml przy użyciu R.layout ._______, w tym czasie nie ma wyskakującego okienka layout xml menu.

Możesz to zrobić z gradem. Zrobiłem projekt demonstracyjny pokazujący jak.

Sztuką jest wykorzystanie zdolności gradle do scalenia wielu folderów zasobów i ustawienia folderu res, a także zagnieżdżonych podfolderów w bloku sourceSets.

Dziwactwo polega na tym, że nie można zadeklarować folderu zasobów kontenera przed zadeklarowaniem folderów zasobów podrzędnych tego folderu.

Poniżej znajduje się blok sourceSets z pliku build.gradle z wersji demonstracyjnej. Zauważ, że podfoldery są zadeklarowane jako pierwsze.

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

Ponadto bezpośredni element nadrzędny twoich rzeczywistych plików zasobów (pngs, układy xml itp.) Nadal musi odpowiadać specyfikacji .

Odpowiedź brzmi nie.

Chciałbym zwrócić uwagę na tę książkę Pro Android 2, która stwierdza:

Warto również zauważyć kilka ograniczeń dotyczących zasobów. Po pierwsze, Android obsługuje tylko liniową listę plików w predefiniowanych folderach w res. Na przykład nie obsługuje zagnieżdżonych folderów w folderze układu (lub innych folderów w res).

Po drugie, istnieją pewne podobieństwa między folderem zasobów a folderem raw w res. Oba foldery mogą zawierać pliki RAW, ale pliki w RAW są uważane za zasoby, a pliki w zasobach nie.

Pamiętaj, że ponieważ zawartość folderu zasobów nie jest uważana za zasoby, możesz umieścić w nim dowolną hierarchię folderów i plików .

Chciałem tylko dodać do fantastycznej odpowiedzi eskis dla osób mających problemy. (Uwaga: będzie to działać tylko i wyglądać jak osobne katalogi w widoku „projektu”, niestety w widoku „Androida”).

Testowane z następującymi. BuildToolsVersion = 23.0.0 stopień 1.2.3 i 1.3.0

W ten sposób zmusiłem moją do pracy z już zbudowanym projektem.

1. Skopiuj wszystkie pliki XML z katalogu układu i umieść je w katalogu na pulpicie lub w celu wykonania kopii zapasowej.
2. Usuń cały katalog układu (upewnij się, że wykonałeś kopię zapasową wszystkiego od kroku 1 !!!)
3. Kliknij prawym przyciskiem myszy katalog res i wybierz nowy> katalog.
4. Nazwij ten nowy katalog „układami”. (Może to być cokolwiek chcesz, ale nie będzie to katalog „fragmentowy” ani katalog „aktywności”, który pojawi się później).
5. Kliknij prawym przyciskiem myszy nowy katalog „układów” i wybierz nowy> katalog. (Będzie to nazwa typu plików XML, które w nim będziesz mieć, na przykład „fragmenty” i „działania”).
6. Kliknij prawym przyciskiem myszy katalog „fragment” lub „działania” (Uwaga: nie musi to być „fragment” lub „działania”, którego właśnie używam jako przykładu) i ponownie wybierz nowy> katalog i nazwij ten katalog "układ". (Uwaga: MUSI się nazywać „układ” !!! bardzo ważne).
7. Umieść wybrane pliki XML w nowym katalogu „layout” z kopii zapasowej wykonanej na pulpicie.
8. Powtórz kroki 5–7 dla dowolnej liczby katalogów niestandardowych.

9. Po zakończeniu przejdź do pliku modułów gradle.build i utwórz definicję sourceSets taką jak ta ... (Upewnij się, że 'src / main / res / layouts' & 'src / main / res' zawsze znajdują się na dole dwóch !! !! Jak pokazuję poniżej).

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

Ale tak na poważnie ... tak to działa. Daj mi znać, jeśli ktoś ma jakieś pytania. Mogę spróbować pomóc.

Zdjęcia są warte więcej niż słowa.

Niemożliwe, ale folder układu jest sortowany według nazwy. Dlatego nazwy plików układu poprzedzam nazwami pakietów. Np. Dla dwóch pakietów „kupowanie” i „granie”:

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

Korzystam z wtyczki Android File Grouping dla Android Studio, która tak naprawdę nie pozwala na tworzenie podfolderów, ale może WYŚWIETLAĆ pliki i zasoby, ponieważ znajdują się one w różnych folderach. I właśnie tego chciałem.

Możesz zainstalować wtyczkę „Android File Grouping” przez

Windows:

Android Studio -> Plik -> Ustawienia -> Wtyczki.

Prochowiec:

Android Studio -> karta Android Studio (lewy górny róg) -> Preferencje -> Wtyczki -> Zainstaluj wtyczkę JetBrains ..

W przypadku komputerów Mac mogłem to przetestować i nie byłem w stanie wyszukać wtyczki. Pobrałem wtyczkę stąd i skorzystałem z Install plugin from diskopcji z powyższego ustawienia.

Teraz z Android Studio i Gradle, możesz mieć wiele folderów zasobów w swoim projekcie. Umożliwiając organizowanie nie tylko plików układu, ale wszelkiego rodzaju zasobów.

Nie jest to dokładnie podfolder, ale może zawierać oddzielne części aplikacji.

Konfiguracja wygląda następująco:

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

Sprawdź dokumentację .

Myślę, że najbardziej eleganckim rozwiązaniem tego problemu (biorąc pod uwagę, że podfoldery nie są dozwolone) jest dodanie nazw plików z nazwą folderu, w którym byłby umieszczony. Na przykład, jeśli masz kilka układów dla działania, fragmentu lub po prostu ogólny widok zwany „miejscami”, powinieneś po prostu dołączyć go do nazwy „nazwa_graj_miejsce”. Przynajmniej to rozwiązuje problem organizowania ich w taki sposób, aby łatwiej je było znaleźć w IDE. To nie jest najbardziej niesamowite rozwiązanie, ale jest lepsze niż nic.

Mały problem

Jestem w stanie osiągnąć podfoldery, postępując zgodnie z najlepszą odpowiedzią na to pytanie.

Jednak w miarę powiększania się projektu będziesz mieć wiele podfolderów:

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

Nie jest to duży problem, ale:

• nie jest ładna, ponieważ lista staje się bardzo długa.
• musisz zmienić swój app/build.gradleza każdym razem, gdy dodajesz nowy folder.

Poprawa

Napisałem więc prostą metodę Groovy, aby pobrać wszystkie zagnieżdżone foldery:

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
}

Wklej tę metodę poza android {...}blok w swoim app/build.gradle.

Jak używać

W przypadku takiej struktury:

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

Użyj tego w ten sposób:

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

Jeśli masz taką strukturę:

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

Użyjesz go w ten sposób:

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

Wyjaśnienie

getLayoutList()bierze a relative pathza argument. relative pathJest w stosunku do katalogu głównego projektu. Więc kiedy wprowadzimy "app/src/main/res/layouts/", zwróci nazwę wszystkich podfolderów jako tablicę, która będzie dokładnie taka sama jak:

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

Oto skrypt z komentarzami do zrozumienia:

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
}

Mam nadzieję, że to pomoże!

Teraz możemy łatwo zrobić z wtyczką JetBrains o nazwie „ Grupowanie plików Androida ”

sprawdź ten link

Grupowanie plików Androida

Sposobem, w jaki to zrobiłem, było utworzenie osobnego folderu res na tym samym poziomie, co rzeczywisty folder res w twoim projekcie, a następnie możesz użyć tego w kompilacji aplikacji. Gradle

android {
    //other stuff

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

wtedy każdy podfolder nowego folderu res może być czymś związanym z każdym konkretnym ekranem lub czymś w twojej aplikacji, a każdy folder będzie miał swój własny layout/ drawable/ valuesetc utrzymujący porządek i nie będziesz musiał ręcznie aktualizować pliku stopni, tak jak niektóre z tych innych odpowiedzi wymagają (po prostu zsynchronizuj ocenę za każdym razem, gdy dodajesz nowy folder zasobów, aby wiedział o tym, i upewnij się, że dodałeś odpowiednie podfoldery przed dodaniem plików xml).

Zaznacz skrypt Bash Spłaszcz folder, który konwertuje hierarchię folderów na pojedynczy folder

Jeśli pracujesz na systemie Linux lub Mac, obejście polega na utworzeniu podfolderów zawierających dowiązania symboliczne do plików układu. Wystarczy użyć polecenia ln z opcją -s

W -s PATH_TO_YOUR_FILE

Problem polega na tym, że folder Layout nadal zawiera wszystkie pliki .xml. Możesz jednak wybrać je za pomocą podfolderów. To najbliższa rzecz, którą chciałbyś mieć.

Właśnie przeczytałem, że może to działać również w systemie Windows, jeśli używasz systemu Vista lub nowszego. To jest tomklink polecenie. Wystarczy google, sam nigdy go nie użyłem.

Innym problemem jest to, że jeśli plik jest otwarty i spróbujesz go otworzyć ponownie, wtyczka zgłasza wyjątek NULL Pointer Exception. Ale się nie rozłącza.

Chociaż wszystkie propozycje dotyczące wielu zestawów zasobów mogą działać, problem polega na tym, że obecna logika wtyczki Android Studio Gradle nie zaktualizuje plików zasobów po ich zmianie na zagnieżdżone zestawy zasobów. Bieżąca implementacja próbuje sprawdzić katalogi zasobów za pomocą startWith (), więc zagnieżdżona struktura katalogów (tj. Src / main / res / layout / layouts i src / main / res / layout / layouts_category2) wybierze src / main / res / layout / layouts konsekwentnie i nigdy tak naprawdę nie aktualizuje zmian. W rezultacie musisz za każdym razem odbudować / wyczyścić projekt.

Przesłałem łatkę na https://android-review.googlesource.com/#/c/157971/, aby spróbować rozwiązać problem.

Najlepsza odpowiedź @eski jest dobra, ale kod nie jest elegancki w użyciu, więc napisałem świetny skrypt stopniowy do ogólnego użytku. Jest stosowany do wszystkich typów kompilacji i smaków produktów i nie tylko można go używać do układu, ale można również dodać podfolder dla dowolnego innego typu zasobów, np. Rysowalnego. Oto kod (umieść go w androidbloku pliku ocen na poziomie projektu) ：

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

Jak robić w praktyce?

Na przykład, chcę utworzyć podfolder activitydla layout, dodać ciąg dowolną nazwą w resDirszmiennej takich jak layouts, to plik xml układ należy umieścić wres\layouts\activity\layout\xxx.xml .

Jeśli chcę, aby utworzyć podfolder selectorsdla drawable, dodać ciąg dowolną nazwą w resDirszmiennej takich jak drawables, wtedy odkształcalne plik XML należy wprowadzić res\drawables\selectors\drawable\xxx.xml.

Nazwa folderu taka jak layoutsi drawablesjest zdefiniowana w resDirszmiennej, może to być dowolny ciąg. Wszystkie utworzone przez Ciebie podfoldery takie jak activitylub selectorssą traktowane tak samo jak resfolder. Tak więc w selectorsfolderze musimy drawabledodatkowo utworzyć folder i umieścić pliki xml w drawablefolderze, po czym grad może rozpoznać pliki xml jako normalnie dostępne do rysowania.

Jeśli użyjesz metody w zatwierdzonej odpowiedzi i chcesz ją nieco poprawić, zmień ustawienie gradacji w następujący sposób:

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

Więc jeśli dodasz więcej folderów i układów, nie musisz wracać tutaj i dołączać długiej listy folderów źródłowych, pozwól gradle uzyskać wszystkie foldery dla Ciebie.

• Krok 1: Kliknij układ prawym przyciskiem myszy - pokaż w eksploratorze
• Krok 2: Otwórz folder układu i utwórz bezpośrednio podfoldery: układ_1, układ_2 ...
• Krok 3: otwórz układ_1 utwórz układ folderu (uwaga: obowiązkowa nazwa to układ), otwórz folder układ_2 utwórz podkatalog układu (uwaga: obowiązkowa nazwa to układ) ...
• Krok 4: Skopiuj pliki XML do podkatalogów układu w layout_1 i layout_2
• Krok 5: Uruchom kod w buid.grade (aplikacja modułu) i naciśnij synchronizację teraz:

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

• Krok 6: Podsumowanie: wszystkie powyższe kroki pomogą tylko w klastrowaniu folderów i wyświetlą się w trybie „projektu”, podczas gdy tryb „Androida” będzie wyświetlany normalnie.
• Rysuję więc, że być może prefiksy nazewnictwa są tak samo skuteczne, jak foldery klastrowe.

Krótka odpowiedź brzmi „nie”. Ale na pewno możesz mieć wiele resfolderów. Myślę, że to jest tak blisko, jak to tylko możliwe, aby mieć podfoldery dla layoutfolderu. Oto jak to robisz.

Najważniejsze odpowiedzi mają kilka wad: musisz dodać nowe ścieżki układu, AS res\layoutszamiast tego umieszcza nowe zasoby w folderzeres\values .

Łącząc kilka odpowiedzi napisałem podobnie:

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

Zrobiłem foldery z tym artykułem: http://alexzh.com/tutorials/how-to-store-layouts-in-different-folders-in-android-project/ . Aby utworzyć podfoldery, powinieneś użyć tego menu: Nowy> Folder> Res Folder.

AKTUALIZACJA

Po kilku tygodniach zauważyłem, że Android Studio nie zauważa zmian w zasobach . Pojawiają się więc dziwne błędy. Na przykład układy nadal pokazują stare rozmiary, marginesy. Czasami AS nie znajduje nowych plików XML (szczególnie w czasie wykonywania). Czasami miesza view ids (odniesienia do innego pliku XML). Często trzeba nacisnąć Build > Clean Projectlub Build > Rebuild Project. Przeczytaj Odbuduj wymagane po zmianie plików układu XML w Android Studio .

Nie można mieć podkatalogów (łatwo), ale możesz mieć dodatkowe foldery zasobów. Zaskoczony, nikt już o tym nie wspominał, ale aby zachować domyślne foldery zasobów i dodać jeszcze kilka:

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