La cartella Layout Android può contenere sottocartelle?


551

In questo momento, sto archiviando tutti i file di layout XML all'interno della res/layoutcartella, quindi è fattibile e semplice gestire piccoli progetti, ma quando c'è un caso di progetti grandi e pesanti, dovrebbero esserci una gerarchia e sottocartelle necessarie all'interno la cartella di layout.

per es

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

Allo stesso modo, vorremmo avere sottocartelle per la grande applicazione, quindi c'è un modo per farlo all'interno del progetto Android?

Sono in grado di creare sottocartelle layout-personal e layout_address all'interno della cartella layout, ma quando arriva il momento di accedere al file di layout xml utilizzando R.layout ._______, in quel momento non è presente alcun pop-up di layout xml all'interno del menù.



Penso che questo link possa aiutarti in dettaglio. blog.mindorks.com/…
Dilip Poudel,

Risposte:


475

Puoi farlo con Gradle. Ho realizzato un progetto dimostrativo che mostra come.

Il trucco è usare la capacità di Gradle di unire più cartelle di risorse e impostare la cartella res e le sottocartelle nidificate nel blocco sourceSets.

La stranezza è che non è possibile dichiarare una cartella di risorse del contenitore prima di dichiarare le cartelle di risorse figlio di quella cartella.

Di seguito è riportato il blocco sourceSets dal file build.gradle della demo. Si noti che le sottocartelle vengono dichiarate per prime.

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

immagine delle risorse nidificate

Inoltre, il genitore diretto dei tuoi file di risorse effettivi (png, layout xml, ecc.) Deve ancora corrispondere alle specifiche .


6
È possibile farlo con le cartelle disegnabili? Ho appena provato senza fortuna, anche tenendo conto dell'ordinamento delle dichiarazioni.
trevor-e

7
Bello! Ricorda solo che stai davvero sfruttando la capacità di Gradle di unire le cartelle delle risorse e avrà senso.
eski

5
I nomi dei file nella cartella devono ancora essere univoci e nel codice devi sapere che, ad esempio, R.layout.list_itemproviene dalla cartella movieso cinemas, quindi i nomi piatti si applicano comunque.
TWiStErRob,

5
Purtroppo questo non funziona con me build:gradle:0.14.4e buildToolsVersion "21.1.1".
Kamil Lelonek,

32
Funziona, tuttavia la risposta fa un lavoro terribilmente inadeguato nel spiegare che ogni sottocartella che aggiungi deve avere una seconda sottocartella al suo interno, che può essere chiamata solo "layout", e tutti i tuoi file di layout devono andare all'interno del seconda sottocartella / e. Leggere dozzine di commenti per capire che è tutt'altro che ideale. E per chiunque sia ancora alla ricerca, impostare le sottocartelle "layout" extra è la soluzione al URI is not registeredproblema.
aroth

233

La risposta è no.

Vorrei attirare la vostra attenzione su questo libro Pro Android 2 che afferma:

Vale anche la pena notare alcuni vincoli relativi alle risorse. Innanzitutto, Android supporta solo un elenco lineare di file all'interno delle cartelle predefinite in res. Ad esempio, non supporta le cartelle nidificate nella cartella layout (o le altre cartelle in ris).

In secondo luogo, ci sono alcune somiglianze tra la cartella delle risorse e la cartella non elaborata in res. Entrambe le cartelle possono contenere file raw, ma i file all'interno di raw sono considerati risorse e i file all'interno di asset no.

Si noti che, poiché il contenuto dei beni cartella non sono considerate le risorse, si può mettere una gerarchia arbitraria di cartelle e file all'interno di esso.


3
Ospite la nostra prossima migliore speranza sarebbe un plugin Eclipse o IntelliJ che potrebbe comprimere i file in base ai prefissi dei nomi dei file.
Jerry Brady,

15
@Justin controlla la soluzione che ho pubblicato per Gradle.
eski,

Immagino che una soluzione potrebbe essere quella di nominare i file come li vorresti classificati, quindi sembra che siano nelle sottocartelle. Aggiungo un "tag sottocartella" all'inizio del nome. Per esempio. tutte le attività sarebbero "activity_activityname.xml" e un'attività figlio potrebbe essere "activity_activityname_childactivity.xml" e così via. Qualsiasi altro file sarebbe "other_filename.xml". Questo è quello che faccio per evitare confusione. Accidenti, qualcuno mi ha battuto. Da tre anni>. <Mio male, non l'avevo visto.
Vedavyas Bhat,

