Ресурсы Android

Материал из AOW

Перейти к: навигация, поиск

Содержание

Основы

Ресурсы - один из основных компонентов, с которыми вам придется работать очень часто. В Android принято держать объекты, как изображения, строковые константы, цвета, анимацию, стили и т.п. за пределами исходного кода. Система поддерживает хранение ресурсов во внешних файлах. Внешние ресурсы легче поддерживать, обновлять, редактировать.

Каждое приложение на Android содержит каталог для ресурсов res/ и каталог для активов assets/. Реальное различие между ресурсами и активами заключается в следующем:

  • информация в каталоге ресурсов будет доступна в приложении через класс R, который автоматически генерируется средой разработки. То есть хранение файлов и данных в ресурсах (в каталоге res/) делает их легкодоступными для использования в коде программы;
  • для чтения информации, помещенной в каталог активов assets/ (необработанный формат файла), необходимо использовать AssetManager для чтения файла как потока байтов.

Позже, вы увидите, как Android умеет динамически выбирать данные из дерева ресурсов, содержащие разные значения для разных конфигураций, языков и регионов. При запуске Android автоматически загрузит нужный ресурс, не требуя ни одной строчки кода.

Ресурсы в Android являются декларативными. В основном ресурсы хранятся в виде XML-файлов в каталоге res с подкаталогами values, drawable-ldpi, drawable-mdpi, drawable-hdpi, layout, но также бывают еще два типа ресурсов: raw и assets.

Для удобства система создает идентификаторы ресурсов и использует их в файле R.java (класс R, который содержит ссылки на все ресурсы проекта), что позволяет ссылаться на ресурсы внутри кода программы. Статический класс R генерируется на основе ваших заданных ресурсов и создается во время компиляции проекта. При создании класс содержит статические подклассы для всех типов ресурсов, для которых был описан хотя бы один экземпляр. Подробнее о классе R рассказано ниже.

Так как файл R генерируется автоматически, то не смысла редактировать вручную, потому что все изменения будут утеряны при повторной генерации.

В общем виде ресурсы представляют собой файл (например, изображение) или значение (например, заголовок программы), связанные с создаваемым приложением. Удобств использования ресурсов заключается в том, что их можно изменять без повторной компиляции или новой разработки приложения. Имена файлов для ресурсов должны состоять исключительно из букв в нижнем регистре, чисел и символов подчеркивания.

Самыми распространенными ресурсами являются, пожалуй, строки (string), цвета (color) и графические рисунки (bitmap). В приложении не рекомендуется применять жестко написанные строки кода - вместо них следует использовать соответствующие идентификаторы, что позволяет изменять текст строкового ресурса, не изменяя исходного кода.

Начинающие программисты не всегда до конца правильно понимают процесс создания ресурсов. В Android используются два подхода - первый подход заключается в том, что ресурсы задаются в файле, при этом имя файла значения не имеет. Второй подход - ресурс задается в виде самого файла, и тогда имя файла уже имеет значение (при этом нужно учитывать определенные нюансы).

Общая структура каталогов, содержащих ресурсы выглядит следующим образом:

/res/values/strings.xml
           /colors.xml
		   /dimens.xml
		   /attrs.xml
		   /styles.xml
	/drawable/*.png
             /*.jpg
             /*.gif
             /*.9.png
    /anim/*.xml
    /layout/*.xml
    /raw/*.*
    /xml/*.xml
/assets/*.*/*.*

Только в assets может располагаться любой набор подкаталогов разной вложенности. Файлы, находящиеся в любом другом каталоге, размещаются именно на уровне этого каталога и не глубже.

Перечисление основных ресурсов Android

</tr>
Тип ресурсаРазмещениеОписание
Цвета/res/values/имя_файлаИдентификатор цвета, указывающий на цветовой код. ID таких ресурсов выражаются в R.java как R.color.*. XML-узел: /resources/color
Строки/res/values/имя_файлаСтроковые ресурсы. В их число также входят строки в формате java и html. ID таких ресурсов выражаются в R.java как R.string.*. XML-узел: resources/string. Можно использовать дополнительное форматирование при помощи стандартных html-тегов <b>, <i> и <u>. Методы, которые будут обрабатывать строковые ресурсы с HTML-форматированием, должны уметь обрабатывать эти теги.
Меню/res/values/имя_файлаМеню в приложении можно задать как XML-ресурсы.
Параметры/res/values/имя_файлаПредставляет собой параметры или размеры различных элементов. Поддерживает пикселы, дюймы, миллиметры, не зависящие от плотности экрана пикселы (dip) и пикселы, не зависящие от масштаба. ID таких ресурсов выражаются в R.java как R.dimen.*. XML-узел: resources/dimen
Изображения/res/drawable/ваши_файлыРесурсы-изображения. Поддерживает форматы JPG, GIF, PNG (самый предпочтительный) и др. Каждое изображение является отдельным файлом и получает собственный идентификатор, который формируется по имени файла без расширения. Такие ID ресурсов представлены в файле R.java как R.drawable.*. Система также поддерживает так называемые растягиваемые изображения (stretchable image), в которых можно менять масштаб отдельных элементов, а другие элементы оставлять без изменений.
Отрисовываемые цвета/res/values/ваш_файл или /res/drawable/ваши_файлыПредставляет цветные прямоугольники, которые используются в качетве фона основных отрисовываемых объектов, например точечных рисунков. Поддержка такой функции обеспечивается тегом значения drawable, находящимся в подкаталоге значений. Такие id ресурсов выражаются в файле R.java как R.drawable.*. ХМL-узел для такого файла: /resources/drawable. В Android при помощи специальных ХМL-файлов, расположенных в /res/drawable, также подерживаются скругленные и градиентные прямоугольники. Корневым ХМL-тегом для drawable является <shape>. Идентификаторы таких ресурсов выражаются в файле R.java как R.drawable.*. В таком случае, каждое имя файла преобразуется в уникальный id отрисовываемого объекта
Анимация/res/anim/ваш_файлAndroid может выполнить простую анимацию на графике или на серии графических изображений. Анимация включает вращения, постепенное изменение, перемещение и протяжение.
Произвольные XML-файлы/res/xml/*.xmlВ Android в качестве ресурсов могут использоваться произвольные XML-файлы. Они компилируются в aapt. Идентификаторы таких ресурсов также выражаются в файле R.java как R.xml.*
Произвольные необработанные ресурсы/res/raw/*.*Любые нескомпилированные двоичные или текстовые файлы, например, видео. Каждый файл получает уникальный id ресурса. Идентификаторы таких ресурсов выражаются в файле R.java как R.raw.*
Произвольные необработанные активы/assets/*.*/*.*Можно использовать произвольные файлы в произвольно названных каталогах, которые находятся в подкаталоге /assets. Это не ресурсы, а просто необработанные файлы. В этом каталоге, в отличие от /res, подкаталоги могут располагаться на любой глубине. Для таких файлов не создаются идентификаторы ресурсов. При работе с ними нужно использовать относительное имя пути, начиная с /assets, но не указываея этого каталгоа в имени пути

