Как создать xml файл android studio

Обновлено: 07.07.2024

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

Уровень сложности: средний

  • Начало работы
  • XML в Android
  • Парсеры XML
  • Приложение для чтения новостей для Android
  • Использование SAX
  • Упрощение использования SAX в Android
  • Использование DOM
  • Принимающий парсер XML
  • Создание документов XML
  • Заключение
  • Загрузка
  • Ресурсы
  • Об авторе

Прочитав эту статью, вы узнаете о создании Android-приложений, способных работать с XML в Интернете. Программы для Android пишутся на Java™, поэтому для понимания материала необходим опыт использования этого языка программирования. Кроме того, вам понадобится инструментарий разработки программного обеспечения для Android (SDK). Все примеры кода, приведенные в этой статье, могут работать с любой версией Android, хотя для их создания использовался SDK 1.5_pre. В принципе приложения для Android можно создавать, имея под рукой только SDK и текстовый редактор, но гораздо проще использовать специальный модуль ADT, подключаемый к Eclipse (Android Developer Tools - инструментарий Android-разработчика). В этой статье используется ADT 0.9 и Eclipse 3.4.2 Java Edition (ссылки на все программы приведены в разделе Ресурсы).

Android представляет собой платформу с открытым кодом для разработки приложений для мобильных устройств. С ее помощью можно получить доступ ко всем компонентам устройства, на котором выполняется эта ОС, начиная от низкоуровневого программирования графики и заканчивая использованием встроенной камеры. В Android есть столько всего интересного, что логично задать вопрос: а зачем вообще задумываться об XML? Однако интерес представляет не столько сам XML, сколько взаимодействие с другими объектами с его помощью. В частности, XML является распространенным форматом для обмена информацией в Интернете, поэтому велика вероятность, что он понадобится вам для доступа к данным в Web. Кроме того, XML может потребоваться для передачи данных, например, Web-сервису. Другими словами, если вы хотите, чтобы ваше приложение для Android работало через Интернет, вам скорее всего придется иметь дело с XML. К счастью, существует множество вариантов работы с XML в Android.

Часто встречающиеся аббревиатуры

  • API: Application programming interface (Интерфейс прикладного программирования)
  • RSS: Real Simple Syndication (Действительно простая синдикация)
  • SDK: Software Developers Kit (пакет разработчика программного обеспечения)
  • UI: пользовательский интерфейс
  • URL: универсальный локатор ресурса
  • XML: расширяемый язык разметки

Одной из наиболее привлекательных черт платформы Android является использование языка программирования Java. SDK Android поддерживает не всю, но достаточно большую часть возможностей стандартной среды выполнения Java (Java Runtime Environment – JRE). Cама платформа Java уже долгое время поддерживает множество различных способов использования XML, причем большинство API для Java, ориентированных на XML, доступны в Android. Примерами таких API могут служить объектная модель документов (Document Object Model — DOM) и простой Java API для XML (Java's Simple API for XML – SAX), которые уже много лет являются частью технологии Java. Обратным примером является более новый потоковый API ( Streaming API for XML – StAX), который не поддерживается в Android (при этом в состав Android входит эквивалентная по своим возможностям библиотека). В Android также недоступен API для связывания с данными XML (Java XML Binding — JAXB). Его безусловно можно реализовать для данной платформы, однако он отличается некоторой тяжеловесностью, которая проявляется в том, что множество экземпляров разных классов часто требуется для представления документов XML. В связи с этим он является менее предпочтительным при создании приложений для портативных устройств, подобных тем, на которых работает Android. Далее мы рассмотрим в качестве примера простой источник XML-данных в Интернете, а также способы их разбора внутри Android-приложения при помощи перечисленных выше API. Мы начнем с рассмотрения основных компонентов простого приложения, работающего с XML-данными, полученными через Интернет.

Ниже будет рассмотрено приложение, получающее информационную ленту RSS с сайта Androidster, популярного среди Android-разработчиков, и трансформирующее ее в набор простых Java-объектов. Этот набор далее будет выступать в качестве содержимого компонента ListView (ссылка на исходный код приведена в разделе Загрузка). Приложение следует классическим принципам полиморфизма: его поведение будет оставаться внешне одинаковым при использовании различных алгоритмов разбора XML. Данная модель легко представима в Java, как показано в листинге 1.

Листинг 1. Интерфейс парсера XML-лент

В листинге 2 показан класс

Листинг 2. POJO-класс

). Этот класс является классическим примером объекта-значения, обладающего собственной реализацией методов

