Эта страница переведена с помощью Cloud Translation API.

Основы Android Kotlin 01.2: Базовая анатомия приложения

Эта практическая работа входит в курс «Основы Android Kotlin». Вы получите максимальную пользу от этого курса, если будете выполнять практические работы последовательно. Все практические работы курса перечислены на целевой странице практической работы «Основы Android Kotlin» .

Введение

Итак, вы всё настроили, и Android Studio создала для вас большой объём кода. Прежде чем редактировать весь этот код, важно знать, что вы только что создали, и как ориентироваться в исходных файлах приложения для Android.

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

Что вам уже следует знать

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

Чему вы научитесь

Как редактировать файл макета приложения.
Как создать приложение с интерактивным поведением.
Много новой терминологии. Загляните в глоссарий терминов , чтобы получить понятные объяснения терминов и понятий.

Что ты будешь делать?

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

В этой лабораторной работе вы создадите новый проект приложения под названием DiceRoller и добавите базовую интерактивность с помощью кнопки. При каждом нажатии на кнопку значение отображаемого текста меняется. Итоговое приложение DiceRoller для этой лабораторной работы выглядит следующим образом:

В предыдущей лабораторной работе вы изучили основные компоненты проекта приложения, включая каталоги java и res . В этой работе вы сосредоточитесь на двух важнейших файлах, составляющих ваше приложение: файле MainActivity Kotlin и файле макета activity_main.xml .

Шаг 1: Проверьте MainActivity

MainActivity — пример Activity . Activity — это базовый класс Android, который отображает пользовательский интерфейс (UI) приложения Android и принимает события ввода. При запуске приложения запускается Activity, указанная в файле AndroidManifest.xml .

Во многих языках программирования определён метод main, который запускает программу. В приложениях Android метод main отсутствует. Вместо этого файл AndroidManifest.xml указывает, что MainActivity должен запускаться при нажатии пользователем значка запуска приложения. Для запуска активности ОС Android использует информацию из манифеста для настройки среды приложения и создания MainActivity . Затем MainActivity выполняет некоторые настройки.

С каждым действием связан файл макета. Действие и макет связаны процессом, известным как инфляция макета . При запуске действия представления, определённые в XML-файлах макета, преобразуются (или «раздуваются») в объекты представлений Kotlin в памяти. После этого действие может отображать эти объекты на экране и динамически изменять их.

В Android Studio выберите «Файл» > «Создать» > «Новый проект» , чтобы создать новый проект. Выберите «Пустая активность» и нажмите «Далее» .
Назовите проект DiceRoller и проверьте все остальные значения параметров «Имя проекта» и «Расположение проекта». Убедитесь, что установлен флажок «Использовать артефакты AndroidX». Нажмите «Готово» .
На панели Project > Android разверните java > com.example.android.diceroller . Дважды щелкните MainActivity . Редактор кода отобразит код MainActivity .
Под именем пакета и операторами импорта находится объявление класса MainActivity . Класс MainActivity расширяет AppCompatActivity .

class MainActivity : AppCompatActivity() { ...

Обратите внимание на метод onCreate() . Активности не используют конструктор для инициализации объекта. Вместо этого в процессе настройки активности вызывается ряд предопределённых методов (называемых «методами жизненного цикла»). Один из этих методов жизненного цикла — onCreate() , который вы всегда переопределяете в своём приложении. Подробнее о методах жизненного цикла вы узнаете в следующей практической работе.

В onCreate() вы указываете, какой макет связан с активностью, и расширяете его. Метод setContentView() выполняет обе эти функции.

override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(R.layout.activity_main)
}

Метод setContentView() ссылается на макет с помощью R.layout.activity_main , который фактически является целочисленной ссылкой. Класс R генерируется при сборке приложения. R включает в себя все ресурсы приложения, включая содержимое каталога res .

В этом случае R.layout.activity_main ссылается на сгенерированный класс R , папку layout и файл макета activity_main.xml . (Ресурсы не включают расширения файлов.) Вы будете ссылаться на многие ресурсы приложения (включая изображения, строки и элементы в файле макета), используя аналогичные ссылки в классе R

Шаг 2: Изучите и изучите файл макета приложения.

Все действия в вашем приложении имеют связанный файл макета в каталоге res/layout . Файл макета — это XML-файл, описывающий внешний вид действия. Файл макета определяет представления и их расположение на экране.

Представления — это такие элементы, как текст, изображения и кнопки, расширяющие класс View . Существует множество типов представлений, включая TextView , Button , ImageView и CheckBox .