Идентификаторы

Этот тип ресурсов формируется, как правило, автоматически, и программисты даже не обращают на него внимания. Когда вы размещаете новый элемент на форме, с которым будете взаимодействовать в программе, то ему нужно присвоить идентификатор. Как правило, это происходит в виде @+id/editText1 (часто это происходит автоматически). Знак плюса обозначает, что если идентификатора не существует, то нужно создать в классе R. В программе вы можете обращаться к элементу R.id.editText1.

Но можно заранее создать ресурс типа item для задания id, не связанного ни с каким конкретным ресурсом:

<code class="xml"> 
<resources> 
    <item type="id" name="text"/> 
</resources>
</code>

Здесь type описывает тип ресурса, в данном случае id. Когда id будет установлен, будет работать и следующее определение View:

<code class="xml">
<TextView android:id="@id/text"> 
</TextView> 
</code>

На практике я не встречал такое применение, поэтому можете не обращать, что я тут выше написал.

Строковые ресурсы

Строковые ресурсы помогают упростить процесс создания локализованных версий. Строковые ресурсы обозначаются тегом <string>., <p>При http://developer.alexanderklimov.ru/android/android2.php разработке первого приложения вы видели, что система создала файл strings.xml, в котором хранились строки для заголовка приложения и выводимого сообщения. Вы можете редактировать данный файл, добавляя новые строковые ресурсы. А также вы можете создать новые файлы, которые будут содержать строковые ресурсы, например, strings2.xml, catnames.xml и т.д. Все эти файлы должны находиться в подкаталоге /res/values. Запомните, имена файлов и их число не важно. Но в большинстве случаев программисты используют для строковых ресурсов стандартное имя strings.xml. Типичный файл выглядит следующим образом.

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Здравствуй, Мир!</string>
    <string name="app_name">Hello, World</string>
</resources>
</code>

При создании или обновлении файла со строковыми ресурсами плагин Eclipse ADT автоматически создает или обновляет класс R.java в базовом корневом пакете вашего приложения (папка gen), сообщая уникальные ID для определенных в файле строковых ресурсов (Независимо от количества файлов ресурсов, в проекте содержится только один файл R.java). Если открыть данный файл, то можно найти там наши ресурсы в следующем виде:

public static final int hello = 0x7f040000; 
public static final int app_name = 0x7f040001;

В принципе достаточно запомнить, что R.java создает внутренний статический класс как пространство имен, в котором содержатся ID строковых ресурсов. Два static final int, которые используются в переменных hello и app_name, являются идентификаторами ресурсов и соответствуют соответствующим строковым ресурсам. Вы можете использовать данные идентификаторы в своем исходном коде, используя следующий формат - R.string.hello.

Обратите внимание, что сгенерированные ID указывают на int, а не на string. Android при необходимости самостоятельно подставляет вместо int нужные строки.

Напомню, что обычно принято хранить строковые ресурсы в файле strings.xml, но вы можете использовать несколько файлов. Главное, чтобы XML-файл имел необходимую структуру и находился в подкаталоге res/values.

Структура файла для строковых ресурсов довольно проста. Имеется корневой узел <resources>, за которым следуют один или несколько дочерних элементов <string>. Каждый элемент <string> в свою очередь имеет свойство name, которое в файле R.java представляет собой атрибут id.

Если вы создаете несколько файлов с ресурсами, то следите за уникальностью создаваемых имен. Вы понимаете, что не выйдет ничего хорошего, если в двух файлах будет одна и та же переменная app_name.

Продвинутые приемы работы со строковыми ресурсами

Кроме стандартного использования строковых ресурсов, можно использовть более сложные приемы. Посмотрим, как определять и использовать строки, написанные на HTML, а также узнаем, как происходит подстановка переменных в строковых ресурсах.

Начнем с того, как определять в ХМL-файлах ресурсов следующие виды строк:

  • обычные строки
  • строки в кавычках
  • НТМL-строки
  • заменяемые строки
<code class="xml">
<resources>
<string  name="simple_string">Простая строка</string>
<string  name="quoted_ string">"Строка в кавычках"</string> 
<string  name="double_quoted_string">\"Строка в двойных кавычках\"</string> 
<string  name="java_format_string">Привет %2$s. Здравствуй %1$s</string> 
<string  name="tagged_string"><b>Рыжик</b> - <i>мой любимый кот</i></string> 
</resources>
</code>

Этот ХМL-файл строковых ресурсов должен находиться в подкаталоге /res/values. Имя файла выбирается произвольно.

Обратите внимание - строки, находящиеся в кавычках, необходимо либо пропускать, либо помещать еще в одни кавычки. При определении строк также можно использовать стандартные последовательности Jаvа, предназначенные для форматирования строк.

Нельзя использовать символы '&amp', '<'. Задать эти символы можно используя специальную последовательность < — &lt; или & — &amp;. Если текст содержит html-теги и в нем встречается неразрывный пробел &nbsp;, то надо заменить на &#160;.

Также можно использовать простые элементы HTML, предназначенные для форматирования, используя теги <b> (полужирный шрифт), <i> (наклонный шрифрт), <u> (подчеркнутый шрифт). Вы можете использовать такую НТМL-строку для оформления текста, перед тем как выводить текст на экран.

Каждый вариант использования проиллюстрирован в листинге на примере кода Jаvа.

<code class="java">
// Считывание  обычной  строки  и  помещение  ее  в  текстовый  вид 
String simpleString  =  activity.getString (R.string.simple_string); 
textView.setText(simpleString);

// Считывание  строки в кавычках и помещение ее в текстовый вид
String quotedString  =  activity.getString(R.string.quotedstring);
textView.setText(quotedString);

// Считывание строки в двойных кавычках и помещение ее в текстовый  вид
String  doubleQuotedString  =  activity.getString(R.string.double_quoted_string); 
textView.setText(doubleQuotedString);