на основе текущего состояния. Он также реализует интерфейс

, служащий для сортировки (на практике этот метод не нужен, поскольку записи в ленте всегда упорядочены).

Листинг 3. Базовый класс парсеров лент

Этот базовый класс хранит URL ленты в переменной

и использует его для открытия потока ввода (

). В случае возникновения любых ошибок он просто генерирует исключение типа

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

Листинг 4. Пример ленты XML

Как видно из примера в листинге 4, каждый элемент

соответствует экземпляру класса

. При этом дочерние элементы записи (

и т. д.) соответствуют свойствам

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

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

, основанная на SAX, показана в листинге 5.

Листинг 5. Реализация парсера на основе SAX

Этот фрагмент кода должен выглядеть привычно для тех, у кого уже есть опыт использования SAX. Большая часть кода заключена в обработчике, что характерно для любого SAX-парсера. Обработчик получает уведомления о событиях от парсера по мере того, как тот разбирает документ XML. В данном случае в роли такого обработчика выступает класс

Листинг 6. Обработчик событий SAX

является наследником класса

, который предоставляет пустую реализацию по умолчанию для обработчиков всех событий, генерируемых SAX-парсером. Благодаря этому базовому классу дочерние классы могут переопределять только методы, которые соответствуют интересующим их событиям.

реализует еще один API, состоящий из метода

. Этот метод возвращает список объектов типа

, составляемый в процессе обработки событий, полученных от SAX-парсера. Кроме того, класс включает две внутренние переменные:

, в которой хранится текстовое содержимое текстовых вершин. Обе эти переменные инициализируются в методе

, который вызывается при начале разбора документа парсером.

Обратите внимание на метод

в листинге 6. Он вызывается каждый раз, когда парсер встречает открывающий тег в документе XML. В нашем случае значение имеют только теги

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

. Далее рассмотрим метод

. Он вызывается при разборе содержимого текстовых вершин в XML, которое просто добавляется в переменную

. Наконец, взгляните на метод

, устанавливается значение соответствующего свойства объекта, хранящегося в переменной

. При этом значение берется из переменной

. Если же закрывающим тегом является

SDK Android включает вспомогательный класс

. Его использование в парсере SAX показано в листинге 7.

Листинг 7. Реализация SAX-парсера в Android

Обратите внимание, что этот класс по-прежнему способен работать с любыми обработчиками SAX, поэтому в нем используется ранее созданный

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

в листинге 6 и обратите внимание на проверку переменной

на null перед установкой значения свойств. Теперь вернитесь к фрагменту XML, приведенному в листинге 4. Как видите, он включает элементы

, находящиеся вне элемента

. Именно этим объясняется проверка на null, поскольку иначе обработка первого же элемента

приведет к исключению типа

. К счастью, Android включает свой собственный вариант API SAX, благодаря которому можно не писать собственные обработчики. Пример приведен в листинге 8.

Листинг 8. Упрощенная реализация SAX-парсера для приложения Android

Как и было обещано, в этом фрагменте кода не используются классы-обработчики SAX. Вместо этого парсер использует классы из пакета android.sax, входящего в состав SDK. Эти классы помогают моделировать структуру документов XML и добавлять слушатели событий по мере необходимости. В приведенном выше примере декларируется, что документ XML имеет корневую вершину

, у которой есть дочерняя вершина