В этом задании вы проверите и измените файл макета приложения.

На панели «Проект» > «Android» разверните раздел res > layout и дважды щёлкните по файлу activity_main.xml . Откроется редактор макета. В Android Studio есть этот редактор, который позволяет визуально создавать макет приложения и просматривать его. Подробнее о редакторе макета вы узнаете в следующем практическом занятии.
Чтобы просмотреть файл макета в формате XML, щелкните вкладку Текст в нижней части окна.
Удалите весь существующий XML-код в редакторе макетов. Макет по умолчанию, который вы получаете вместе с новым проектом, — хорошая отправная точка, если вы работаете в редакторе дизайна Android Studio. В этом уроке вы будете работать с базовым XML-кодом, чтобы создать новый макет с нуля.
Скопируйте и вставьте этот код в макет:

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

<LinearLayout   
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    tools:context=".MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />

</LinearLayout>

Теперь изучите код:

Элемент верхнего уровня, или корневой, макета — это элемент <LinearLayout> . Представление LinearLayout — это ViewGroup . Группы представлений — это контейнеры, которые содержат другие представления и помогают определить их положение на экране.

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

Корневым элементом по умолчанию для нового проекта Android является ConstraintLayout , который хорошо работает в сочетании с редактором дизайна. В этом приложении используется группа представлений LinearLayout , которая проще, чем макет с ограничениями. Подробнее о группах представлений и макете с ограничениями вы узнаете в следующем уроке.
Внутри тега LinearLayout обратите внимание на атрибут android:layout_width . Ширина этого LinearLayout установлена в match parent , то есть он равен родительскому элементу. Поскольку это корневой элемент, макет разворачивается на всю ширину экрана.
Обратите внимание на атрибут android:layout_height , которому присвоено значение wrap_content . Этот атрибут устанавливает высоту LinearLayout , равную суммарной высоте всех содержащихся в нём представлений (на данный момент это только TextView .
Изучите элемент <TextView> . Этот TextView , отображающий текст, — единственный визуальный элемент в вашем приложении DiceRoller. Атрибут android:text содержит строку для отображения, в данном случае — "Hello World!"
Обратите внимание на атрибуты android:layout_width и android:layout_height в элементе <TextView> , которым присвоено значение wrap_content . Содержимым текстового представления является сам текст, поэтому представление будет занимать только необходимое для текста пространство.

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

Шаг 1: Добавьте кнопку в макет

Добавьте элемент Button в макет под текстовым полем, введя <Button и нажав клавишу Enter. Появится блок Button , заканчивающийся на /> и включающий атрибуты layout_width и layout_height .

<Button
   android:layout_width=""
   android:layout_height="" />

Установите атрибуты layout_width и layout_height на значение "wrap_content" . При этих значениях ширина и высота кнопки будут такими же, как и у текстовой надписи, которую она содержит.
Добавьте к кнопке атрибут android:text и присвойте ему значение «Roll». Теперь элемент Button выглядит так:

<Button
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:text="Roll" />

Для представлений Button атрибут text — это метка кнопки. В редакторе макета атрибут подсвечивается жёлтым цветом, что указывает на подсказку или предупреждение. В данном случае жёлтый цвет обусловлен тем, что строка "Roll" жёстко закодирована в метке кнопки, но сама строка должна быть ресурсом. Подробнее о строковых ресурсах см. в следующем разделе.

Шаг 2: Извлечение строковых ресурсов

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

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

Android Studio поможет вам запомнить необходимость помещения строк в файл ресурсов с помощью подсказок и предупреждений.

Щелкните один раз по строке «Roll» в атрибуте android:text тега <Button> .
Нажмите Alt+Enter ( Option+Enter в macOS) и выберите Извлечь строковый ресурс во всплывающем меню.
Введите roll_label в качестве имени ресурса .
Нажмите кнопку «ОК» . В файле res/values/string.xml будет создан строковый ресурс, а строка в элементе Button будет заменена ссылкой на этот ресурс:
android:text="@string/roll_label"
На панели Project > Android разверните res > values , а затем дважды щелкните strings.xml , чтобы увидеть строковые ресурсы в файле strings.xml :

<resources>
   <string name="app_name">DiceRoller</string>
   <string name="roll_label">Roll</string>
</resources>

Шаг 3: Стиль и расположение представлений

Теперь ваш макет содержит один элемент управления TextView и один элемент управления Button . В этом задании вы упорядочите элементы управления внутри группы, чтобы они выглядели привлекательнее.

Перейдите на вкладку «Дизайн» , чтобы увидеть предварительный просмотр макета. Сейчас оба представления расположены рядом друг с другом и вынесены в верхнюю часть экрана.
Перейдите на вкладку «Текст» , чтобы вернуться в XML-редактор. Добавьте атрибут android:orientation к тегу LinearLayout и присвойте ему значение "vertical" . Элемент <LinearLayout> должен выглядеть следующим образом:

<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical"
   tools:context=".MainActivity">

Группа представлений LinearLayout располагает содержащиеся в ней представления одно за другим в линию, либо горизонтально в ряд, либо вертикально в стопку. Горизонтальная ориентация используется по умолчанию. Поскольку вы хотите, чтобы TextView располагался поверх Button , вы задаёте вертикальную ориентацию. Теперь дизайн выглядит примерно так: кнопка находится под текстом:

Добавьте атрибут android:layout_gravity к элементам TextView и Button и присвойте ему значение "center_horizontal" . Это выровняет оба элемента по центру горизонтальной оси. Элементы TextView и Button теперь должны выглядеть следующим образом:

<TextView   
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Hello World!" />

<Button
   android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:text="@string/roll_label" />

Добавьте атрибут android:layout_gravity к линейному макету и присвойте ему значение "center_vertical" . Ваш элемент LinearLayout теперь должен выглядеть так:

<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical"
   android:layout_gravity="center_vertical"
   tools:context=".MainActivity">

Чтобы увеличить размер текста в текстовом поле, добавьте атрибут android:textSize к элементу <TextView> со значением "30sp" . Аббревиатура sp расшифровывается как «scalablepixels» (масштабируемые пиксели) , что является мерой изменения размера текста независимо от качества отображения устройства. Теперь элемент TextView должен выглядеть следующим образом:

<TextView   
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:textSize="30sp"
   android:text="Hello World!" />

Скомпилируйте и запустите ваше приложение.

Теперь и текст, и кнопка расположены удобно, а в текстовом поле текст стал крупнее. Кнопка пока не имеет функциональности, поэтому при нажатии на неё ничего не происходит. Работайте над этим дальше.

Шаг 4: Получите ссылку на кнопку в коде.

Код Kotlin в MainActivity отвечает за определение интерактивных компонентов вашего приложения, например, за то, что происходит при нажатии кнопки. Чтобы написать функцию, которая выполняется при нажатии кнопки, необходимо получить ссылку на объект Button в вашем расширенном макете в MainActivity. Чтобы получить ссылку на кнопку:

Присвойте Button идентификатор в XML-файле.
Используйте метод findViewById() в своем коде, чтобы получить ссылку на View с определенным идентификатором.

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

Откройте файл макета activity_main.xml , если он еще не открыт, и перейдите на вкладку Текст .
Добавьте к кнопке атрибут android:id и дайте ей имя (в данном случае « @+id/roll_button" ). Теперь ваш элемент <Button> выглядит так:

<Button
   android:id="@+id/roll_button"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="@string/roll_label" />

При создании идентификатора представления в XML-файле макета Android Studio создаёт целочисленную константу с именем этого идентификатора в сгенерированном классе R Таким образом, если вы назовёте представление roll_button , Android Studio сгенерирует и создаст целочисленную константу с именем roll_button в классе R Префикс "@+id" для имени идентификатора указывает компилятору добавить эту константу в класс R. Все идентификаторы представлений в XML-файле должны иметь этот префикс.

Откройте файл MainActivity на Kotlin. Внутри onCreate() после setContentView() добавьте следующую строку:

val rollButton: Button = findViewById(R.id.roll_button)

Используйте метод findViewById() для получения ссылки на View , определённое в классе XML. В этом случае вы получаете ссылку на Button из класса R и идентификатор roll_button , а затем присваиваете эту ссылку переменной rollButton .

Обратите внимание, что Android Studio выделяет класс Button красным цветом и подчёркивает его, указывая на то, что это неразрешённая ссылка и что перед использованием необходимо импортировать этот класс. Также может появиться подсказка с полным именем класса:
Нажмите Alt+Enter ( Option+Enter на Mac), чтобы принять полностью определенное имя класса.

Шаг 5: Добавьте обработчик щелчков для отображения уведомления

Обработчик кликов — это метод, который вызывается каждый раз, когда пользователь нажимает или касается интерактивного элемента пользовательского интерфейса, например кнопки. Для создания обработчика кликов необходимо:

Метод, выполняющий некоторую операцию.
Метод setOnClickHandler() , который подключает Button к методу обработчика.

В этой задаче вы создадите метод обработчика щелчков для отображения Toast . ( Toast — это сообщение, которое появляется на экране на короткое время.) Вы подключаете метод обработчика щелчков к Button .

В классе MainActivity после onCreate() создайте закрытую функцию с именем rollDice() .

private fun rollDice() {
  
}

Добавьте эту строку в метод rollDice() , чтобы отобразить Toast при вызове rollDice() :

Toast.makeText(this, "button clicked", 
   Toast.LENGTH_SHORT).show()

Чтобы создать тост, вызовите метод Toast.makeText() . Этот метод требует трёх условий:

Объект Context . Он позволяет взаимодействовать с ОС Android и получать информацию о её текущем состоянии. Здесь вам нужен Context , чтобы объект Toast мог сообщить ОС о необходимости отображения уведомления. Поскольку AppCompatActivity является подклассом Context , вы можете просто использовать ключевое Context this для контекста.
Сообщение, которое будет показано, в данном случае "button clicked" .
Длительность отображения сообщения. Метод show() в конце отображает уведомление.

В onCreate() после вызова findViewById() добавьте эту строку, чтобы назначить rollDice() в качестве обработчика щелчков для объекта rollButton :

rollButton.setOnClickListener { rollDice() }

Полное определение вашего класса MainActivity теперь выглядит так:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val rollButton: Button = findViewById(R.id.roll_button)
        rollButton.setOnClickListener { rollDice() }
    }

    private fun rollDice() {
        Toast.makeText(this, "button clicked",
            Toast.LENGTH_SHORT).show()
    }
}

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