1
È importante notare qui che considerando rawcome risorse si ottiene lo striping dipendente dalla densità / orientamento / versione / etc, mentre con esso assetsè necessario farlo manualmente.
TWiStErRob,

1
Scelta questa risposta come argomento contro la ricerca del mainstream Android.
Zon,

77

Volevo solo aggiungere la fantastica risposta di eskis per le persone che hanno problemi. (Nota: funzionerà e sembrerà solo una directory separata all'interno della vista 'progetto', non purtroppo la vista 'Android'.)

Testato con il seguente. BuildToolsVersion = 23.0.0 grado 1.2.3 e 1.3.0

È così che ho fatto lavorare il mio con un progetto già realizzato.

  1. Copia tutti i file XML dalla directory del layout e inseriscili in una directory sul desktop o qualcosa per il backup.
  2. Elimina l'intera directory di layout (assicurati di aver eseguito il backup di tutto dal passaggio 1 !!!)
  3. Fare clic con il tasto destro sulla directory res e selezionare new> directory.
  4. Denominare questa nuova directory "layout". (Questo può essere quello che vuoi, ma non sarà una directory 'frammento' o 'attività', che verrà dopo).
  5. Fare clic con il tasto destro sulla nuova directory "layout" e selezionare nuova> directory. (Questo sarà il nome del tipo di file XML che avrai in esso, ad esempio "frammenti" e "attività").
  6. Fai clic con il pulsante destro del mouse sulla directory "fragment" o "Activities" (Nota: questo non deve essere "framment" o "attività", è solo quello che sto usando come esempio) e seleziona di nuovo new> directory e dai un nome a questa directory "disposizione". (Nota: questo DEVE essere chiamato 'layout' !!! molto importante).
  7. Inserisci i file XML desiderati nella nuova directory 'layout' dal backup che hai effettuato sul desktop.
  8. Ripeti i passaggi da 5 a 7 per tutte le directory personalizzate che desideri.
  9. Una volta completato, vai nel tuo file gradle.build dei moduli e crea una definizione sourceSets come questa ... (Assicurati che 'src / main / res / layouts' e 'src / main / res' siano sempre i due in fondo !! !! Come sto mostrando di seguito).

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

Ma sul serio ... è così che l'ho fatto funzionare. Fammi sapere se qualcuno ha qualche domanda .. Posso provare ad aiutare.

Le immagini valgono più delle parole.

Struttura delle directory


1
Che dire di directory di layout come layout-v21?
Akshay Chordiya,

4
Non l'ho provato, ma immagino che tu crei semplicemente una cartella layout-v21 lungo le cartelle layout.
hitch.united,

Funziona su Gradle 2.0.0 e buildToolsVersion 23.0.2! Si noti che il valore di configurazione è 'src/main/res/layouts/content'e il percorso di questa configurazione è'src/main/res/layouts/content/layout'
cwhsu

3
Sto riscontrando problemi con questo stackoverflow.com/questions/41934004/…
Petra Barus

2
Cercata per un po 'senza fortuna, questa è l'unica soluzione che ha funzionato per me. Grazie per aver pubblicato una risposta così dettagliata con le immagini!
Machine Tribe,

53

Non possibile, ma la cartella di layout è ordinata per nome. Quindi, antepongo i nomi dei file di layout con i nomi dei miei pacchetti. Ad esempio per i due pacchetti "acquisto" e "gioco":

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

20

Uso il plug-in di raggruppamento di file Android per Android Studio, che non ti consente davvero di creare sottocartelle, ma può VISUALIZZARE i tuoi file e le risorse in quanto si trovano in cartelle diverse. E questo è esattamente quello che volevo.

È possibile installare il plug-in "Raggruppamento file Android" da

Finestre:

Android Studio -> File -> Impostazioni -> Plugin.

Mac:

Android Studio -> Scheda Android Studio (in alto a sinistra) -> Preferenze -> Plugin -> Installa JetBrains Plugin ..

Per Mac, sono stato in grado di testarlo e non sono stato in grado di cercare il plug-in. Quindi ho scaricato il plug-in da qui e ho utilizzato l' Install plugin from diskopzione dall'impostazione sopra.


Condividi anche il link di quel plugin!
Paresh Mayani,

Fatto. Ad ogni modo puoi sempre cercare "Raggruppamento file Android" in Android Studio -> File -> Impostazioni -> Plugin
Sharpe

3
il plugin non funzionava nella vista "Android", solo nella vista "Progetto": /
Hugo Gresse

18

Ora con Android Studio e Gradle, puoi avere più cartelle di risorse nel tuo progetto. Consentire di organizzare non solo i file di layout ma qualsiasi tipo di risorsa.

Non è esattamente una sottocartella, ma può separare parti dell'applicazione.

La configurazione è così:

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

Controlla la documentazione .


2
Ho notato che ogni volta che ho apportato modifiche a un layout in questa impostazione, ho sempre dovuto fare un cleanper vederlo riflesso sull'app.
Pawan Kumar,

16

Penso che la soluzione più elegante a questo problema (dato che le sottocartelle non sono consentite) sia anteporre i nomi dei file con il nome della cartella in cui lo avresti inserito. Ad esempio, se hai un sacco di layout per un'attività, un frammento o solo una vista generale chiamata "luoghi", devi semplicemente anteporre a places_my_layout_name. Almeno questo risolve il problema di organizzarli in modo che siano più facili da trovare all'interno dell'IDE. Non è la soluzione più fantastica, ma è meglio di niente.


16

Piccolo problema

Sono in grado di ottenere sottocartelle seguendo la risposta migliore a questa domanda.

Tuttavia, man mano che il progetto diventa più grande, avrai molte sottocartelle:

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

Non è un grosso problema, ma:

  • non è carino in quanto l'elenco diventa molto lungo.
  • devi cambiare app/build.gradleogni volta che aggiungi una nuova cartella.

Miglioramento

Quindi ho scritto un semplice metodo Groovy per afferrare tutte le cartelle nidificate:

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
}