. Внутри нее располагаются элементы

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

). Обратите внимание, что в этом подходе не приходится отдельно хранить текстовое содержимое, что не только проще, но и эффективнее. При этом обработчик, который передается в вспомогательный метод Xml.parse, автоматически определяется корневым элементом документа.

Подход, продемонстрированный в листинге 8, не является обязательным. Если вас устраивает стандартный способ работы с SAX в Java, вы можете использовать его. В противном случае вы можете работать с SAX через вспомогательные классы, предоставляемые SDK Android. Однако что делать, если вы вообще не хотите использовать SAX? В этом случае есть еще несколько вариантов, одним из которых является DOM.

Разбор документов XML по принципам DOM полностью поддерживается в Android. Этот API работает точно так же, как в Java-приложениях для серверов и настольных компьютеров. Реализация интерфейса парсера лент RSS на основе DOM показана в листинге 9.

Листинг 9. Реализация парсера XML-лент на основе DOM

Как и в случае c SAX, в данном коде нет ничего специфичного для платформы Android. Парсер DOM считывает содержимое всего документа в память и предоставляет методы API для обхода дерева XML, позволяющие находить нужную информацию. Этот подход весьма очевиден и в некотором смысле проще реализаций, основанных на SAX. Однако использование DOM, как правило, требует больше памяти, поскольку в нее считываются все узлы XML. Это может представлять собой реальную проблему для портативных устройств под управлением Android, за исключением случаев разбора заведомо небольших документов XML. Учитывая это, нетрудно было предположить, что SAX должен быть значительно популярнее среди разработчиков Android-приложений, поэтому именно для него были созданы вспомогательные классы. Кроме SAX и DOM, платформа поддерживает и третий тип парсеров, а именно принимающие парсеры (pull parsers).

Как было замечено выше, Android не поддерживает API StAX. Однако в состав Android входит принимающий парсер, работающий аналогично StAX. Он позволяет вашему приложению принимать события от парсера в отличие от SAX-парсеров, которые автоматически передают события обработчику. Реализация принимающего парсера для анализа лент RSS показана в листинге 10.

Листинг 10. Реализация принимающего парсера

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

). События имеют числовые идентификаторы (коды), поэтому для их выбора можно использовать оператор case-switch. Следует отметить, что вместо отслеживания закрывающих тегов, как в SAX, в случае принимающего парсера проще обрабатывать содержимое элемента при обнаружении открывающего тега. В листинге 10 приведен пример вызова метода

при обработке начала элемента для получения его текстового содержимого. Это существенно упрощает разбор документов по сравнению с SAX. Кроме того, обратите внимание на установку булева флага

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

До этого момента мы рассматривали варианта разбора документов XML, полученных из Интернета. Однако существуют ситуации, в которых вашему приложению необходимо отправлять данные в формате XML удаленному серверу. Разумеется, вы можете просто создавать текстовое представление XML при помощи

или аналогичного класса. В качестве альтернативного решения можно воспользоваться принимающим парсером, как показано в листинге 11.

Листинг 11. Формирование документа XML при помощи принимающего парсера

находится в том же пакете, что и

, использовавшийся в предыдущем разделе. Однако вместо того, чтобы запрашивать события, он помещает их в поток или передает классу-писателю (в примере выше таковым является

). Парсер предоставляет простой API, содержащий методы начала и завершения документа, создания элементов, а также формирования текстового содержимого элементов и атрибутов. Этот подход обладает существенным преимуществом по сравнению со

: с его помощью легче гарантировать синтаксическую корректность документа XML.