В этой задаче вы модифицируете метод rollDice() , чтобы изменить текст в TextView . На первом этапе вы меняете текст с "Hello World!" на строку "Dice Rolled!" . На втором этапе вы выводите случайное число от одного до шести.

Шаг 1: Отображение строки

Откройте activity_main.xml и добавьте идентификатор в TextView .

android:id="@+id/result_text"

Откройте MainActivity . В методе rollDice() закомментируйте строку для отображения Toast .
Используйте метод findViewById() , чтобы получить ссылку на TextView по его идентификатору. Присвойте ссылку переменной resultText .

val resultText: TextView = findViewById(R.id.result_text)

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

resultText.text = "Dice Rolled!"

Скомпилируйте и запустите приложение. Обратите внимание, что нажатие кнопки «Прокрутить» теперь обновляет TextView .

Шаг 2: Отобразите случайное число

Наконец, в этой задаче вы добавляете случайность к нажатию кнопки, имитируя бросок игральной кости. Каждый раз при нажатии или касании кнопки ваш код выбирает случайное число от 1 до 6 и обновляет TextView . Задача генерации случайного числа не является специфичной для Android, и для неё используется класс Random .

В верхней части метода rollDice() используйте метод Random.nextInt() для получения случайного числа от 1 до 6:

val randomInt = Random().nextInt(6) + 1

