Layout files naming conventions?

What are some layout file naming conventions people have come up with.

I haven't found anything online, but thought about using the following convention.

What does everyone think?

 - activity_* 
 - dialog_*
 - list_item_*

That's all I have worked with so far.

Also, what about the naming of the activity against its layout? For example:

-> res
    -&g开发者_运维问答t; layout
        -> activity_about_us.xml
-> src
    -> activity
        -> AboutUs.java

Strangely enough, trying to google this question brings only this page as meaningful result... For the past half year I am using naming convention similar to yours but with shorter prefixes. For example: For activity that shows "About us" screen:

Class name: ActAboutUs. Prefixing class is kind of overkill but it clearly distinguishes activity classes from the others. Initially I used separate directory for all the activities (similar to your approach) but after some time I realized that for bigger apps may be it is better to group in directories by feature than by superclass (i.e. Activity). It is easier for me to work in single directory for example /src/settings/ when I work on Settings. That way all java files that I need are in a single dir so i don't have to wander around:

/src/settings/ActSettingsGlobal.java
/src/settings/ActSettingsNet.java
/src/settings/Settings.java
/src/settings/SettingsDBAdapter.java
/src/settings/etc...

This approach also helps to split the work among different developers, i.e. each one is working in his own dir on separate feature so no stepping on each other's feet :-).

Some people preffer suffixes but I found them less useful. Prefixes help to group things alphabetically like in the example above: Act* prefix is sorted first so all activities are conveniently at the top.

I am even considering of using Act_ as a prefix which is more readable although it is in conflict with java naming conventions...

Layout filename: act_about_us.xml. In res/layout/ we don't have the "luxury" of subdirs which is quite unfortunate so the only way to group things is using appropriate prefix like act_, dlg_, etc...

String IDs: <string name="act_about_us_dlg_help1_title" ... string.xml is the place where we have most problems with duplicate names. It is very easy to create duplicates if naming convention like activity_element_item is not used. It adds a lot of additional typing but it saves you from a lot of confusion later on. For global (application wide) strings we use prefix "global_", for example global_btn_ok, global_msg_no_inet_conn. Usually we make one person responsible for all global_ strings so if someone needs new string or change he needs to sync with him in order to avoid creating a mess.

(now I am realizing that activity__element__item (two underscores) is more clear and readable than activity_element_item)

All in all I still can't get rid of the feeling that there is something wrong with my approach because I can't believe that google devs created such an inconvenient framework when it comes to working with files, IDs, names, etc...

i think following naming convention should be follow

for activity

if our activity name is

DisplayListActivity

then our layoutname should be

display_list_activity.xml

for list items we can include category in list item layout name

country_list_item.xml

and for dialogboxes their action can be included

delete_country_dialog.xml

When looking for a group of layouts, which is how I tend to work on them, I find it effective to always prepend the class name and follow up with any sub-layouts. For Instance:

Class Name: AboutActivity.java
Layout Name: about_activity.xml
Sub-layout Name: about_activity_menu.xml
Sub Sub-layout Name: about_activity_menu_item.xml

Your activity will always be at the top of each grouping and hunting for non-activities becomes less of a chore. Anyone know why sub-folders aren't a thing yet? I expect for efficiency and simplicity on the back-end, but I imagine it wouldn't hurt too much.

This is a good read https://jeroenmols.com/blog/2016/03/07/resourcenaming/

Basically, you follow WHAT WHERE DESCRIPTION SIZE

For example, layout file

• activity_main: content view of the MainActivity
• fragment_articledetail: view for the ArticleDetailFragment

strings

• articledetail_title: title of ArticleDetailFragment
• feedback_explanation: feedback explanation in FeedbackFragment

drawable - all_infoicon_large: large version of generic info icon - all_infoicon_24dp: 24dp version of generic info icon

The first part of a layout file name should always be the type of the corresponding class. For example if we have a class MainActivity (type is Activity in this case), the corresponding layout file should be called activity_main.xml

That means that lets say we have a dialog called WarningDialog, the corresponding layout file should be called dialog_warning.xml, same goes for fragments etc.

This might seem familiar because thats also how the activity/layout files are named when creating a new project in Android Studio (MainActivity -> activity_main.xml).

For me, naming should fix two important requirements:

1. it should give you a hint about files' content and type (for example activity_login/login_activity or movie_list_item/list_item_movie)
2. it should visually group related items together to minimize jumping back and forth

For the second requirement, most people define "related" as type related which gives you something like this:

activity_login
activity_movie_list
activity_user_list
activity_settings
fragment_movie_list
fragment_user_list
item_movie 
item_user

etc.

I prefer to do grouping by feature since you'll almost never work on all activities or all fragments, but instead, you'll work on movies feature or setting feature.

so, my prefered way is this:

login_activity
movie_list_activity
movie_list_fragment
movie_list_item 
user_list_activity
user_list_fragment
user_list_item
settings_activity

Source files are following xml naming but in CamelCase, so there will be

LoginActivity
MovieListActivity
MovieFragment 
etc.