Как называется компонент отображающий определенный экран в Android-прилож.?
Как называется компонент, отображающий определенный экран в Android-приложениях?
Чтобы правильно ответить на вопрос, надо дать каждому предлагаемому ответу пояснение.
Сначала определим, что такое Activity
Этот ответ там подходит, но разберем и другие понятия.
Следующее понятие, это слово Intent:
Оно нам не подходит.
Рассмотрим последнее определение View
Теперь не составит труда ответить на вопрос. Верный ответ: Activity.
Очередной вопрос от VK Testers касается операционной системы Android.
Когда одновременно используется несколько экранов, то в какой-то определенный момент активен только один или два, поэтому предположу, что определяется экран тот, который активен, компонентом с названием Activity.
Ответ на этот вопрос: 1.
Сегодня начали раздавать новые стикеры в ВК с хорошеньким беленьким кроликом, но чтобы их получить нужно ответить на восемь очень сложных вопросов, должно быть хотя-бы пять ответов из этих восьми правильных. Вот на этот вопрос я сама нашла ответ, хотя с трудом понимаю что-то в этой теме. Нам не подойдет ни ответ "Intent" ни ответ "View". Компонент о котором идет речь в вопросе называется — Activity.
Урок 1. Создание Activity и работа с LinearLayout на примере UserInfoScreen
При создании проекта в предыдущем уроке автоматически были созданы два файла: UserInfoActivity.java и activity_user_info.xml . В целом, это отражает парадигму написания кода при разработке Android приложений: весь код нашего проекта делится на два типа файлов:
- xml – файлы с расширением .xml . С их помощью мы создаем разметку элементов отображаемых в нашем приложении, иными словами – пользовательский интерфейс приложения. Для каждого окна ( Activity ) приложения создается свой xml -файл со своей разметкой. Также их можно включать друг в друга, комбинировать и использовать много раз одну и ту же разметку с помощью дублирования. Как это делается, мы рассмотрим далее.
- java – файлы с расширением .java , содержат в себе код, отвечающий за все процессы (бизнес-логику) происходящие в программе.
Итак, у нас есть файл разметки с внешним видом элементов activity_user_info.xml и файл, который приводит в действие эти элементы UserInfoActivity.java . Android Studio по умолчанию связала наши UserInfoActivity.java и activity_user_info.xml в методе onCreate() класса UserInfoActivity . Если кто-то не помнит (не знает) жизненный цикл Activity , то будет полезно освежить знания, посмотрев этот урок.
Весь экран, который нам предстоит сделать в ближайшие уроки выглядит так:
Вначале нам необходимо сделать эту часть экрана:
В первую очередь необходимо абстрагироваться и разбить экран на блоки, чтобы представить структуру файла xml . Визуально это можно представить прямоугольниками с именами элементов и их id . Выглядит это так:
Затем надо проанализировать расположение элементов. Очень важно уделить этому время, чтобы потом ничего не пришлось переделывать. Можно заметить, что первые пять элементов расположены линейно вертикально (один находится под другим), а два последних элемента линейно горизонтально относительно друг друга.
Элементы View, ViewGroup
Здесь самое время вспомнить (узнать) немного базовой теории об элементах пользовательского интерфейса в Android.
Внутри xml -файлов все элементы делятся на два вида – элементы и контейнеры, с помощью которых можно объединять несколько элементов:
- элементы – это компоненты View . С английского это можно перевести как отображение. Мы отображаем разные элементы в нашей разметке. View -компоненты – это просто прямоугольники на экране, границы которых мы можем видеть, а можем и не видеть. И все базовые компоненты расширяют View -компонент: TextView , EditText , Button , Spinner , CheckBox . У каждого элемента есть свои свойства такие как ширина, высота, размеры, цвета и многое другое. Все эти свойства меняются с помощью соответствующих атрибутов ( android:layout_width , android:layout_height , android:background и т.д.).
- контейнеры называются ViewGroup , что означает группа элементов. Внутрь контейнера можно поместить любые элементы (текст, картинки, кнопки, другие контейнеры (т.к. ViewGroup в свою очередь также является View )). Они служат для удобства, чтобы мы могли группировать элементы экрана и тем самым создавать удобную структуру, с нам будет удобно работать.
Для линейного расположения элементов в Android есть контейнер LinearLayout (рус. линейный макет). Если кто-то не знаком с ним, то можно посмотреть этот урок. Мы будем использовать его в качестве главного контейнера для нашего layout . У LinearLayout есть атрибут android:orientation=»vertical | horizontal» . Мы будем использовать значение vertical потому что элементы расположены вертикально.
Теперь создадим layout , в соответствии нашим описанием. Для того, чтобы видеть расположение элементов необходимо наполнить их каким-то содержимым(текстом, изображением). К элементу ImageView добавим атрибут android:src . Это необходимо для того, чтобы отрисовалась хоть какая-то картинка (мы укажем ссылку на стандартную картинку android:src=»https://devcolibri.com/unit/%D1%83%D1%80%D0%BE%D0%BA-1-%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-activity-%D0%B8-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0-%D1%81-linearlayout-%D0%BD%D0%B0-%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80-3/@mipmap/ic_launcher» ). К нашим TextView добавим атрибут android:text , присвоив им соответствующие значения. Наш файл activity_user_info.xml будет выглядеть так:
Android Studio подсвечивает значения атрибутов android:text , предлагая заменить их на строковые ресурсы. Т.к. мы используем эти атрибуты временно, потом мы их просто удалим, то просто игнорируем это замечание.
Когда вы просто создаёте layout , то лучше не запускать приложение каждый раз (т.к. это отнимет гораздо больше времени), а посмотреть результат, нажав кнопку Preview в правой верхней части экрана или нажав на вкладку Design :
Этот режим удобен, когда вам не надо видеть мелкие элементы, требующие детальной проработки. Если же вам надо увидеть layout крупнее, то вы можете нажать вкладку Design снизу и увеличить zoom:
Пока у нас получилась довольно сырая версия нашего экрана. Давайте подумаем, что нужно доработать:
- добавить вертикальные отступы между элементами;
- увеличить размер текста в элементах TextView ;
- добавить отступ у всех элементов по левому краю;
- расположить элементы following_text_view и followers_text_view горизонтально в одной строке.
Первое, что мы исправим – вертикальное расстояние между элементами. Для этого есть два свойства:
- android:padding (top, bottom, right | end, start | left)
- android:layout_margin (top, bottom, right | end, start | left)
Параметры (top, bottom, right | end, start | left) означают, с какой стороны вы хотите сделать отступ. Параметры right | end , start | left означают практически одно и тоже. Только start, end добавляют поддержку для стран, в которых тексты читаются справа налево. Поэтому рекомендуется использовать их вместо left, right . Эти атрибуты поддерживаются с 17 версии устройств, значит мы можем их использовать (помните, что при создании проекта мы указали, что поддерживаем устройства 17 версии и выше).
Если указать padding без всякого параметра, то отступ будет сделан со всех сторон. Основное различие двух атрибутов состоит в том, что padding делает отступ внутри элемента, а layout_margin делает отступ снаружи. Покажем это на примере. Как говорилось ранее, View -компоненты – это просто прямоугольники, которые отображаются на экране. И иногда для целей проверки каких-либо наших решений в xml -файлах удобно пользоваться свойством, которое присутствует у каждого View -компонента – android:background . Задавая ему какой-либо цвет явно выделяющийся на экране мы можем чётко увидеть границы, занимаемые нашим элементом для проверки соответствия отрисованного на экране с тем, что мы желали бы там видеть.
Таким образом, давайте отредактируем атрибуты первых двух TextView , а всё остальное оставим неизменным:
В результате увидим:
То есть видим, что границы элемента user_name_text_view увеличились. Границы элемента стали занимать больше места, потому что мы указали ему высоту и ширину wrap_content (рус. упаковывать содержимое) и визуально образовался отступ для текста. А user_nick_text_view занимает столько же места, сколько и текст в нём, потому что layout_marginTop задаёт отступ снаружи элемента. В случаях, когда нам не нужно увеличивать размеры самого элемента (это и есть наш случай), лучше использовать свойство layout_marginTop .
Давайте удалим свойства background , marginTop , paddingTop из наших TextView для дальнейшей работы.
Так, с отступом между элементами мы разобрались. Давайте добавим к каждому TextView атрибут увеличения вертикального отступа (а заодно увеличим и размера шрифта):
Следующий шаг – добавление отступа у всех элементов по левому краю. Можно добавить всем элементам атрибут layout_marginStart . Но давайте подумаем, что будет, если в layout добавятся ещё 20 новых TextView ? Придётся добавлять это свойство в каждый элемент. А если надо будет изменить размер отступа? Это будет задача не из простых, точнее не из быстрых. Все элементы находятся внутри одного LinearLayout . Помните, что padding делает отступы внутри элемента? Это именно тот случай, когда надо применить этот атрибут. Укажем атрибут padding для LinearLayout . Причём по рекомендациям Google padding у контейнеров должен быть симметричный (одинаковый со всех сторон).
Нам осталось выполнить последнее задание в этом уроке. Необходимо расположить элементы following_text_view и followers_text_view горизонтально в одной строке. Помните, на рисунке с блоками элементов мы их визуально объединили ещё в один прямоугольник? Чтобы расположить их горизонтально мы можем также использовать LinearLayout , в который вложим два этих элемента. Давайте для двух последних TextView в нашем layout сделаем контейнер LinearLayout . Т.к. мы хотим расположить наши элементы горизонтально, то используем атрибут android:orientation=»horizontal» у нашего LinearLayout .
Выглядит это так:
Важно, что атрибуты android:layout_width , android:layout_height у LinearLayout имеют значение wrap_content . Это значит, что контейнер занимает ровно столько места, сколько необходимо его вложенным элементам.
Нам необходимо добавить отступ между элементами внутри. Давайте добавим атрибут android:layout_marginStart=»10dp» элементу, стоящему справа( followers_text_view ).
Также мы можем перенести повторяющийся атрибут layout_marginTop в их контейнер. Это лучше сделать, чтобы при изменениях величины менять её в минимальном количестве мест. Учитывая все замечания, получим:
Посмотрим, что получилось:
Что ж, в этом уроке мы создали основу для отображения данных пользователя, используя контейнер LinearLayout . В следующем уроке на практике познакомимся с контейнером RelativeLayout .
Полезные материалы:
2.2 Компоненты Android-приложения
Приложения для Androidсостоят из компонентов, которые система может запускать и управлять так, как ей необходимо.
Всего в Android-приложениях существует четыре типа компонентов:
Взаимодействие компонентов осуществляется с помощь объектов Intent.
Компонент Activityпредставляет собой визуальный пользовательский интерфейс для приложения – окно. Как правило, окно полностью заполняет экран мобильного устройства, но может иметь размер меньше, чем у экрана.Activityможет также использовать дополнительные окна, например всплывающее диалоговое окно, которое запрашивает пользовательский ответ для основногоActivity, или окно уведомлений о каком-либо событии в приложении или системе.
Все Activityреализуются как подкласс базового классаActivity. Приложение может содержать несколькоActivity. КаждыйActivityнезависим от других. При открытии новогоActivityработа предыдущегоActivityприостанавливается, а сам он вносится и сохраняется в стекActivity.
Компонент Serviceне имеет визуального интерфейса пользователя и выполняется в фоновом режиме в течение неопределенного периода времени, пока не завершит свою работу. Этот компонент аналогичен службам в настольных операционных системах.
Приложения могут подключаться к компоненту Serviceили запускать его, если он не запущен, а также останавливать уже запущенные компоненты. Подключившись кService, можно обращаться к функциям компонента через предоставляемый этим компонентом интерфейс.
Broadcast Receiver
Компонент BroadcastReceiver– компонент для получения внешних событий и реакции на них. Инициализировать передачи могут другие приложения иService.
Приложение может иметь несколько компонентов BroadcastReceiver, чтобы ответить на любые объявления, которые оно считает важными.
BroadcastReceiverне имеют пользовательского интерфейса. Однако они могут запуститьActivityили службу, выдать в ответ на информацию, которую они получают, или показать уведомление на экране мобильного устройства, чтобы предупредить пользователя о наступившем событии.
Content Provider
Компоненты ContentProviderделает определенный набор данных, используемых приложением, доступным для других приложений. Этот компонент является своеобразным посредником между хранилищем данных и клиентским приложением.
Данные в Androidмогут быть сохранены различными способами: в файловой системе, в базе данныхSQLiteили любым другим способом.ContentProvider, для безопасного доступа к данным, используют механизм разрешений. Это означает, что вы можете сконфигурировать собственныйContentProvider, чтобы разрешить доступ к своим данным из других приложений, а также использоватьContentProviderдругого приложения для обращения к его хранилищу данных.
Главная особенность платформы Androidсостоит в том, что одно приложение может использовать элементы других приложений, при условии, что это приложения разрешают использовать свои компоненты. При этом ваше приложение не включает код другого приложения или ссылки на него, а просто запускает нужный элемент другого приложения.
Поэтому, в отличие от приложений в большинстве других систем, у приложений Androidнет единственной точки входа для запуска всего приложения, аналогичной, например, функцииmain() в С-подобных языках программирования.
Для реализации такого использования компонентов других приложений система должна быть в состоянии запустить процесс для приложения, в котором находится требуемый компонент, и инициализировать нужные ей объекты [6, 12, 13].
Как называется компонент отображающий определенный экран в android приложениях
В прошлой теме мы рассмотрели создание простого приложения, который предлагает Android Studio по умолчанию и которое просто выводит на экран строку Hello Android.
Но почему у нас выводится именно эта строка? Почему у нас вообще создается именно такой визуальный интерфейс?
Выполнение приложения Android по умолчанию начинается с класса MainActivity , который по умолчанию открыт в Android Studio:
Каждый отдельный экран или страница в приложении описывается таким понятием как activity. В литературе могут использоваться различные термины: экран, страница, активность. В данном случае я буду использовать понятие «activity». Так вот, если мы запустим приложение на устройстве, то на экране мы по сути увидим определенную activity, которая предсталяет данный интерфейс.
Класс MainActivity по сути представляет обычный класс java, в начале которого идет определение пакета данного класса:
Далее идет импорт классов из других пакетов, функциональность которых используется в MainActivity:
Затем идет собственно определение класса:
По умолчанию MainActivity наследуется от класса AppCompatActivity, который выше подключен с помощью директивы импорта. Класс AppCompatActivity по сути представляет отдельный экран (страницу) приложения или его визуальный интерфейс. И MainActivity наследует весь этот функционал.
По умолчанию MainActivity содержит только один метод onCreate() , в котором фактически и создается весь интерфейс приложения:
В метод setContentView() передается ресурс разметки графического интерфейса:
Именно здесь и решается, какой именно визуальный интерфейс будет иметь MainActivity. Но что в данном случае представляет ресурс R.layout.activity_main ? Это файл activity_main.xml из папки res/layout (в принципе можно заметить, что название ресурса соответствует названию файла), который также по умолчанию открыт в Android Studio:
Файл activity_main.xml
Android Studio позволяет работать с визуальным интерфейсом как в режиме кода, так и в графическом режиме. Так, по умолчанию файл открыт в графическом режиме, и мы наглядно можем увидеть, как у нас примерно будет выглядеть экран приложения. И даже набрасать с панели инструментов какие-нибудь элементы управления, например, кнопки или текстовые поля.
Но также мы можем работать с файлом в режиме кода, поскольку activity_main.xml — это обычный текстовый файл с разметкой xml. Для переключения к коду нажмем на кнопку Code над графическим представлением. (Дополнительно с помощью кнопки Split можно переключиться на комбинированное представление код + графический дизайнер)
Здесь мы увидим, что на уровне кода файл activity_main.xml содержит следующую разметку:
Весь интерфейс представлен элементом-контейнером androidx.constraintlayout.widget.ConstraintLayout :
ConstraintLayout позволяет расположить вложенные элементы в определенных местах экрана. Вначале элемента ConstraintLayout идет определение пространств имен XML:
Каждое пространство имен задается следующим образом: xmlns:префикс=»название_ресурса» . Например, в
Название ресурса (или URI — Uniform Resource Indicator) — «http://schemas.android.com/apk/res/android» . И этот ресурс сопоставляется с префиксом android ( xmlns:android ).
Зачем эти пространства имен нужны? Каждый ресурс или URI определяет некоторую функциональность, которая используется в приложении, например, предоставляют теги и атрибуты, которые необходимые для построения приложения.
xmlns:android=»http://schemas.android.com/apk/res/android» : содержит основные атрибуты, которые предоставляются платформой Android, применяются в элементах управления и определяют их визуальные свойства (например, размер, позиционирование)
xmlns:app=»http://schemas.android.com/apk/res-auto» : содержит атрибуты, которые определены в рамках приложения
xmlns:tools=»http://schemas.android.com/tools» : применяется для работы с режиме дизайнера в Android Studio
И чтобы упростить работу с этими ресурсами, применяются префиксы. Например, дальше мы видим:
android:layout_width определяет ширину контейнера. Этот атрибут ( layout_width ) расположен в ресурсе «http://schemas.android.com/apk/res/android». И поскольку этот ресурс сопоставляется с префиксом android , то для обращения к атрибуту перед ним через двоеточие указывается префикс данного ресурса.
Значением атрибута android:layout_width является «match_parent» . Это значит, что элемент (ConstraintLayout) будет растягиваться по всей ширине контейнера (экрана устройства).
Атрибут android:layout_height=»match_parent» определяет высоту контейнера и также определен в «http://schemas.android.com/apk/res/android». Значение «match_parent» указывает, что ConstraintLayout будет растягивается по всей длине контейнера (экрана устройства).
Атрибут tools:context определяет, какой класс activity (экрана приложения) связан с текущим определением интерфейса. В данном случае это класс MainActivity. Это позволяет использовать в Android Studio различные возможности в режиме дизайнера, которые зависят от класса activity.
TextView
Текстовое поле устанавливает текст с помощью атрибута android:text .
android:layout_width устанавливает ширину виджета. Значение wrap_content задает для виджета величину, достаточную для отображения в контейнере.
android:layout_height устанавливает высоту виджета. Значение wrap_content аналогично установке ширины задает для виджета высоту, достаточную для отображения в контейнере
android:text устанавливает текст, который будет выводиться в TextView (в данном случае это строка «Hello World!»)
app:layout_constraintLeft_toLeftOf=»parent» : указывает, что левая граница элемента будет выравниваться по левой стороне контейнера ConstraintLayout
Обратите внимание, что этот атрибут определен в пространстве имен с префиксом app, то есть в «http://schemas.android.com/apk/res-auto».
app:layout_constraintTop_toTopOf=»parent» : указывает, что верхняя граница элемента будет выравниваться по верхней стороне контейнера ConstraintLayout
app:layout_constraintRight_toRightOf=»parent» : указывает, что правая граница элемента будет выравниваться по правой стороне контейнера ConstraintLayout
app:layout_constraintBottom_toBottomOf=»parent» : указывает, что нижняя граница элемента будет выравниваться по нижней стороне контейнера ConstraintLayout
Стоит отметить, что последние четыре атрибута вместе будут приводить к расположению TextView по центру экрана.