Установите свойство text равным значению случайного целого числа в виде строки:

resultText.text = randomInt.toString()

Скомпилируйте и запустите приложение. При каждом нажатии кнопки «Прокрутить» число в текстовом поле меняется.

Проект Android Studio: DiceRoller

Задача: добавить в приложение вторую кнопку с надписью «Подсчёт» (Count Up), которая будет располагаться сразу под кнопкой « Прокрутка» . При нажатии кнопка «Подсчёт» должна получать текущее значение текстового представления результата, прибавлять к нему 1 и обновлять текстовое представление. Убедитесь, что вы обрабатываете следующие пограничные случаи:

Если текстовое представление результата еще не содержит числа (то есть, если текстовое представление все еще содержит строку по умолчанию «Hello World»), задайте тексту результата значение 1.
Если число уже равно 6, ничего не делайте.

Код решения задачи по кодированию

Проект Android Studio: DiceRoller-challenge

Деятельность

MainActivity — это подкласс AppCompatActivity , который, в свою очередь, является подклассом Activity . Activity — это базовый класс Android, отвечающий за отрисовку пользовательского интерфейса приложения Android и получение событий ввода.
С каждым действием связан файл макета — XML-файл в ресурсах приложения. Имя файла макета соответствует имени действия, например, activity_main.xml .
Метод setContentView() в MainActivity связывает макет с активностью и расширяет этот макет при создании активности.
Расширение макета — это процесс, в ходе которого представления, определённые в XML-файлах макета, преобразуются (или «раздуваются» в) объекты представлений Kotlin в памяти. После того, как макет расширен, Activity может отображать эти объекты на экране и динамически изменять их.