Incolla questo metodo al di fuori del android {...}blocco nel tuo app/build.gradle.


Come usare

Per una struttura come questa:

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

Usalo in questo modo:

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

Se hai una struttura come questa:

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

Lo userai in questo modo:

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

Spiegazione

getLayoutList()prende a relative pathcome argomento. Il relative pathè relativo alla radice del progetto. Quindi, quando inseriamo "app/src/main/res/layouts/", restituirà tutto il nome delle sottocartelle come un array, che sarà esattamente lo stesso di:

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

Ecco lo script con commenti per la comprensione:

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
}

Spero che sia d'aiuto!


Ho usato il tuo approccio ma come usarlo in attività? ho creato una sottocartella nella cartella layout chiamata admin e ha il layout admin_home quando sono in attività e utilizzo setContentView(R.layout.Admin.admin_home .)Admin.admin_home non è stato risolto
Asmaa Rashad,

Dovresti essere in grado di usarlo normalmente, come R.layout.admin_home. Lo script dovrebbe essere in grado di raccogliere automaticamente i nomi per te. Fammi sapere se riesci a farlo funzionare.
Sono un drago rana

funziona bene, ma dopo aver cambiato questa linea array.push("src/main/res");di def res="src/main/res"; array.push(res);perché ho un errore come spinta vuole parametro Gstring non String uno .se qualcuno piuttosto che mi ha trovato questo errore è possibile modificarlo
Asmaa Rashad

1
I layout nelle sottocartelle non sono in grado di risolvere lo spazio dei nomi Android. Qualche idea ?
Jaguar,

Puoi decommentare quelle linee con // uncomment for debugginge quindi verificare se le uscite src/main/res/layouts/<your_layout_files>sono state correttamente rilevate?
Sono un drago rana il

15

Ora possiamo facilmente farlo con il plugin JetBrains chiamato " Raggruppamento di file Android "

controlla questo link

Raggruppamento di file Android

inserisci qui la descrizione dell'immagine


Deve essere contrassegnato come risposta corretta, in quanto organizza il raggruppamento solo con una convenzione di nome semplice. Non è necessario modificare la pendenza o persino la struttura di directory predefinita di un'app. Tutto il layout rimane ancora nella cartella layout ma sono raggruppati inAndroid Studio
Alireza Fattahi l'