Вне зависимости от того, какое приложение вы создаете для Android, если ему требуется принимать или отправлять данные через Интернет, оно скорее всего должно будет уметь работать с XML. Как было продемонстрировано в этой статье, Android поддерживает множество технологий для обработки документов XML, поэтому вы можете делать свой выбор как на основе личных предпочтений, так и основываясь на конкретной ситуации. В большинстве случаев можно смело выбирать SAX и использовать этот API либо традиционным образом, либо через тонкий вспомогательный класс. Если вы работаете с небольшими документами XML, то, возможно, проще использовать DOM. В противном случае, а также если требуется обработать лишь часть документа, использование принимающего парсера XML может быть выгоднее из соображений производительности. Кроме того, принимающий парсер предоставляет удобные возможности для создания и редактирования документов. Таким образом, каковы бы ни были потребности вашего приложения в отношении работы с XML, вы всегда сможете найти нужную технологию в SDK Android.

  • Оригинал статьи: "Working with XML on Android" (Michael Galpin, developerWorks, июнь 2009 г.). (EN)
  • Прочитайте руководство "Создания приложений для Android при помощи Eclipse" (Фрэнк Эблсон, Frank Ableson,developerWorks, февраль 2008 г.), в котором подробно рассказывается о наиболее простом способе разработки для Android - среде Eclipse. (EN)
  • Ознакомьтесь со статьей "Использование интегрированных пакетов: Codehaus' Woodstox" (Майкл Галпин, developerWorks, июль 2007 г.), в которой приводится сравнение SAX, DOM и принимающих парсеров. (EN)
  • Обратитесь к статье "Разбор XML при помощи StAX, часть 2: принимающие парсеры и события" (Петер Нерер, Peter Nehrer, developerWorks, декабрь 2006 г.), детально рассматривающей принципы работы принимающих парсеров. (EN)
  • Станьте экспертом по вопросам SAX, прочитав руководство "Принципы работы SAX" (Николас Чейз, Nicholas Chase, developerWorks, июль 2003 г.). (EN)
  • Узнайте больше о разборе XML при помощи DOM из руководства "Принципы работы DOM" (Николас Чейз, developerWorks, март 2007 г.). (EN)
  • Обратитесь к документации по SDK Android за информацией об использовании этого пакета для разработки и отладки приложений, а также проектирования пользовательского интерфейса. (EN)
  • Прочитайте о спонсорах Android – альянсе Open Handset, состоящем из 47 технологических компаний, работающих над решениями в области мобильных устройств. (EN)
  • Сертификация по XML корпорации IBM: узнайте, как стать сертифицированным разработчиком IBM в области XML и связанных с ним технологий. (EN)
  • Технические мероприятия и Web-трансляции developerWorks: в этих разделах можно получить самую актуальную информацию о современных технологиях. (EN)
  • Слушайте интервью и обсуждения вопросов, интересующих разработчиков программного обеспечения, в трансляциях developerWorks. (EN)

Получить продукты и технологии

  • Примите участие в обсуждении материала на форуме developerWorks.
  • Читайте блоги developerWorks и становитесь членами нашего сообщества. (EN)

Майкл Галпин (Michael Galpin) имеет учёную степень по математике в Калифорнийском Технологическом институте. Он является Java-разработчиком с конца 90-х гг. и работает инженером по программному обеспечению в Vitria Technology, в Саннивейл, Калифорния.

На прошлом уроке мы выяснили, что Activity читает layout-файл и отображает то, что в нем сконфигурировано. Теперь выясним, откуда Activity знает, какой именно layout-файл читать.

Урок был обновлен 02.02.2015

Создадим приложение для этого урока. Для этого необходимо создать модуль в проекте Android lessons. Этот проект мы создали в прошлых уроках. Если вы еще не запомнили, как создавать модули, то можно просмотреть еще раз Уроки 3 и 4.

И давайте сразу разберем один момент. Последующие уроки были написаны давно, и написаны они были под среду разработки Eclipse. Соответственно, все уроки содержат информацию для создания проекта в Eclipse.

Но Eclipse отличается от Android Studio организацией проектов/модулей. И сейчас мы разберемся, как информацию по созданию проекта в Eclipse использовать при создании модулей в Android Studio.

Инфа для создания проекта в Eclipse выглядит так:

Project name: P0051_LayoutFiles
Build Target: Android 2.2
Application name: LayoutFiles
Package name: ru.startandroid.develop.LayoutFiles
Create Activity: MainActivity