Просмотры

Все элементы пользовательского интерфейса в макете приложения являются подклассами класса View и называются представлениями . Примерами представлений являются TextView и Button .
Элементы View можно группировать внутри ViewGroup . Группа представления служит контейнером для представлений или других групп представлений внутри неё. LinearLayout — пример группы представлений, которая упорядочивает представления линейно.

Просмотреть атрибуты

Атрибуты android:layout_width и android:layout_height определяют ширину и высоту представления. Значение match_parent растягивает представление до ширины или высоты родительского элемента. Значение wrap_content сжимает представление до размеров его содержимого.
Атрибут android:text указывает текст, который должно отображать представление (если в этом представлении отображается текст). Для кнопок android:text — это метка кнопки.
Атрибут android:orientation в группе представлений LinearLayout упорядочивает содержащиеся в ней элементы представления. Значение horizontal упорядочивает представления слева направо. Значение vertical упорядочивает представления сверху вниз.
Атрибут android:layout_gravity определяет размещение представления и всех его дочерних элементов.
Атрибут android:textSize определяет размер текста в текстовом представлении. Размер текста указывается в единицах sp ( масштабируемых пикселях ). Используя единицы sp, можно изменять размер текста независимо от качества отображения устройства.

Струны

Вместо того чтобы жестко кодировать строки в макете, лучше всего использовать строковые ресурсы.
Строковые ресурсы содержатся в файле values/res/string.xml .
Для извлечения строк используйте Alt+Enter ( Option+Enter на Mac). В контекстном меню выберите «Извлечь строковые ресурсы» .

Использование представлений

Чтобы подключить код Kotlin к представлению, определенному в макете, необходимо получить ссылку на объект представления после его расширения. Присвойте представлению идентификатор ( android:id ) в макете, а затем используйте метод findViewById() для получения связанного объекта представления.
При создании идентификатора представления в XML-файле макета Android Studio создаёт целочисленную константу с именем этого идентификатора в сгенерированном классе R Затем вы можете использовать эту ссылку R.id в методе findViewById() .
Вы можете задать атрибуты объекта представления в коде Kotlin напрямую, указав имя свойства. Например, текст в текстовом представлении определяется атрибутом android:text в XML, а в Kotlin — свойством text .
Обработчик щелчков — это метод, который вызывается при щелчке или касании пользователем элемента пользовательского интерфейса. Чтобы прикрепить метод обработчика щелчков к представлению, например к кнопке, используйте метод setOnClickListener() .

Использование тостов

Всплывающее уведомление — это представление, которое показывает пользователю простое сообщение в небольшом всплывающем окне.

Чтобы создать тост, вызовите фабричный метод makeText() класса Toast с тремя аргументами:

Контекст приложения Activity
Сообщение для отображения, например строковый ресурс
Длительность, например Toast.LENGTH_SHORT

Чтобы отобразить тост, вызовите show() .

Курс Udacity:

Разработка приложений для Android с помощью Kotlin

Документация для разработчиков Android:

Другой:

Словарь слов и понятий

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

При необходимости задавайте домашнее задание.
Объясните учащимся, как следует сдавать домашние задания.
Оцените домашние задания.

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

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

Изменить приложение

Откройте приложение DiceRoller. Добавьте в приложение кнопку «Сброс», которая будет располагаться прямо под кнопкой «Бросить» . Эта кнопка должна сбрасывать текстовое поле результата на 0.

Ответьте на эти вопросы

Вопрос 1

Какой метод Activity расширяет макет приложения и делает его представления доступными в качестве объектов?

onCreate()
setClickListener()
setContentView()
show()

Вопрос 2

Какой атрибут представления используется для установки ширины представления, чтобы оно подстраивалось под содержимое?

android:view_width="wrap"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_width="match_parent"

Отправьте свое приложение на оценку

Проверьте, что приложение имеет следующее:

Макет приложения должен включать одно текстовое поле и две кнопки.
Код приложения должен установить два обработчика щелчков, по одному для каждой кнопки.
Обработчик щелчков, который сбрасывает текстовое представление, должен установить свойство текста на 0.

Начните следующий урок: 1.3 Ресурсы изображений и совместимость

Ссылки на другие практические занятия по этому курсу см. на целевой странице практических занятий по основам Android Kotlin .