Applying Styles and Themes

When designing your application, you can use styles and themes to apply uniform formatting to its various screens and UI elements.

• A style is a set of one or more formatting attributes that you can apply as a unit to single elements in your layout XML file(s). For example, you could define a style that specifies a certain text size and color, then apply it to instances of a certain type of View element.
• A theme is a set of one or more formatting attributes that you can apply as a unit to all activities in an application or just a single activity. For example, you could define a theme that sets specific colors for the window frame and the panel foreground and background, and sets text sizes and colors for menus, then apply it to the activities of your application.

스타일은 여러분의 레이아웃 XML 파일에 있는 하나의 엘리먼트 단위로 적용할 수 있는 하나 또는 그 이상의 포맷팅 애트리뷰트의 집합이다. 예를 들어 여러분은 특정 텍스트 크기와 그리고 컬러를 지정하는 스타일을 정의할 수 있고, 그런 다음 그것을 특정 유형의 뷰 엘리먼트의 인스턴스에 적용할 수 있다.
테마는 여러분이 애플리케이션 내의 모든 액티비티 또는 단지 하나의 액티비티 단위로 적용할 수 있는 하나 또는 그 이상의 포맷팅 애트리뷰트의 집합이다. 예를 들어 여러분은 윈도우 프레임과 패널 포어그라운드foreground와 백그라운드background에 대해 특정 색깔을 지정하고, 메뉴에 대해 텍스트 크기와 색을 지정하는 테마를 정의할 수 있으며, 그런 다음 여러분의 애플리케이션의 액티비티들에 그것을 적용할 수 있다.

Styles and themes are resources. Android provides some default style and theme resources that you can use, or you can declare your own custom style and theme resources.

To create custom styles and themes:

1. Create a file named styles.xml in the your application's res/values directory. Add a root <resources> node.
2. For each style or theme, add a <style> element with a unique name and, optionally, a parent attribute. The name is used for referencing these styles later, and the parent indicates what style resource to inherit from.
3. Inside the <style> element, declare format values in one or more <item> element(s). Each <item> identifies its style property with a name attribute and defines its style value inside the element.
4. You can then reference the custom resources from other XML resources, your manifest or application code.

여러분의 애플리케이션의 res/values 디렉토리에 styles.xml 라는 이름의 파일을 생성하라. 그리고 파일 안에 <resources> 루트root 노드를 추가하라.
각 스타일 또는 테마에 대해, 고유한 name 과 선택 사항으로 parent 애트리뷰트를 가지는 <style> 엘리먼트를 추가하라. name은 나중에 이 스타일을 레퍼런스하기 위해 사용되며, parent는 스타일 리소스가 상속받을 것을 가리킨다.
<style> 엘리먼트 내부에, 하나 또는 그 이상의 <item> 엘리먼트에 포맷 값들을 정의하라. 각각의 <item>은 name 애트리뷰트를 가지고 그것의 스타일 속성을 구분하며, 해당 엘리먼트 안에 그것의 값을 정의한다.
여러분은 그런 다음에 다른 XML 리소스, 여러분의 매니페스트 또는 애플리케이션 코드로부터 커스텀 리소스를 레퍼런스할 수 있다.

Styles

Here's an example declaration of a style:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="SpecialText" parent="@style/Text">
        <item name="android:textSize">18sp</item>
        <item name="android:textColor">#008</item>
    </style>
</resources>

As shown, you can use <item> elements to set specific formatting values for the style. The name attribute in the item can refer to a standard string, a hex color value, or a reference to any other resource type.

Notice the parent attribute in the <style> element. This attribute lets you specify a resource from which the current style will inherit values. The style can inherit from any type of resource that contains the style(s) you want. In general, your styles should always inherit (directly or indirectly) from a standard Android style resource. This way, you only have to define the values that you want to change.

Here's how you would reference the custom style from an XML layout, in this case, for an EditText element:

<EditText id="@+id/text1"
          style="@style/SpecialText"
          android:layout_width="fill_parent"
          android:layout_height="wrap_content"
          android:text="Hello, World!" />

Now this EditText widget will be styled as defined by the XML example above.

Themes

Just like styles, themes are also declared in XML <style> elements, and are referenced in the same manner. The difference is that you add a theme to an entire application or activity, via the <application> and <activity> elements in the Android Manifest themes cannot be applied to individual Views.

Here's an example declaration of a theme:

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <style name="CustomTheme">        
    <item name="android:windowNoTitle">true</item>
    <item name="windowFrame">@drawable/screen_frame</item>
    <item name="windowBackground">@drawable/screen_background_white</item>
    <item name="panelForegroundColor">#FF000000</item>
    <item name="panelBackgroundColor">#FFFFFFFF</item>
    <item name="panelTextColor">?panelForegroundColor</item>
    <item name="panelTextSize">14</item>
    <item name="menuItemTextColor">?panelTextColor</item>
    <item name="menuItemTextSize">?panelTextSize</item>
  </style>
</resources>

Notice the use of the at-symbol (@) and the question-mark (?) to reference resources. The at-symbol indicates that we're referencing a resource previously defined elsewhere (which may be from this project or from the Android framework). The question-mark indicates that we're referencing a resource value in the currently loaded theme. This is done by referring to a specific <item> by its name value. (E.g., panelTextColor uses the same color assigned to panelForegroundColor, defined beforehand.) This technique can be used only in XML resources.

Set the theme in the manifest

To set this theme for all the activites of your application, open the AndroidManifest.xml file and edit the <application> tag to include the android:theme attribute with the theme name:

<application android:theme="@style/CustomTheme">

If you want the theme applied to just one Activity in your application, then add the theme attribute to the <activity> tag, instead.

Just as Android provides other built-in resources, there are several themes that you swap in without having to write one yourself. For example, you can use the Dialog theme to make your Activity appear like a dialog box. In the manifest, reference an Android theme like so:

<activity android:theme="@android:style/Theme.Dialog">

If you like a theme, but want to slightly tweak it, just add the theme as the parent of your custom theme. For example, we'll modify the Theme.Dialog theme. To do so, create a style with Theme.Dialog as the parent:

<style name="CustomDialogTheme" parent="@android:style/Theme.Dialog">

There it is. We've inherited the Android Dialog theme so we can adjust its styles as we like. So, for each item in the Dialog theme that we want to change, we re-define the value here and use CustomDialogTheme instead of Theme.Dialog inside the Android Manifest.

Set the theme from the application

You can also load a theme for an Activity programmatically, if needed. To do so, use the setTheme() method. Note that, when doing so, you must be sure to set the theme before instantiating any Views in the context, for example, before calling setContentView(View) or inflate(int, ViewGroup). This ensures that the system applies the same theme for all of your UI screens. Here's an example:

 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...
    setTheme(android.R.style.Theme_Light);
    setContentView(R.layout.linear_layout_3);
}

If you are considering loading a theme programmatically for the main screen of your application, note that the theme would not be applied in any animations the system would use to start the activity, which would take place before your application opens. In most cases, if you want to apply a theme to your main screen, doing so in XML is a better approach.

For detailed information about custom styles and themes and referencing them from your application, see Available Resource Types: Style and Themes.

For information about default themes and styles available, see R.style.