Обычно, подобный текст есть в начале каждого урока.

А для создания модуля в Android Studio нам нужна информация в таком виде

Application/Library name: LayoutFiles
Module name: p0051layoutfiles
Package name: ru.startandroid.p0051layoutfiles

Как получить из старого новое? Рассмотрим на примере этого урока. Будем брать значения для Eclipse и подставлять их в Android Studio.

Для поля Application/Library name берете значение Application name, без каких-либо изменений. Т.е. LayoutFiles.

Для Module name можно брать значение Project name, но заглавные буквы надо сделать маленькими, а нижнее подчеркивание удалить. Т.е. из P0051_LayoutFiles получаем p0051layoutfiles.

Package name – это ru.startandroid. плюc только что полученный Module name, т.е. ru.startandroid.p0051layoutfiles

Используйте эту схему во всех последующих уроках для создания модулей.


Также, в информации для Eclipse есть поле Create Activity. Его будем использовать при создании модуля, когда указываем имя Activity, в поле Activity Name


Сюда надо подставить значение из Create Activity. Обычно это всегда MainActivity.

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

Возвращаемся к уроку.

При разработке, каждому Activity сопоставляется одноименный java-класс (наследник класса android.app.Activity). При запуске приложения, когда система должна показать Activity и в дальнейшем работать с ним, она будет вызывать методы этого класса. И от того, что мы в этих методах накодим, зависит поведение Activity.

При создании модуля мы указывали, что надо создать Activity с именем MainActivity


Мы попросили создать Activity, и среда разработки создала нам соответствующий класс (в дальнейшем мы научимся их создавать самостоятельно).

Давайте посмотрим этот класс: откроем двойным кликом файл: java\ru\startandroid\p0051layoutfiles\MainActivity.java


Смотрим java-код. Нас интересует метод onCreate – он вызывается, когда приложение создает и отображает Activity (на остальные методы пока не обращаем внимания). Посмотрим код реализации onCreate.

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

Нас сейчас очень интересует следующая строка:

