android-layout auto - La cartella Layout di Android può contenere sottocartelle?




studio linear (16)

Bene, la risposta breve è no. Ma sicuramente puoi avere più cartelle di ricerca. Questo, penso, è il più vicino possibile ad avere sottocartelle per la cartella di layout . Here's come lo fai.

In questo momento sto memorizzando ogni file di layout xml all'interno della cartella res/layout , quindi è possibile e semplice gestire piccoli progetti, ma quando c'è un caso di progetti grandi e pesanti, allora ci dovrebbe essere una gerarchia e cartelle necessarie all'interno della 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 -personale e layout_address all'interno della cartella di layout, ma quando arriva il momento di accedere al file di layout xml usando R.layout ._______, in quel momento non c'è alcun pop-up di layout xml all'interno del menu.


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

Il trucco consiste nell'utilizzare 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 contenitore prima di dichiarare le cartelle delle risorse figlio della 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'
        ]
    }
}

Inoltre, il genitore diretto dei tuoi file di risorse reali (pngs, layout xml, ecc.) Deve comunque corrispondere alle specification .


Un modo per farlo era 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()]
    }
}

allora ogni sottocartella della tua nuova cartella res può essere qualcosa che si riferisce ad ogni particolare schermo o qualcosa nella tua app, e ogni cartella avrà il proprio layout / drawable / values ecc mantenendo le cose organizzate e non devi aggiornare manualmente il file gradle come alcuni di queste altre risposte (Sincronizza il tuo gradle ogni volta che aggiungi una nuova cartella di risorse in modo che ne sia a conoscenza, e assicurati di aggiungere le sottocartelle pertinenti prima di aggiungere i tuoi file xml).


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 "riproduzione":

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

La risposta è no.

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

Vale anche la pena di 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 sotto la cartella di layout (o le altre cartelle sotto res).

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

Si noti che poiché i contenuti della cartella delle risorse non sono considerati risorse, è possibile inserire una gerarchia arbitraria di cartelle e file al suo interno.


Penso che la soluzione più elegante a questo problema (dato che le sottocartelle non sono consentite) è di anteporre i nomi dei file al nome della cartella in cui l'avresti inserito. Ad esempio, se disponi di una serie di layout per un'attività, un frammento o solo una vista generale chiamata "luoghi", dovresti semplicemente aggiungerla 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ù impressionante, ma è meglio di niente.


Uso il plug-in Raggruppamento file Android per Android Studio. In realtà non consente di creare sottocartelle, ma può VISUALIZZARE i file e le risorse poiché si trovano in cartelle diverse. E questo è esattamente quello che volevo.

Puoi installare il plug-in "Raggruppamento file Android" di

Finestre:

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

Mac:

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

Per Mac, sono riuscito a testarlo e non sono stato in grado di cercare il plug-in. Quindi ho scaricato il plug-in da here e ho usato l'opzione Install plugin from disk dall'impostazione precedente.


Se stai sviluppando su una macchina Linux o Mac, una soluzione alternativa sarebbe, 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 con Windows, anche se si utilizza Vista o versioni successive. C'è questo comando mklink . Basta google, non l'ho mai usato da solo.

Un altro problema è che se il file è aperto e prova ad aprirlo di nuovo, il plugin genera un'eccezione Pointer NULL. Ma non riaggancia.