//  Считывание строки форматирования Java
String javaFormatString  =  activity.getString(R.string.java_format_string);
// Преобразование отформатированной строки при  помощи  данных 
// передаваемых в аргументах
String  substitutedString  =  String.format(javaFormatString, 
"Рыжик",  "Барсик" ); 
// помещение вывода в текстовый  вид 
textView.setText(substitutedString);

//  Считывание  строки  html_string из ресурса и помещение ее в текстовый  вид
String htmlTaggedString  =  activity.getString(R.string.tagged_string);
// Преобразование строки во фрагмент текста,
// который  может  быть  помещен  в  текстовом  виде
// Класс  android.text.Html допускает  рисование строк "html" (не все теги)
Spanned textSpan  =  android.text.Html.fromHtml(htmlTaggedString);
// Поместить  информацию  в  текстовый  вид 
textView.setText(textSpan);
</code>

После того, как вы определите строки в виде ресурсов, вы можете вставить их прямо в вид. Например, воспользуемся строкой на HTML в элементе TextView:

<code class="xml">
<TextView  
    android:layout_width="fill_ parent"
    ...
	android:text="@string/tagged string" /> 
</code>

TextView автоматически определяет, что эта строка написана на HTML, и соответствующим образом обрабатывает форматирование этой строки. Данный пример использовался в статье о http://developer.alexanderklimov.ru/android/activity.php создании нового окна.

Можно использовать строковые ресурсы в качестве входящих параметров для метода String.format. Однако данный метод не поддерживает стилизацию текста через теги <b>, <i>, <u>. Что выйти из этого положения, экранируйте HTML-теги следующим образом:

<string name="my_message">&lt;b>Жирный кот&lt;/b></string>

А в коде используйте метод Html.fromHtml для преобразования строки в нужном виде:

String rString = getString(R.string.my_message);
String fString = String.format(rString, "Bla-bla-bla");
CharSequence styledString = Html.fromHtml(fString);

Также существует особый вид ресурсов для строк - Строковые массивы

Есть еще один вид ресурсов, который редко используется, но может пригодиться - plurals, позволяющий задавать строки для разных ситуаций. Например, в английском языке мужчина в единственном числе - man, а во множественном - men.

<code class="xml">
<plurals name="NumberOfMan">
    <item quantity="one">man</item>
    <item quantity="other">men</item>
</plurals>
</code>

Более подробно об этом типе ресурсов читайте в http://developer.android.com/guide/topics/resources/string-resource.html#Plurals документации.

Системные строковые ресурсы

Во многих случаях можно задействовать системные строковые ресурсы - это строки типа OK, Cancel и др. В этом случае используется схожий формат (добавляется слово android):

<code class="xml">
android:text="@android:string/cancel"
</code>

Булевы ресурсы

Можно также хранить в ресурсах булевы значения true или false в файле с произвольным именем в папке res/values.

В файле с корневым элементом <resources> вы определяете элемент <bool> с нужным значением. У элемента есть атрибута name - строка, определяющая имя булевого ресурса.

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="autostart">true</bool>
    <bool name="sound">no</bool>
</resources>
</code>

Получить значение через код:

<code class="java">
Resources res = getResources();
boolean AutostartSetting = res.getBoolean(R.bool.autostart);
</code>

В макете для булевых атрибутов

<code class="xml">
<ImageView
    android:layout_height="fill_parent"
    android:layout_width="fill_parent"
    android:adjustViewBounds="@bool/adjust_view_bounds" />
</code>


Числовые ресурсы

В ресурсах можно хранить числа типа Integer. Хранить можно в произвольном имени XML-файла в папке res/values/ в корневом элементе <resources>

У элемента <integer> есть атрибут name, определяющий имя числового значения.

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <integer name="max_speed">75</integer>
    <integer name="min_speed">5</integer>
</resources>
</code>

Для работы в коде:

<code class="java">
Resources res = getResources();
int maxSpeed = res.getInteger(R.integer.max_speed);
</code>