1
Non dovrebbe essere la risposta accettata perché non funziona nella vista Android .... (ma adoro l'idea ^^)
Appyx,

Questo non funziona per l'ultima ultima versione di Android ... c'è qualche versione aggiornata?
user3053247,

7

Un modo in cui l'ho fatto è stato quello di creare una cartella res separata allo stesso livello della cartella res effettiva nel tuo progetto, quindi puoi usarla nelle tue build build.gradle

android {
    //other stuff

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

struttura di cartelle di esempio

quindi ogni sottocartella della tua nuova cartella res può essere qualcosa relativa a ciascuna schermata particolare o qualcosa nella tua app, e ogni cartella avrà il proprio layout/ drawable/ valuesetc mantenendo le cose organizzate e non dovrai aggiornare il file gradle manualmente come alcuni di questi altri le risposte richiedono (basta sincronizzare il tuo voto ogni volta che aggiungi una nuova cartella di risorse in modo che ne sia a conoscenza, e assicurati di aggiungere le relative sottocartelle prima di aggiungere i tuoi file xml).


4

Controlla lo script Cartella Bash Flatten che converte la gerarchia di cartelle in una singola cartella


Lo verificherò presto. Grazie
Paresh Mayani

1
Lo script inserisce le modifiche al nome del file per includere la gerarchia di directory nel nome del file. Come funzionerà con il tuo IDE Android con i nomi dei file che cambiano ovunque?
Stealth Rabbi,

3

Se stai sviluppando su un Linux o un Mac Box, sarebbe una soluzione alternativa per creare sottocartelle che includano collegamenti simbolici ai tuoi file di layout. Basta usare il comando ln con -s

ln -s PATH_TO_YOUR_FILE

Il problema è che la cartella Layout contiene ancora tutti i file .xml. Ma potresti anche selezionarli usando le sottocartelle. È la cosa più vicina a ciò che vorresti avere.

Ho appena letto che questo potrebbe funzionare anche con Windows se stai usando Vista o versioni successive. C'è questo mklinkcomando. Basta google, non l'ho mai usato da solo.

Un altro problema è che se il file è aperto e si tenta di riaprirlo, il plug-in genera un'eccezione del puntatore NULL. Ma non riattacca.


1
Mettere un symlink in sconfigge lo scopo di voler modulare l'archiviazione separando i componenti in diverse sottodirectory: rendendolo effettivamente più complesso anziché meno. Gradle consente le specifiche di directory di risorse aggiuntive.
RichieHH,

3

Sebbene tutte le proposte per più set di risorse possano funzionare, il problema è che la logica corrente per il plug-in Grado di Android Studio non aggiornerà i file di risorse dopo che sono stati modificati per set di risorse nidificate. L'implementazione corrente tenta di controllare le directory delle risorse usando startWith (), quindi una struttura di directory che è nidificata (cioè src / main / res / layout / layouts e src / main / res / layout / layouts_category2) sceglierà src / main / res / layout / layout coerentemente e non aggiorna mai effettivamente le modifiche. Il risultato finale è che devi ricostruire / pulire il progetto ogni volta.

Ho inviato una patch su https://android-review.googlesource.com/#/c/157971/ per cercare di aiutare a risolvere le cose.


Sono d'accordo con te che AS non nota le modifiche nei file XML. Ma qual è la soluzione? Proverò stackoverflow.com/questions/32317822/… .
CoolMind,

3

La risposta migliore di @eski è buona, ma il codice non è elegante da usare, quindi ho scritto uno script groovy in gradle per uso generale. Viene applicato a tutti i tipi di build e sapore del prodotto e non solo può essere utilizzato per il layout, ma è anche possibile aggiungere una sottocartella per qualsiasi altro tipo di risorsa come ad esempio il disegno. Ecco il codice (mettilo nel androidblocco del file gradle a livello di progetto) :

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

Come fare in pratica?

Per esempio, io voglio creare sottocartella denominata activityper layout, aggiungere una stringa con qualsiasi nome nella resDirsvariabile, ad esempio layouts, il file XML di layout dovrebbe essere messo in res\layouts\activity\layout\xxx.xml.

Se voglio creare sottocartella denominata selectorsper drawable, aggiungere una stringa con qualsiasi nome nella resDirsvariabile, ad esempio drawables, il file xml drawable dovrebbe essere messo in res\drawables\selectors\drawable\xxx.xml.

Il nome della cartella come layoutsed drawablesè definito in resDirsvariabile, può essere qualsiasi stringa. Tutte le sottocartelle create dall'utente come activityo selectorssono considerate uguali a quelle della rescartella. Quindi nella selectorscartella, dobbiamo creare drawableulteriormente la cartella e mettere i file xml nella drawablecartella, dopo che Gradle può riconoscere i file xml normalmente disegnabili.


Questa dovrebbe essere considerata la risposta corretta! Semplice e perfettamente funzionante!
Gláucio Leonardo Sant'ana

2

Se si utilizza il metodo nella risposta approvata e si desidera migliorarlo un po ', modificare l'impostazione della pendenza in questo modo:

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

Quindi, se aggiungi più cartelle e layout, non è necessario tornare qui e aggiungere un lungo elenco di cartelle di origine, lascia che Gradle ottenga tutte le cartelle per te.


1
  • Passaggio 1: fare clic con il pulsante destro del mouse su layout: mostra in Explorer
  • Passaggio 2: apri la cartella del layout e crea direttamente le sottocartelle: layout_1, layout_2 ...
  • Passaggio 3: apri layout_1 crea layout di cartella (nota: il nome obbligatorio è layout), apri la cartella layout_2 crea una sottodirectory di layout (nota: il nome obbligatorio è layout) ...
  • Passaggio 4: copiare i file xml nelle sottodirectory layout in layout_1 e layout_2
  • Passaggio 5: esegui il codice in buid.grade (app del modulo) e premi Sincronizza ora:

sourceSets {
    main {
        res.srcDirs =
            [
                'src / main / res / layout / layout_1'
                'src / main / res / layout / layout_2',
                'src / main / res'
            ]
    }
}
  • Passaggio 6: Riepilogo: tutti i passaggi precedenti aiuteranno solo il raggruppamento di cartelle e la visualizzazione in modalità "progetto", mentre la modalità "Android" verrà visualizzata normalmente.
  • Quindi disegno che forse i prefissi di denominazione sono efficaci quanto le cartelle di clustering.

Grazie per la Projectmodalità. Non riuscivo a capire dove scomparissero le sottocartelle (in Androidmodalità).
CoolMind

0

Bene, la risposta breve è no. Ma puoi sicuramente avere più rescartelle. Questo, penso, è il più vicino possibile ad avere sottocartelle per la layoutcartella. Ecco come lo fai.


1
Controlla la risposta accettata. Non l'ho provato personalmente, ma se è possibile controllare e aggiornare, sarebbe utile!
Paresh Mayani,

0

Le risposte migliori hanno diversi svantaggi: devi aggiungere nuovi percorsi di layout, AS posiziona nuove risorse nella res\layoutscartella anziché res\values.

Combinando diverse risposte ho scritto simili:

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

Ho creato cartelle con questo articolo: http://alexzh.com/tutorials/how-to-store-layouts-in-different-folders-in-android-project/ . Per creare sottocartelle è necessario utilizzare questo menu: Nuovo> Cartella> Cartella res.

AGGIORNARE

Dopo un paio di settimane ho scoperto che i cambiamenti nelle risorse non vengono notati da Android Studio . Quindi, compaiono alcuni strani bug. Ad esempio, i layout continuano a mostrare dimensioni, margini precedenti. A volte AS non trova nuovi file XML (specialmente durante il runtime). A volte mescola view ids (riferimenti a un altro file XML). Spesso è necessario premere Build > Clean Projecto Build > Rebuild Project. Leggi Ricostruzione richiesta dopo aver modificato i file di layout XML in Android Studio .


Il tuo commento 'Ho creato cartelle con questo articolo (link allegato)' non è un modo accettabile per fornire soluzioni qui su SO La tua risposta è vaga. Puoi lasciare istruzioni e accreditare all'autore un link. Altrimenti, questo è solo pigro.
jungledev,

@jungledev, beh, finalmente ho rifiutato questa idea e sono tornato a una rescartella tradizionale , perché AS non supporta completamente la divisione delle risorse in cartelle. Probabilmente cambierò questa risposta o addirittura cancellerò. Ma cosa intendi quando dici che non è un modo accettabile per fornire soluzioni qui su SO?
CoolMind

Intendo esattamente quello che ho detto. Non dire "L'ho fatto con questo tutorial .... (inserisci link)." Quello che dovresti dire è: "Ho seguito questo tutorial (inserisci link) e qui ci sono i passaggi che hanno funzionato per me. Passaggio 1, Passaggio 2, Passaggio 3 ... ecc." Devi includere i passaggi QUI nella risposta. Semplicemente il collegamento a un tutorial è inaccettabile
jungledev

0

Non è possibile avere sottodirectory (facilmente) ma è possibile avere cartelle di risorse aggiuntive . Sorpreso nessuno lo ha già menzionato, ma per mantenere le cartelle di risorse predefinite e aggiungerne altre:

    sourceSets {
        main.res.srcDirs += ['src/main/java/XYZ/ABC']
    }
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.