La risposta migliore di @eski è buona, ma il codice non è elegante da usare, quindi ho scritto uno script groove in gradle per uso generale. È applicato a tutti i tipi di build e al gusto del prodotto e non solo può essere utilizzato per il layout, è anche possibile aggiungere una sottocartella per qualsiasi altro tipo di risorsa, ad esempio drawable. Ecco il codice (mettilo nel blocco android 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?

Ad esempio, desidero creare una sottocartella denominata activity per il layout , aggiungere una stringa con qualsiasi nome nella variabile resDirs come i layouts , quindi il file xml di layout deve essere inserito in res\layouts\activity\layout\xxx.xml .

Se voglio creare sottocartelle denominate selectors per drawable , aggiungi una stringa con qualsiasi nome nella variabile resDirs come drawables , quindi il file xml drawable dovrebbe essere messo in res\drawables\selectors\drawable\xxx.xml .

Il nome della cartella come layouts e drawables è definito nella variabile resDirs , può essere qualsiasi stringa. Tutte le sottocartelle create dall'utente come activity o selectors sono considerate uguali alla cartella res . Quindi, nella cartella dei selectors , dobbiamo creare anche una cartella drawable e mettere i file xml in una cartella drawable , dopo che gradle può riconoscere i file xml come disegnabili normalmente.


Le risposte principali hanno diversi svantaggi: devi aggiungere nuovi percorsi di layout, AS inserisce nuove risorse nella cartella res\layouts 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 di ricerca.

AGGIORNARE

Dopo un paio di settimane ho scoperto che le modifiche alle risorse non sono state notate da Android Studio . Quindi, appaiono alcuni bug strani. Ad esempio, i layout continuano a mostrare vecchie dimensioni, margini. A volte AS non trova nuovi file XML (specialmente durante l'esecuzione). A volte mischia view id (riferimenti ad un altro file XML). Spesso è necessario premere Build > Clean Project o Build > Rebuild Project . Leggi .com/questions/32317822/… .



Sebbene tutte le proposte per più set di risorse possano funzionare, il problema è che la logica corrente per il plug-in Android Studio Gradle non aggiornerà i file di risorse dopo che sono stati modificati per set di risorse annidate. L'attuale implementazione tenta di controllare le directory delle risorse usando startsWith (), quindi una struttura di directory che è annidata (es. Src / main / res / layout / layouts e src / main / res / layout / layouts_category2) sceglierà src / main / res / layout / layout in modo coerente e mai effettivamente aggiornare 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 provare a risolvere il problema.



  • Passaggio 1: fare clic con il pulsante destro del mouse sul layout: mostrare in Esplora risorse
  • Passaggio 2: aprire la cartella di layout e creare direttamente le sottocartelle: layout_1, layout_2 ...
  • Passaggio 3: apri layout_1 crea il layout della cartella (nota: il nome obbligatorio è layout), apri la cartella layout_2 crea la sottodirectory del layout (nota: nome obbligatorio è layout) ...
  • Passaggio 4: copia i file xml nelle sottodirectory di layout in layout_1 e layout_2
  • Passaggio 5: esegui il codice in buid.grade (modulo app) e premi subito la sincronizzazione:
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 le cartelle di clustering e verranno visualizzate in modalità 'progetto', mentre la modalità 'android' verrà visualizzata normalmente.
  • Così traggo che forse i prefissi di denominazione sono efficaci quanto le cartelle di clustering.

Se utilizzi il metodo nella risposta approvata e desideri migliorarlo un po ', modifica l'impostazione gradle in questo modo:

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

Pertanto, se aggiungi altre cartelle e layout, non è necessario tornare qui e aggiungere un lungo elenco di cartelle di origine, quindi lasciare a gradle recuperare tutte le cartelle.


Puoi esaminare i problemi relativi all'emulatore su Google I / O 2011: gli strumenti di sviluppo Android parlano, a partire da 0:40:20.

L'emulatore funziona lentamente perché l'ambiente Android completo è in esecuzione su hardware emulato e le istruzioni vengono eseguite anche su un processore ARM emulato.

Il punto di soffocamento principale è il rendering, poiché non è in esecuzione su alcun hardware dedicato, ma viene effettivamente eseguito tramite il rendering del software. L'abbassamento delle dimensioni dello schermo migliorerà drasticamente le prestazioni dell'emulatore. Ottenere più / memoria più veloce non aiuterà.

A quel tempo hanno accennato al fatto che stanno sviluppando un'interfaccia che permetterebbe all'emulatore di instradare determinate istruzioni attraverso l'hardware dell'host, così alla fine sarete in grado di sfruttare le prestazioni dell'emulatore con la potenza pura dell'hardware desktop.







android android-layout