Не создавайте меню в коде приложения, а используйте отдельные ресурсы для меню в формате XML. Можно использовать как для описания обычного и контекстного меню. Меню, описанное в формате XML, загружается в виде программного объекта с помощью метода inflate, принадлежащего сервису MenuInflater. Как правило, это происходит внутри обработчика onCreateOptionsMenu (смотри урок http://developer.alexanderklimov.ru/android/menu.php Меню).

Описание меню хранится в отдельном файле в каталоге res/menu. Имена файлов без расширения автоматически становятся идентификаторами ресурсов.

В ХМL-файле меню есть три элемента:

  • <menu> — корневой элемент файла меню;
  • <group> — контейнерный элемент, определяющий группу меню;
  • <item> — элемент, определяющий пункт меню

Элементы <item> и <group> могут быть дочерними элементами <group>.

Элемент item может иметь несколько атрибутов:

id</dt>
Идентификатор пункта меню, по которому приложение может распознать при выделении пункта меню пользователем</dd>
title</dt>
Текст, который будет выводиться в меню</dd>
icon</dt>
Значок для пункта меню. Можно использовать графический ресурс</dd>

Ресурсы разметки

Еще один из важных видов ресурсов - ресурсы разметки, которые отвечают за внешний вид приложения. Данные ресурсы представлены в формате XML. Ресурс разметки формы (layout resource) - это ключевой тип ресурсов, применяемый при программировании пользовательских интерфейсов в Android. Каждый ресурс, описывающий разметку, хранится в отдельном файле каталога res/layout. Имя файла без расширения выступает как идентификатор ресурса.

Ниже представлен фрагмент исходного кода для разметки:

<code class="java">
setContentView(R.layout.main);
</code>

Строка setContentView(R.layout.main); указывает на то, что у нас имеется статический класс, называемый R.layout, в котором есть константа main (некое число), указывающая на View, определяемый в ХМL-файле ресурса разметки формы. ХМL-файл будет иметь имя main.xml, и он должен быть размещен в подкаталоге ресурсов res/layout и содержать необходимое определение разметки формы.

Содержимое самого файла main.xml может быть таким:

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello"
    />
</LinearLayout>
</code>

В данном файле разметки формы имеется корневой узел <LinearLayout>, в котором содержится дочерний элемент <TextView>.

Для каждого варианта разметки требуется специальный файл. Если вы рисуете два экрана, вам понадобится два файла разметки, например /res/layout/screenl_layout.xml и /res/layout/screen2_layout.xml. Каждый файл в подкаталоге /res/layout генерирует уникальную константу на основе имени файла (без расширения). При работе с ресурсами разметки здесь важно количество файлов, а при работе со строковыми ресурсами важно количество отдельных строковых ресурсов внутри файлов. Например, если в подкаталоге /res/layout у нас есть два файла filel.xml и filе2.xml, то в файле R.java будут содержаться следующие записи:<p>

public static final int file1=0x7f030000;
public static final int file2=0x7f030001;

Элементы управления, которые используются в данных файла компоновки, например, TextView, будут доступны в коде через ID, генерируемым в R.java:

<code class="java">
TextView  tv  =  (TextView)this.findViewByld(R.id.text1); 
</code>
<p>В данном примере мы находим файл TextView при помощи метода findViewByid класса Activity. Константа R.id.textl соответствует ID, заданному в TextView. ID для TextView в файле разметки выглядит следующим образом:

<code class="xml"> 
<TextView  android:id="@+id/textl" />
</code>

Значение атрибута id указывает, что константа text1 будет использоваться для идентификации этого вида среди других, используемых данным окном. Знак + в @+id/text1 означает, что будет создан ID textl, если он еще не существует.

Синтаксис ссылок на ресурсы

Все ресурсы Android идентифицируются по их id, содержащемуся в исходном коде Jаvа. Синтаксис, используемый при связывания id с ресурсом в файле XML, называется синтаксис ссылок на ресурс (resource-reference syntax). Синтаксис атрибута id в предыдущем примере @+id/textl имеет следующую структуру:

 
@[package:]type/name

Параметр tуре соответствует одному из пространств имен:

  • R.drawable
  • R.id
  • R.layout
  • R.string
  • R.attr
  • и др.

Параметр name - это имя ресурса. Она также представлена в виде константы int в файле R.java.

Если не указывать пакет (package), то разрешение пары type/name будет производиться на основе локальных ресурсов и локального пакета R.java. Если указать android:type/name, то связывание ID ссылки будет производиться с применением пакета Android, в частности с использованием файла android.R.java. Вы можете использовать имя любого пакета jаvа вместо подстановочного слова package, чтобы использовать файл R.java, подходящий для связывания ссылки.

Рассмотрим несколько примеров

TextView android:id="text" - Ошибка компиляции,так как id не принимает необработанные текстовые строки

TextView android:id="@text" - Неправильный синтаксис. Не хватает названия типа. Вы получите сообщение об ошибке "No Resource type specified"

TextView android:id="@id/text - Ошибка: не найдено ни одного ресурса, соответствующего id "text". Возможно, вы не задали "text" как один из видов ID

TextView android:id="@android:id/text" - Ошибка: 11 Ошибка : Ресурс не является общедоступным". Означает, что такой id отсутствует в android.R.id. Чтобы такая запись была действительной, необходимо в файле Android.R.java задать id с таким именем

TextView android:id=="@+id/text - Успешно: создает id с названием "text" в файле R.java локального пакета.

Определение собственных идентификационных номеров ресурсов для последующего использования

Общий принцип присвоеимя id предполагает либо создание нового id для ресурса, либо использование одного из id, созданных в пакете Android. Однако id можно создавать и заранее, а потом использовать их в собственных пакетах.

Строка <TextView android:id="@+id/text"> в предыдущем фрагменте кода указывает, что id с названием text, будет использоваться в том случае, если этот id уже создан. Если id еще не существует, нужно создать новый идентификатор. В связи с этим возникает вопрос: может ли id, например, text уже существовать в файле R.java, чтобы такой идентификатор можно было использовать многократно?

Можно предположить, что такую задачу могла бы выполнять константа, например R.id.text, находящаяся в файле R.java, но R.java не поддается редактированию. Даже, если бы было возможно внести такие изменения, файл приходилось бы заново генерировать после добавления, изменения или удаления любой информации из подкаталога /res /*.

Решение проблемы заключается в использовании тега ресурса под названием item для задания id, не связанного ни с каким конкретным ресурсом. Ниже приведен соответствующий пример:

<code class="xml">
<resources> 
<item  type="id"  name="text "/> 
</ resources> 
</code>

Здесь type описывает тип ресурса, в данном случае id. Когда id будет установлен, будет работать и следующее определение View:

 
<TextView  android:id="@id/text"/>


Цветовые ресурсы

Для работы со цветом используется тег <color>, а цвет указывается в специальных значениях.

  • #RGB;
  • #RRGGBB;
  • #ARGB;
  • #AARRGGBB;

Также существуют предопределенные названия цветов. Такие ID доступны в пространстве имен android.R.соlor. Посмотреть цветовые значения цветов можно в документации http://developer.android.com/reference/android/R.color.html http://developer.android.com/reference/android/R.color.html

Обычно для цветовых ресурсов используют файл colors.xml в подкаталоге /res/values. Но можно использовать любое произвольное имя файла, или даже вставить их в файл вместе со строковыми ресурсами strings.xml. Android прочтет все файлы, а затем обработает их, присвоив им нужные ID.

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="red">#f00</color>
    <color name="yellow">#FFFF00</color>
    <color name="green">#FF00FF00</color>
</resources>
</code>

Для программного использования цветовых ресурсов можно использовать следующий код:

<code class="java">
int myRedColor = activity.getResourses.getColor(R.color.red); // получаем значение красного цвета

linearLayout.setBackgroundResource(R.color.yellow); // устанавливаем фон в желтый цвет
</code>

При использованиии в xml-файлах (например, файл разметки) используется следующий формат:

<code class="xml">
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/anytext"
	android:color="@color/red" />
</code>

Обратите внимание на использование префикса @ для того, чтобы ввести ссылку ресурса — текст после этого префикса — имя ресурса. В этом случае мы не должны были указывать пакет, потому что мы ссылаемся на ресурс в нашем собственном пакете. Для ссылки на системный ресурс мы должны записать: android:textColor="@android:color/black"

Ресурсы размеров

В Android используются следующие единицы измерения: пикселы, дюймы, точки. Все они могут входит в состав ХМL-шаблонов и кода Jаvа. Данные единицы измерения также можно использовать в качестве ресурсов при помощи тега <dimen> (обычно используют файл dimens.xml):

<code class="xml">
<resources> 
<dimen name="in_pixels">1px</dimen> 
<dimen name="in_dp">5dp</dimen> 
<dimen name="in_sp">100sp</dimen>
</resources> 
</code>

Список разрешенных единиц измерения можно прочитать в отдельной статье http://developer.alexanderklimov.ru/android/scales.php Android:: Единицы измерения

Метод Java использует в названии целое слово Dimension, а в коде и в XML используется сокращенная версия dimen

Вы должны иметь доступ к каждому экземпляру объекта Resources, чтобы найти значения его параметров. Это можно сделать, применив метод getResources к объекту activity. Когда у вас будет объект Resources, его можно запросить по id, чтобы узнать значение этого параметра.

<code class="java">
float dimen = activity.getResources().getDimension(R.dimen.in_pixels);
</code>

В XML-файлах используется следующий синтаксис

<code class="xml">
<TextView  
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
	android:textSize="@dimen/in_dp"/>
</code>

Ресурсы визуальных стилей и тем

Ресурсы со стилями позволяют поддерживать единство внешнего вида приложения. Чаше всего визуальные стили и темы используются для хранения цветовых значений и шрифтов. Обычно используют файл styles.xml.

Чтобы создать стиль, используйте тег <style>, включающий атрибут name, а также один или несколько вложенных узлов item. Каждый тег item в свою очередь также должен иметь атрибут name, содержащий тип описываемого значения (например, размер шрифта или цвет). Внутри тега должно находиться само значение.

<code class="xml">
<style name="StyleName">
    <item name="attributeName">value</item>
</style>
</code>

Тег <style> поддерживает наследование с помощью атрибута parent, поэтому вы можете свободно варьировать стили.

Программно доступ к ресурсам стилей осуществляется следующим образом:

<code class="java">
// текстовое поле с атрибутами, загружаемыми из ресурсов стиля
final TextView textStyle = (TextView)findViewById(R.id.text_style);
</code>


Ресурсы изображений

Android генерирует идентификаторы ресурсов для файлов изображений, расположенных в подкаталоге /res/drawable. Поддерживаются файлы PNG (самый предпочтительный), GIF, JPG. Для каждого файла изображения, который находится в этом каталоге, генерируется уникальный идентификатор на основе имени файла без расширения. Например, если у файла имя cat.jpg, то для него будет создан идентификатор ресурса R.drawable.cat. Нужно следить за уникальностью имен, так как если у вас будут два файла cat.jpg и cat.png, то возникнет ошибка. Кроме того, не нужно создавать дополнительных подкаталогов в папке /res/drawable, так как файлы оттуда не будут считываться.

Можно адаптировать картинки для разных разрешений и размеров экранов. Для этого нужно создать специальные папки и складывать там нужные картинки. Например, для различных разрешений экрана используются папки drawable-hdpi, drawable-mdpi, drawable-ldpi и пр.. Существует аналогичное деление для размеров экрана: drawable-normal, drawable-large и т.д.. Можно совмещать эти способы и создавать папки типа drawable-normal-hdpi. Для изображений, которые должны оставаться неизменными вне зависимости от разрешения экрана, следует создать папку drawable-nodpi.

Чтобы сослаться на изображение из /res/drawable в XML-файлах разметки, используйте следующий синтаксис:

<code class="xml">
<Button
    android:id="@+id/button1"
	...
	android:background="@drawable/cat"
</Button>
</code>

Обратите внимание, что в любом случае мы обращаемся к ресурсу как drawable, а не drawable-hdpi или как-то еще.

Программным способом можно достучаться до изображения следующим образом:

<code class="java">
// вызываем getDrawable для получения изображения
BitmapDrawable bd = activity.getResources().getDrawable(R.drawable.cat);

// Затем можно использовать полученый объект, чтобы установить фон
button.setBackgroundDrawable(bd);

// или можно установить фон непосредственно по идентификатору ресурса
button.setBackgroundResource(R.drawable.icon);
</code>


Ресурсы отрисовываемых цветов

Кроме обычных изображений в Android поддерживается и другой тип отрисовываемых ресурсов, которые называются отрисовываемыми цветами (color-drawable). По сути, это просто цветные прямоугольники.

Чтобы задать цветной прямоугольник, нужно указать тег <drawable> в имени узла XML-файла, находящегося в подкаталоге /res/values/.

<code class="xml">
<resources>
    <drawable name="black_rectangle">#000000</drawable>
	<drawable name="white_rectangle">#ffffff</drawable>
</resources>
</code>

В XML-шаблонах ресурсы используются следующим образом

<code class="xml">
<TextView
    android:layout_width="fill_parent"
	...
	android:background="@drawable/white_rectangle" />
</code>

Программным способом:

<code class="java">
// Получение отрисовываемого объекта
ColorDrawable whiteDrawable =
    (ColorDrawable)activity.getResources().getDrawable(R.drawable.white_rectangle);
	
// установление его в качестве фона для текстового вида
textView.setBackground(whiteDrawable);
</code>

Ресурсы фигур и градиентов

Также можно создавать ресурсы фигур на основе стандартных фигур вроде прямоугольника, эллипса, линии. Для использования ресурсов фигур нужно создать в подкаталоге /res/drawable XML-файл, в котором будет присутствовать тег <shape>, который в свою очередь можете содержать дочерние элементы <corners>, <gradient>, <padding>, <size>, <solid>, <stroke>.

Имя файла без расширения будет служить идентификатором (ID): R.drawable.filename в Java-коде и @[package:]drawable/filename в XML-файлах.

Примеры с shape.php фигурами и градиентами приведены в отдельной статье.


State List

У некоторых элементов управления есть некоторые состояния: нажато, выбрано и т.д.. В Android есть возможность задавать изображения для любого из таких состояний.

Доступны следующие состояния:

  • state_focused
  • state_window_focused
  • state_enabled
  • state_checkable
  • state_checked
  • state_selected
  • state_active
  • state_pressed

Для списков есть также:

  • state_single
  • state_first
  • state_middle
  • state_last


Сделать это просто. Добавляем в ресурсы изображения нормального (button_up.png) и нажатого (button_down.png) состояний кнопки. И создаем в папке drawables XML-файл со следующим содержанием (states_button.xml):

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true" android:drawable="@drawable/button_down" />
    <item android:drawable="@drawable/button_up" />
</selector>
</code>

Важный момент: в списке состояний нужно сначала указывать специализированные состояния, а последним должно следовать состояние по умолчанию (без атрибутов state-* вообще).

Теперь осталось у атрибута background для кнопки прописать созданный ресурс.

<code class="xml">
<Button android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:background="@drawable/states_button"
        android:text="Custom button"
        android:textSize="18dip"
    />
</code>

Можно обойтись без использования изображений для кнопки, а воспользоваться фигурами (states_shapes.xml).

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true">
        <shape>
            <gradient android:type="linear" android:endColor="#6699CC" android:startColor="#99CCFF" android:angle="90.0" />
            <corners android:radius="5.0dip" />
            <padding android:left="20dip" android:right="20dip" android:top="7dip" android:bottom="7dip"/>
        </shape>
    </item>
    <item>
        <shape>
            <gradient android:type="linear" android:endColor="#336699" android:startColor="#99CCFF" android:angle="90.0" />
            <corners android:radius="5.0dip" />
            <padding android:left="20dip" android:right="20dip" android:top="7dip" android:bottom="7dip"/>
        </shape>
    </item>
</selector>
</code>


RadioBox, CheckBox и др.

Похожим образом можно задавать стили для RadioButtom, CheckBox и т.п.. Но тут мало того, что можно отдельным ресурсом задавать фон, так отдельным же ресурсом можно задавать саму пиктограмму через атрибут button (states_compound.xml).

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_checked="true">
      <shape android:shape="oval">
          <gradient android:startColor="#00FF00" android:endColor="#00000000" android:type="radial" android:gradientRadius="7"/>
          <size android:width="10dip" android:height="10dip" />
      </shape>
    </item>
    
    <item>
      <shape android:shape="oval">
          <gradient android:startColor="#FF0000" android:endColor="#00000000" android:type="radial" android:gradientRadius="7"/>
          <size android:width="10dip" android:height="10dip" />
       </shape>
    </item>
</selector>
</code>

Разметка с созданными стилями

<code class="xml">
<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
    android:button="@drawable/states_compound"
    android:text="Item 1"
    android:paddingLeft="20dip"
/>
<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
    android:button="@drawable/states_compound"
    android:checked="true"
    android:text="Item 2"
    android:paddingLeft="20dip"
/>
<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
    android:button="@drawable/states_compound"
    android:text="Item 3"
    android:paddingLeft="20dip"
/>
</code>


Программно к ресурсам можно обращаться так:

<code class="java">
Resources res = getResources();
Drawable shape = res. getDrawable(R.drawable.gradient_box);

TextView tv = (TextView)findViewByID(R.id.textview);
tv.setBackground(shape);
</code>

При написании статьи о drawable-ресурсах использовались материалы с http://megadarja.blogspot.com/2011/03/android-xml-drawables.html Android XML Drawables.

Ресурсы анимации

Android поддерживает два типа анимации. Первый тип основан на расчете промежуточных кадров и может использоваться для поворота, перемещения, растягивания, затемнения элементов. Второй тип - пошаговая анимация, т.е. последовательный вывод заранее подготовленных изображений.

При использовании анимации промежуточных кадров каждый экземпляр анимации хранится в отдельном XML-файле внутри каталога res/anim. Имена файлов без расширения являются идентификаторами для ресурсов.

Анимацию можно задать в виде изменений параметров alpha (затемнение), scale (масштабирование), translate (перемещение) или rotate (вращение).

Вы можете комбинировать различные экземпляры анимации, используя тег set с атрибутами:

  • duration - продолжительность анимации в секундах
  • startOffset - миллисекундная задержка перед началом анимации
  • fillBefore - при значении true преобразование происходит перед началом анимации
  • fillAfter - при значении true преобразование происходит после завершения анимации
  • interpolator - описывает изменения в скорости эффекта

Если не использовать атрибут startOffset, все анимационные эффекты внутри набора происходят одновременно.

Пошаговая анимация подразумевает создание последовательности объектов Drawable? каждый из которых будет отображаться в качестве фона на протяжении указанного промежутка времени. Пошаговая анимация хранится в виде ресурсов Drawable в каталоге res/drawable (см. выше). Имена файлов без расширения используются в качестве идентификаторов.


Ресурсы массивов

Существует еще один тип ресурсов для хранения значений массивов. Принято хранить данные ресурсы в файле arrays.xml папки /res/values. Вот как может выглядеть файл:

<code class="xml">
<?xml version="1.0" encoding="utf-8"?>
<resources>

    <array name="choose">
        <item>@string/red_pill_label</item>
        <item>@string/blue_pill_label</item>
    </array>

    <string-array name="catnames">
        <item>Рыжик</item>
        <item>Барсик</item>
        <item>Мурзик</item>
    </string-array>

    <integer-array name="years">
        <item>2009</item>
        <item>2010</item>
        <item>2011</item>
    </integer-array>

</resources>
</code>

Как видите, есть типы ресурсов array, string-array, integer-array.

Программно получить доступ к ресурсам массива можно так:

<code class="java">
// загрузка массива строк из res/values/arrays.xml в текстовое поле textStrings
String[] names = getResources().getStringArray(R.array.names);
for(int i = 0; i < names.length; i++) {
    textStrings.append("Name[" + i + "]: "+ names[i] + "\n");
} 

// загрузка массива целых чисел из res/values/arrays.xml в текстовое поле textDigits
int[] digits = getResources().getIntArray(R.array.digits);
for(int i = 0; i < digits.length; i++) {
    textDigits.append("Digit[" + i + "]: "+ digits[i] + "\n");
} 
</code>


Скомпилированные и нескомпилированные ресурсы Android

Большинство ресурсов компилируются в двоичные файлы, но некоторые используются без дополнительной обработки. В Android поддержка ресурсов осуществляется преимущественно при помощи файлов двух типов - XML и RAW-файлов (к последним относятся изображения, аудио и видео). При работе с ХМL-файлами мы видели, что в большинстве случаев ресурсы определяются как значения внутри файла XML (это касается, например, строк), а иногда весь ХМL-файл является ресурсом (например, файл ресурса разметки).

Файлы, созданные в XML, также подразделяются на два типа: первые компилируются в двоичный формат, а вторые копируются на устройство без изменений. Например, XML-файлы строковых ресурсов и ресурсов разметки компилируются в двоичный формат. Эти ХМL-файлы имеют заданный формат, в котором узлы XML преобразуются в ID.


XML-документы

Вы также можете специально выбрать некоторые ХМL-файлы и задать для них структуру формата, отличающуюся от принятой по умолчанию, - чтобы эти файлы не интерпретировались и для них не генерировались идентификаторы ресурсов. Однако в данном случае нам как раз нужно, чтобы они компилировались в двоичный формат и чтобы их было удобно локализовывать. Для достижения этой цели файлы XML можно поместить в подкаталог /res/xml - тогда они будуr скомпилированы в двоичный формат. В таком случае вы можете воспользоваться поставляемыми вместе с Android инструментами для считывания XML, которые могут считывать ХМL-узлы.

Ниже приведен пример ХМL-файла в подкаталоге /res/xml/test.xml:

<code class="xml">
<rootelement> 
    <subelement> 
        Коты - наше всё!
    </subelement> 
</rootelement>
</code>

Как и при работе с другими ХМL-файлами ресурсов, ААРТ компилирует такой ХМL-файл, перед тем как поместить его в пакет прикладных программ. Для синтаксического разбора подобных файлов используйте экземпляр XmlPullParser:

<code class="java"> 
Resources  res  =  activity.getResources();
XmlResourceParser хрр  =  res.getXml(R.xml.test);
</code>

Возвращенный XmlResourceParser является экземпляром XmlPullParser, а также реализует java.util.AttributeSet.

Пример работы с XML-документами описан в статье xmldoc.php Работаем с XML-документами

Использование необработанных ресурсов RAW

Но, если разместить файлы, в том числе написанные на XML, в каталоге /res/raw, они не будут скомпилированы в двоичном формате, а попадает в пакет прикладных программ как есть. Для считывания таких фалов нужно использовать явные API с поддержкой потоков. К категории raw относятся аудио- и видеофайлы.

Каждый такой файл, помещенный в папку /res/raw, имеет свой идентификатор, генерируемый в R.java. Если бы вы поместили текстовый файл в /res/raw/test.txt, то можно было бы прочитать при помощи следующего кода, используя идентификатор test:

<code class="java">
String  getStringFromRawFile(Activity  activity) 
{ 
    Resources r = activity.getResources();
    InputStream is = r.openRawResource(R.raw.test);
    String myText = convertStreamToString(is); 
    is.close();
    return  myText;
}

String  convertStreamToString(InputStream is);
{ 
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    int i = is.read();
    while( i != -1) 
    { 
        baos.write(i); 
        i = baos.read(); 
    } 
    return  baos.toString();
}
</code>

Мы уже рассматривали structure_app.php структуру папок в каталоге res. Компилятор ресурсов, входящий в состав инструмента Android Asset Packaging Tool (ААРТ), собирает все ресурсы, кроме raw, и помещает все их в итоговый файл АРК. Этот файл, содержащий код и ресурсы приложения Android, аналогичен файлу JAR, который применяется в Java (АРК означает Android package - пакет Android). Именно файл АРК устанавливается на устройство.

Хотя инструмент синтаксического разбора (parser) ресурсов XML допускает такие имена ресурсов, как hello-string, в файле R.java во время компиляции такое название вызовет ошибку. Для ее устранения можно переименовать ресурс в hello_string, заменив дефис нижним подчеркиванием.

Имена файлов, в которых дублируются базовые имена, вызывают в плагине Eclipse·ADT ошибку компиляции (build error). Так происходит со всеми идентификаторами ресурсов, которые сгенерированы для ресурсов, созданных на основе файлов.

Использование ресурсов в коде программы

Подведем воедино информацию об использовании ресурсов в коде программы.

Во время компиляции генерируется статический класс R на основе ваших ресурсов и содержит идентификаторы всех ресурсов в программе. Класс R имеет несколько вложенных классов, один для каждого типа ресурса, поддерживаемого системой Android, и для которого в проекте существует файл ресурса. Класс R может содержать следующие вложенные классы:

  • R.anim — идентификаторы для файлов из каталога res/anim/ (анимация);
  • R.array — идентификаторы для файлов из каталога res/values/ (массивы);
  • R.bool — идентификаторы для битовых массивов в файлах arrays.xml из каталога res/values/;
  • R.integer — идентификаторы для целочисленных массивов в файлах arrays.xml из каталога res/values/;
  • R.color — идентификаторы для файлов colors.xml из каталога res/values/ (цвета);
  • R.dimen — идентификаторы для файлов dimens.xml из каталога res/values/ (размеры);
  • R.drawable — идентификаторы для файлов из каталога res/drawable/ (изображения);
  • R.id — идентификаторы представлений и групп представлений для файлов ХМL-разметки из каталога res/layout/;
  • R.layout — идентификаторы для файлов разметки из каталога res/layout/;
  • R.raw — идентификаторы для файлов из каталога res/raw/;
  • R.string — идентификаторы для файлов strings.xml из каталога res/values/ (строки);
  • R.style — идентификаторы для файлов styles.xml из каталога res/values/ (стили);
  • R.xml — идентификаторы для файлов из каталога res/xml/.

Синтаксис для обращения к ресурсу:

R.resource_type.resource_name 

При использовании системных ресурсов используется класс android.R.

<code class="java"> 
android.R.drawable.sym_def_app_icon; // стандартный значок приложения
android.R.style.Theme_Black;  // загрузить стандартный стиль: 
</code>

Если в коде вам понадобится идентификатор ресурса для конструктора или метода, то можете использовать данные свойства:

<code class="java">
setContentView(R.layout.main); // загрузка ресурса разметки

// Строковый ресурс используется при выводе Toast-сообщения
Toast.makeText(this, R.string.mytext, Toast.LENGTH_LONG).show();
</code>

Если вам нужен не идентификатор, а сам экземпляр ресурса, то используйте метод getResources для доступа к экземпляру класса Resources:

<code class="java">
Resources myResources = getResources();
</code>

Принцип работы класса Resources заключается в передаче идентификатора ресурса, чей экземпляр вам нужен для работы. Вот несколько примеров получения экземпляров ресурсов:

<code class="java">
Resources myResources = getResources();

CharSequence myText = myResources.getText(R.string.hello_app); // получим строку
Drawable myIcon = myResources.getDrawable(R.drawable.app_icon); // получим значок
int myColor = myResources.getColor(R.color.color_blue); // получим значение цвета
float myWidth = myResources.getDimension(R.dimen.width_border); // получим размер

// Получим массив строк
String[] stringArray;
stringArray = myResources.getStringArray(R.array.string_array);

// Ресурс, содержащий пошаговую анимацию, возвращается в виде объекта AnimationResources
// Также можно вернуть значение с помощью метода getDrawable и привести к нужному типу
AnimationDrawable cat;
cat = (AnimationDrawable)myResources.getDrawable(R.drawable.frame_cat);
</code>

Вложенные ресурсы

Можно использовать ссылки на ресурсы в качестве значений для атрибутов внутри других ресурсов (разметка, стили), что позволяет создавать специальные варианты визуальных тем, локализованных строк и графических объектов. Чтобы сослаться на один ресурс внутри другого, используйте символ @ в следующем виде:

<code class="java">
attribute = "@[packagename:]resourcetype/resourceID"
</code>

Полное имя packagename нужно указывать только при использовании сторонних пакетов, при использовании собственных ресурсов данный параметр можно опустить, так как Android предполагает, что вы используете ресурсы пакета со своим приложением.

<code class="xml">
...
android:text="@string/hello_app"
android:textColor="@color/color_blue"
...
</code>

Использование системных ресурсов

Сама система имеет собственные ресурсы (строки, изображения, анимация, разметки, стили), которые используются стандартными приложениями, входящими в состав Android. Вы также можете использовать данные системные ресурсы в своих приложениях, добиваясь единообразного стиля и дизайна.

Получение доступа к системным ресурсам внутри кода программы ничем не отличается от приведенных выше примеров. Единственно, в чем состоит отличие, это использование не вашего класса R, а системного класса android.R. Например, для получения строки, которая хранит сообщение об ошибке, используется следующий код:

<code class="java">
CharSequence errorMessage = getString(android.R.string.httpErrorBadUrl);
</code>

Чтобы получить доступ к системным ресурсам внутри XML-файла, используйте значение android следующим образом:

<code class="xml">
...
android:text="@android:string/httpErrorBadUrl"
android:textColor="@android:color/darker_gray"
...
</code>

Использование ссылок на визуальные стили в текущей теме

Использование визуальных тем позволяет обеспечить целостность пользовательского интерфейса приложения. Вместо описания каждого стиля, вы можете использовать ссылки, предоставляемые Android, с помощью которых вы можете использовать стили из текущей темы.

Чтобы задать ссылку на ресурс, который нужно применить, вместо символа @ укажите префикс ?android:. Например, предыдущий пример можно переделать следующим образом:

<code class="xml">
android:textColor="?android:textColor"
</code>

Такой подход позволяет создавать визуальные стили, которые смогут меняться по мере преобразований в текущей теме, и избавляет от необходимости редактировать каждый отдельный ресурс.

Создание ресурсов для локализации и аппаратных конфигураций

Применение ресурсов позволяет использовать механизм динамического выбора нужного ресурса в программе. Можно задать определенную структуру каталогов в проекте, чтобы создавать ресурсы для конкретных языков, регионов и аппаратных конфигураций. Во время выполнения программы Android выберет нужные значения для конкретного телефона пользователя.

Вы можете указывать альтернативные значения, создавая собственные структуры каталогов внутри каталога res при помощи дефиса (-). Например, мы хотим создать дополнительные строковые ресурсы для французского языка, франкоканадского региона и для русского языка. Тогда структура каталогов в проекте будет выглядять следующим образом:

Project/
    res/
	    values/
		    strings.xml
		values-fr/
		    strings.xml
		values-fr-rCA
		    strings.xml
		values-ru/
		    strings.xml

Как видите, мы создали несколько файлов strings.xml, которые содержат текст на французском и русском языках и раскидали их по нужным каталогам. Далее приводится список возможных идентификаторов, которые можно использовать для создания альтернативных значений в ресурсах.

Регионы и язык можно указывать без всякой связи друг с другом. Так в папке values-ru-rJP будут храниться русские тексты для жителей Японии.

  • Мобильный код страны и код мобильного оператора (MCC/MNC) - содержит информацию о стране и опционально о мобильной сети, которая привязана к SIM-карте. MCC (Mobile Country Code) состоит из символов mcc, за которыми следует трехзначный код страны. Также можно добавить MNC (Mobile Network Code), используя символы mnc и двухзначный код мобильной сети, например, mcc250-mnc99 (Россия-Билайн). Список кодов MCC/MNC можно посмотреть в Википедии.
  • Язык и регион - указывает на язык при помощи языкового кода в формате ISO 639-1. Состоит из двух символов в нижнем регистре. В случае необходимости можно добавить обозначение региона в виде символа r и двухсимвольного кода в формате ISO 3166-1-alpha-2, записанного в верхнем регистре, например, en-rUS, en-rGB, fr-rCA.
  • Размер экрана - может иметь одно из следующих значений: small (меньше, чем HVGA), medium (HVGA или меньше, чем HVGA), large (VGA или больше).
  • Высота и ширина экрана - можно использовать значения long или notlong, если необходимо создать ресурсы, предназначенные для широкоформатных экранов (long для WVGA, notlong для QVGA).
  • Ориентация экрана - возможны значения port (Портретный), land (Альбомный), square (Квадратные экраны).
  • Плотность пикселов на экране - возможны значения ldpi (120 dpi), mdpi (160 dpi), hdpi (240). Вы можете использовать значение nodpi для растровых ресурсов, которые не должны масштабироваться. В этом случае система не требует точного совпадения. Подбирая подходящий каталог, Android выберет тот спецификатор, который наиболее точно описывает плотность пикселов экрана устройства и откорректирует масштаб объекта Drawable. По умолчанию, в проекте все создаются папки drawable-ldpi, drawable-mdpi, drawable-hdpi, в которых содержатся значки для приложения.
  • Тип сенсорного экрана - возможны варианты: notouch, stylus, finger.</li>
  • <b>Наличие клавиатуры - возможны варианты: keysexposed, keyshidden, keysoft.
  • Тип ввода - возможны варианты: nokeys, qwerty, 12key.
  • Способ навигации - возможны варианты: nonav, dpad, trackball, wheel.

Вы можете комбинировать указанные спецификаторы, разделяя их дефисами. Поддерживаются любые сочетания, однако они должны идти в том порядке, как указано в списке, т.е. язык всегда указывается раньше ориентации экрана и т.п. В одном спецификаторе может применяться не более одного значения.

Корректные варианты

drawable-en-rUS
drawable-en-keyshidden
drawable-long-land-notouch-nokeys

Некорректные варианты

drawable-rUS-en (нарушен порядок)
drawable-nonav-dpad (несколько значениф для одного спецификатора)

Если на устройстве не будет обнаружено соответствующих ресурсов, при попытке получения доступа к ним ваша программа сгенерирует исключение. Чтобы избежать подобной ситуации, необходимо всегда добавлять значения по умолчанию для всех типов ресурсов в каталог без спецификаторов.

Пример с локализацией программы можно посмотреть в статье http://developer.alexanderklimov.ru/android/locale.php Локализация приложений.

Личные инструменты

Разработка веб-сайтов, автоматизация.
По всем вопросам обращайтесь по телефонам:

+7 495 640 29 90
http://artofweb.ru