Метод setContentView(int) – устанавливает содержимое Activity из layout-файла. Но в качестве аргумента мы указываем не путь к layout-файлу (res/layout/activity_main.xml), а константу, которая является ID файла. Эта константа генерируется автоматически в файле R.java, который мы пока трогать не будем. В этом классе будут храниться сгенерированные ID для всех ресурсов проекта (из папки res/*), чтобы мы могли к ним обращаться. Имена этих ID-констант совпадают с именами файлов ресурсов (без расширений).

Файл res/layout/activity_main.xml был создан средой разработки вместе с Activity. Его название запрашивалось на том же экране, где и название Activity (скрин выше).

В последующих уроках этот файл называется обычно main.xml, а не activity_main.xml

Откроем двойным кликом res/layout/activity_main.xml


посмотрим, что там


Запустим приложение и посмотрим, что оно нам покажет


Все верно - Activity отобразил то, что прописано в activity_main.xml.

Попробуем отобразить содержимое другого файла. Создадим еще один layout-файл, например myscreen.xml. Для этого выделим папку res/layout в нашем модуле и нажмем на ней правую кнопку мыши. В появившемся меню выбираем New > Layout resource file. Для любителей горячих клавиш есть более удобный путь: при выделенной папке res/layout нажать ALT+Insert, и там уже Enter на пункте Layout resource file.


Вводим имя файла myscreen, остальное пока не меняем, жмем OK.

В папке layout должен появиться новый файл myscreen.xml


Этот новый layout-файл должен сразу открыться на редактирование. Добавим на экран элемент Plain TextView из списка слева и через Properties изменим его текст на: «new layout file myscreen for activity».


Обязательно сохраняем (CTRL+S).

При создании нового layout-файла myscreen, среда добавила в R.java новую константу для этого файла - R.layout.myscreen. И мы теперь в коде сможем через эту константу указать на этот новый layout-файл.

Настроим так, чтобы Activity использовало новый файл myscreen.xml, а не activity_main.xml, который был изначально. Откроем MainActivity.java и поменяем аргумент метода setContentView. Замените «R.layout.activity_main», на «R.layout.myscreen» (ID нового layout-файла). Должно получиться так:

Сохраняем код (CTRL+S) и запускаем приложение (SHIFT+F10).

Теперь нам предложат подтвердить, что мы хотим запустить приложение на включенном эмуляторе.


Чтобы он при каждом запуске это не спрашивал, включите галку Use same device for future launches и жмите OK.


Видим, что теперь оно отображает содержимое из myscreen.xml, т.к. мы явно ему это указали в методе setContentView, который выполняется при создании (onCreate) Activity

Layout-файл в виде XML

Открыв в Android Studio layout файл activity_main или myscreen, вы видите его визуальное представление. Т.е. некий предпросмотр, как это будет выглядеть на экране. Снизу вы можете видеть две вкладки – Design и Text. Откройте вкладку Text


Мы видим достаточно читабельное xml-описание всех View нашего layout-файла. Названия xml-элементов - это классы View-элементов, xml-атрибуты - это параметры View-элементов, т.е. все те параметры, что мы меняем через вкладку Properties. Также вы можете вносить изменения прямо сюда и изменения будут отображаться во вкладке Design. Например, изменим текст у TextView. Вместо «new layout file myscreen for activity», напишем текст «some new text»


Сохраняем. Открываем Design и наблюдаем изменения.


Обычно авторы учебников дают содержание layout-файлов именно в xml виде. Это удобно – вы можете просто скопировать фрагмент и использовать, и не надо вручную добавлять View-элементы, бегать по Properties и настраивать все руками. Я буду делать в своих проектах так же.

Layout-файл при смене ориентации экрана

По умолчанию мы настраиваем layout-файл под вертикальную ориентацию экрана. Но что будет если мы повернем смартфон и включится горизонтальная ориентация? Давайте смотреть.

Изменим myscreen.xml. Добавим вертикальный ряд кнопок и изменим надпись.

xml-код (вы можете скопировать его и заменить им содержимое вашего layout файла myscreen во вкладке Text):

Обратите внимание - я добавил вертикальный LinearLayout и поместил в него 4 кнопки. Подробнее обсудим это на следующем уроке.

Сохраним файл, запустим приложение.


В вертикальной ориентации все ок.

Нажмем в эмуляторе CTRL+F12, ориентация сменилась на горизонтальную и наши кнопки уже не влезают в экран.


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

Но как дать знать Activity, что она в вертикальной ориентации должна использовать один layout-файл, а в горизонтальной – другой? Об этом за нас уже подумали создатели Андроид. У нас есть возможность создать layout-файл, который будет использоваться приложением, когда устройство находится в горизонтальной ориентации.

Создание такого файла почти не отличается от создания обычного layout-файла. Становимся на папку res/layout и создаем новый Layout resource file. Название файла указываем то же самое: myscreen. Осталось добавить спецификатор, который даст приложению понять, что этот layout-файл надо юзать в горизонтальной ориентации. Для этого в списке спецификаторов слева снизу находим Orientation


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

Обратите внимание, что изменилось значение поля Directory name


Настройкой спецификатора мы указали, что наш новый layout-файл будет создан в папке res/layout-land, а не res/layout, как обычно. Т.е. спецификатор –land указывает на то, что layout-файлы из этой папки будут использованы в горизонтальной ориентации устройства.

Посмотрим на структуру модуля


Видим, что у нас теперь два файла myscreen: обычный и land. Можно это же увидеть в структуре папок. Для этого сверху поменяйте вид проекта с Android на Project


И вы увидите, что в модуле теперь есть папки res/layout и res/layout-land. И обе они содержат файл myscreen.

Откроем двойным кликом файл res/layout-land/myscreen и поменяем его содержимое на такой xml-код:

Вкладка Design покажет следующее:


В этом layout файле мы расположили кнопки горизонтально, чтобы они адекватно отображались в горизонтальной ориентации.

Обратите внимание на название файла сверху. Там присутствует спецификатор land, чтобы вы всегда понимали какой из двух myscreen вы сейчас редактируете.


Activity читает layout-файл, который мы указывали в методе setContentView, т.е. myscreen.xml и отображает его содержимое. При этом оно учитывает ориентацию устройства, и в случае горизонтальной ориентации берет myscreen из папки res/layout-land (если он, конечно, там существует).

Переключим ориентацию CTRL+F12.


Activity понимает, что находится в вертикальной ориентации, и использует layout-файл myscreen из папки res/layout.

Еще немного об уроках. Далее почти во всех уроках основной layout-файл будет называться main.xml. Пусть это вас не смущает, просто помните, что ваш основной файл - это activity_main.xml.

- в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

- ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня

- новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме

Доброго дня.
Прошу простить мои ламерские вопросы.
Проблема раз:
Нужно сгенерить xml файл.
Погуглил, нашел только как обрабатывать чужие XMLки.
Если не трудно можно пример создания простейшей XML, или ссылку на русскую инфу(где для чайника расписано).

Проблема два:
Как мне сохранить xml?
Необходимо создать папку на диске девайса, и туда сохранять.

По работе заставили писать програмулину, времени осталось мало, а я дуб дубом)

__________________
Помощь в написании контрольных, курсовых и дипломных работ здесь

Создание XML запроса
Всем привет) Пишу приложения для регистрирования пользователей на сервере. Пользователь вводит.

Создание XML файлов Андроидом
Требуется написать программу, которая будет создавать XML файл с некоторым кодом. Я не имею понятия.

Создание объекта через xml разметку. NullPointerExeption
Кажется у меня пробел в основах, я думал прописывая вью через разметку, при сборке создается.

Создание экрана программно и через xml файл
Когда задаю всё программно, все элементы как надо располагаются на экране, ничего не сдвигается.

В кратце по второму файл сохраняется во внутреннею память устройства (папка /data/data/имя пакета/) и только твое приложение сможет читать этот файл (предполагается что устройство без рут прав) Вот два достаточно понятных урока по созданию и чтению xml файлов с помощью DOM-парсера.
Создание.
Чтение.

Добавлено через 5 часов 53 минуты
Ребят проблема, не хочет гадость работать. Нажимаю кнопку Сохранить и пишет что приложение остановлено.
Выкидываю код, посмотрите пожалуйста!

Как смотреть логи нормальные я еще не разобрался. Но методом тыка понял что ошибка возникает в 460 строке. а мы каким методом должны угадать какая там ошибка возникла? Прощу прощения за мою не состоятельность в данном вопросе.
Переписал заново, ошибки нету.
Но я не совсем понял как сохранить XML.
Вот я создал XML и попробовал ее сохранить :

Однако (папка /data/data/имя пакета/) пуста.
'и только твое приложение сможет читать этот файл'
В дальнейшем данные XMLки будут парсится на сайте.
Как правильно сохранять?

Добавлено через 1 минуту
c4sp3r, спс изучу

VictorAkira, файл должен сохранится в

если имя твоего пакета com.example.nero

еще можно получить путь например так:

Прошелся поиском, нету( Что я мог не правильно сделать? VictorAkira, ты на эмуляторе проверяешь или на устройстве? VictorAkira, если на нем нет рут прав ты не увидишь папку! Но твое приложение может читать данный файл.
Еще можно сохранять на sdcard.

c4sp3r,
В DDMS у меня папка data вообще пуста.

Дело в том что мне нужно сохранить XMl так, что бы его можно было вытянуть и обработать.
Работать все это дело будет на планшетах, будут ходить люди на выставке и заполнять анкету(а это и есть мое приложение). А у них точно прав рута не будет.

VictorAkira, ну если рут прав нет конечно она будет пуста.

Дело в том что мне нужно сохранить XMl так, что бы его можно было вытянуть и обработать.

Ну после создания напиши код чтоб он экспортировал этот файл на sdcard или вообще заливал на сервер и т.п.

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

Добавлено через 7 минут
Или сразу сохраняй файл в папку где у тебя есть доступ на чтение правда openFileOutput уже не пойдет
но есть и другие методы.

ОЧень сильно Вас благодарю!
Однако у нас так и не получилось сделать(
Мне надо создать вот такую XML:
И сохранить ее в корень памяти(аля DCIM).
Если поможете то будем очень благодарны, ибо уже сроки горят(

Уважаемый, ViktorAkira.
Вот вам рабочий класс для создания xml файла с вашей структурой. Создаете объект этого класса и вызываете метод setAttr. Метод сам посмотрит существования файла и если его нет, то создаст с коревым тегом Question. После этого наполнит дочерними тегами и атрибутами. Значения атрибутам будут присвоены те, которые вы передадите в качестве параметров при вызове метода setAttr.
Новая запись в xml файле будет появляться столько раз, сколько вы вызовите этот метод.
Класс еще нужно до ума довести, например, сделать сохранение на SD-CARD (сейчас он пишется в каталог приложения), сделать этого не могу, т.к. комп заглючил, а с ним и IDE.

VictorAkira,

не забудь только в манифест добавить:

Да и если папки /mnt/sdcard/DCIM не существует файл не сохранится! Можно конечно добавить создание папки и создать например класс для получаемых данных и т.д. но мне лень, остальное сам добавишь.
Кстати папка DCIM вообще-то не предназначена для xml.

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

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

Как правило, каждый экран в вашем приложении для Android связан с одним классом Java или Kotlin, известным как Activity. Этот термин можно перевести как активность или деятельность, но мы будем использовать термин активити, без перевода. Единственный экран с отображенным «Hello World» создается с помощью активити MainActivity.kt. Это активити было создано средой разработки, когда вы создали свой новый проект. Каждое видимое активити в приложении для Android имеет макет, который определяет пользовательский интерфейс для активити. Android Studio имеет редактор макетов, в котором вы можете создавать и определять макеты.

Макеты описаны в XML. Редактор макета позволяет вам определять и изменять макет либо путем кодирования XML, либо с помощью интерактивного визуального редактора. Вы можете переключаться между редактированием макета в XML и в редакторе визуального дизайна и создавать макеты любым способом.

1 . Редактор макета в Android Studio

Каждый элемент в макете представляет собой view, или представление. В этой задаче изучим интерфейс редактора макетов в Android Studio и разберемся, как изменять значения свойств для view.

Что вы узнаете

  • Как использовать редактор макетов.
  • Как установить значения свойств.
  • Как добавить строковые ресурсы.
  • Как добавить цветовые ресурсы.

Откройте редактор макета

Изучите и измените размер дерева компонентов

  1. Посмотрите на дерево компонентов в левом нижнем углу вкладки «Дизайн».
    На этой панели отображается иерархия представлений view в вашем макете.
  2. Отрегулируйте стороны панелей так, чтобы вы могли видеть все в Дереве компонентов.
  3. Щелкните значок «Закрыть панель» в правом верхнем углу дерева компонентов.Панель Component Tree закрывается.
  4. Верните панель Component Tree, щелкнув по вертикальной метке «Дерево компонентов» слева.Теперь, когда вы знаете, как изменять размер, закрывать и открывать панель Component Tree, пришло время изучить иерархии представлений view.

Исследуйте иерархии представлений view

Далее в этом уроке мы рассмотрим работу с ConstraintLayout более подробно.


  1. Обратите внимание, что ConstraintLayout содержит TextView.
  2. Просмотрите XML-код для макета, щелкнув вкладку « Текст » в нижней части вкладки «Дизайн».
  3. В коде XML обратите внимание, что корневой элемент <android.support.constraint.ConstraintLayout>. Корневой элемент содержит один <TextView> элемент.

Читайте также: