Как сделать многоэкранное приложение в android studio

Добавил пользователь Евгений Кузнецов
Обновлено: 10.09.2024

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

Уроки Android Studio для начинающих

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

В данном уроке речь пойдет о том, как установить и настроить среду Android Studio, а также её вспомогательный компонент – JDK.
Разбор структуры проекта. Создание ADV-эмулятора и простого приложения для ОС Андроид.
Из каких элементов состоят android-приложения? Что такое View, Activity и Layout? Узнаем в данном уроке.
Учимся работать с XML-файлами макетов для android, а также говорим о вертикальном и горизонтальном видах приложений.
В данном видео уроке мы рассмотрим свойства двух основных контейнеров для группировки – RelativeLayout и LinearLayout.
Еще один контейнер для табличной компоновки элементов приложения андроид.
Какими параметрами обладают различные элементы андроид-приложений? Смотрим и запоминаем.
Как манипулировать различными view-элементами, используя код на языке Java.
3 различных способа обработки данных от нажатия на кнопку в приложении.
Как задать один способ обработки для нескольких кнопок android-приложения.
В данном уроке мы узнаем какие типы ресурсов бывают и как взаимодействовать с ними из приложения.

Урок 1 - Установка Android Studio
Урок 2 - Создание первого приложения для Android
Урок 3 - Элементы приложений
Урок 4 - Файл макета приложения
Урок 5 - Виды компоновки элементов (Layout)
Урок 5 (Часть 2) - Виды компоновки элементов (TableLayout)
Урок 6 - Элементы Android-приложений (Настройки)
Урок 7 - Управление View-элементами с помощью Java
Урок 8 - Способы обработки нажатий кнопки в приложении
Урок 9 - onclickListener для группы кнопок
Урок 10 - Работа с ресурсами в приложении
Урок 11 - LogCat, логи приложения. Исключения (Exception) - обработка ошибок в коде
Урок 12 - Меню в Андроид - добавление пунктов меню, обработка нажатия
Урок 13 - Menu Android? добавляем иконки и чекбоксы, программно добавляем и скрываем пункты меню
Урок 14 - Создаем контекстное меню для экранных компонентов в андроид приложениях
Урок 15 - Программное создание экрана в андроид приложениях. LayoutParams
Урок 16 - Cоздание и удаление элементов экрана в процессе работы андроид-приложения
Урок 17 - Динамически меняем параметры элементов экрана в андроид-приложении
Урок 18 - Делаем приложение? калькулятор для андроид
Урок 19 - Анимация компонентов экрана андроид-приложения
Урок 20 - Добавление Activity - cоздание многоэкранных приложений
Урок 21 - Что такое Intent, Intent Filter, Context
Урок 22 - Жизненный цикл активити (Activity Lifecycle)
Урок 23 - Activity Lifecycle - взаимодействие двух активити
Урок 24 - Task и BackStack активити андроид-приложений
Урок 25 - Как вызвать другое Activity из приложения через Action и Intent Filter
Урок 26 - Создаем в одной Activity несколько Action для Intent и Intent Filter
Урок 27 - Передаем данные между Activity используя Intent Extras
Урок 28 - Вызов второго Activity с возвращением данных
Урок 29 - Используем requestCode и resultCode в onActivityResult
Урок 30 - Вызываем браузер, звонилку, карты с помощью intent с атрибутом data – Uri
Урок 31 - Создаем простое приложение - интернет браузер для андроид
Урок 32 - SharedPreferences - сохранение данных в приложениях

Базовый курс по Adobe Lightroom Полноценный курс видеоуроков для осваивающих Adobe Lightroom. Раскрывает возможности программы, подробно разбирает каждый инструмент и особенности его влияния на изображение. Прекрасно подойдёт начинающим пользователям.

Видео уроки по Sweet Home 3D Подробный видеокурс по функциональному редактору трехмерных интерьеров. Доходчиво объяснит принцип планировки и дизайна помещений. Научит пользоваться программой на уровне продвинутого пользователя.

Уроки рисования в Paint Tool SAI Девять детальных видеоуроков для тех, кто изучает графический редактор Paint Tool SAI. Прекрасно структурированная подача информации позволит освоить программу даже новичку, а опытному пользователю – улучшить свои знания и навыки.


Android Studio Создание программ, Интегрированные среды разработки


Visual Studio 2013 Создание программ, Интегрированные среды разработки, Визуальные среды разработки


Cocos 2D-X Создание игр, 2D движки, Мобильные игры


Adobe Photoshop Lightroom CC Графические редакторы, Фоторедакторы

Класс Acitvity является важнейшим компонентом Android-приложения, а способ запуска и компоновки является фундаментальной частью платформы Android. В отличие от парадигм программирования, где приложение запускается в методе main(), система Android инициирует код в экземпляре Activity, вызывая специальные коллбэки, которые соответствуют конкретным этапам жизненного цикла активности (подробнее о жизненном цикле активности будет сказано ниже).


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

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

Есть различные разновидности активностей, хотя все они так или иначе являются наследниками базового класса Activity. Например, если используется библиотека поддержки, то при создании нового проекта Android Studio генерирует класс MainActivity, который наследует от AppCompatAcitivty. Если посмотреть иерархию наследования, то в результате можно увидеть, что в начале этой иерархии будет находиться класс Activity.


Активность представляет собой окно, в котором приложение рисует свой UI. Это окно обычно полностью заполняет экран, но может быть меньше экрана или находиться поверх других окон. Как правило, одна активность представляет собой один экран в приложении. Например, одна активность может реализовывать окно настроек, в то время как другая — окно с выбором фото.

Большинство приложений имеют несколько экранов, из чего можно сделать вывод, что они содержат несколько активностей. Как правило, одна из активностей определяется как главная и является первым экраном, появляющимся при запуске пользователем приложения. Затем каждая активность может запустить другую активность для выполнения каких-либо действий. На примере Gmail можно увидеть, что главной активностью является экран со списком писем. Из этой активности можно запустить активность, которая отвечает за создание и отправку новых писем, или любую другую.

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

Рассмотрим на примере, как добавить в приложение новую активность. Создадим в Android Studio новый пустой проект. По умолчанию, в приложении создаётся одна главная активность, называемая MainActivity. При этом в проекте происходят следующие действия.

Создаётся одноимённый класс MainActivity.java. В этом классе будет реализовываться вся работа активности, при создании в ней уже есть переопределённый метод onCreate() и загрузка разметки активности.

Как уже говорилось выше, метод setContentView() загружает разметку активности. Эта разметка берётся из XML-файла, который размещается в /res/layout. При создании проекта там уже находится сгенерированный файл activity_main.xml, идентификатор которого и передаётся в параметры setContentView(). Как правило, идентификатор идентичен названию файла. Если заглянуть в этот файл, то можно увидеть там TextView с надписью Hello World!, размещённое в центре экрана. Таким образом, то, что будет в коде этого файла, и увидит пользователь при запуске активности, для которой эта разметка установлена.

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

  • android.intent.action.MAIN — сообщает системе о том, что данная активность является главной.
  • android.intent.category.LAUNCHER — сообщает системе о том, что приложение должно показываться в списке приложений.

Вот всё, что нужно для того, чтобы создать активность. Подводя итог, можно сказать, что для создания активности Android Studio выполняет 3 шага:

Ничто не мешает разработчику выполнять эти шаги вручную, однако намного проще воспользоваться возможностями Android Studio, которая в разы ускоряет этот процесс. Допустим, нам понадобилось добавить в проект вторую активность. Для того, чтобы добавить новую активность нужно в контекстном меню выбрать New — Activity. В списке будет предложено выбрать несколько активностей с уже готовыми компонентами (например, активность с настройками). Чтобы создать активность без лишних компонентов, нужно выбрать Empty Activity.


Откроется окно, в котором будет предложено ввести название новой активности и название XML-файла разметки.


Жмём Finish и видим, что Android Studio добавила все необходимые файлы для активности.


Как можно было заметить, при создании активности в коде класса добавляется переопределённый метод onCreate(). Этот метод вызывается, когда активность начинает свою работу, и соответствует началу жизненного цикла активности.

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

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

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

Для навигации между этапами жизненного цикла активности класс Activity предоставляет базовый набор из шести коллбэков: onCreate(), onStart(), onResume(), onPause(), onStop() и onDestroy(). Система вызывает каждый из этих коллбэков как только активность переходит в новое состояние.


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

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

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

Во время деинициализации наоборот нужно выполнить всю работу и только потом вызвать суперкласс:

onCreate()

Этот метод обратного вызова срабатывает, когда система создаёт активность. Его наличие обязательно, поскольку здесь выполняется первоначальная настройка активности. В этом методе активность переходит в состояние Created. В методе onCreate() нужно выполнять основную логику запуска, которая должна выполниться только один раз. Например, реализация onCreate() может привязать данные к спискам, ассоциировать активность с ViewModel и создать экземпляры некоторых переменных. Этот метод принимает в качестве параметра savedInstanceState, который представляет собой объект Bundle, содержащий ранее сохраненное состояние активности. Если активность ранее не существовала, значение объекта Bunde будет равно null.

После того, как onCreate() завершит выполнение, активность переходит в состояние Started и система следом вызывает onStart() и onResume().

onStart()

Когда активность переходит в состояние Started, система вызывает этот метод. Вызов onStart() делает активность видимой для пользователя, так как приложение готовится к переходу активности на передний план и становится интерактивной. Например, здесь можно реализовывать код, который будет поддерживать пользовательский интерфейс.

Метод onStart() завершается очень быстро и, как и с onCreate(), активность не остаётся в состоянии Started, а переходит в состояние Resumed, после чего система вызывает метод onResume().

onResume()

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

Когда происходит событие, прерывающее текущее состояние, активность переходит в состояние Paused и система вызывает метод onPause().

onPause()

Метод onPause() является первым признаком того, что пользователь покидает активность. Это не всегда означает, что активность уничтожается, она просто перестаёт находиться на переднем плане (хотя может оставаться видимой, если пользователь находится в многооконном режиме). Метод onPause() следует использовать для приостановки или регулирования операций, которые не должны продолжаться пока активность находится в состоянии Paused и ожидает возобновления. Существует несколько причин, по которым активность может войти в это состояние:

  • Некоторые события прерывают выполнение приложения, как описано в части про onResume(). Это самый распространенный случай.
  • В Android 7.0 (API 24) или выше несколько приложений могут работать в многооконном режиме. Поскольку только одно из приложений имеет фокус в момент времени, система приостанавливает работу всех других приложений.
  • Открывается новая полупрозрачная активность (например, диалог). Пока активность ещё частично видимо, но не в фокусе, она остаётся приостановленной.

Метод onPause() можно также использовать для освобождения системных ресурсов, регулирования сенсоров или любых других ресурсов, которые могут влиять на расход батареи, пока активность приостановлена. Однако, как уже говорилось, активность в состоянии Paused может быть ещё частично видимой, поэтому лучше всего использовать для освобождения ресурсов onStop() вместо onPause().

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

Завершение метода onPause() не означает, что активность выходит из состояния Paused. Скорее активность останется в этом состоянии до тех пор, пока не возобновится или не станет полностью невидимой для пользователя. Если активность возобновляется, система снова вызывает метод onResume(). Если активность возвращается из состояния Paused в состояние Resumed, система сохраняет экземпляр Activity в памяти, вызывает его в методе onResume(). В этом случае не нужно повторно инициализировать компоненты, созданные ранее. Если активность становится полностью невидимой, система вызывает метод onStop().

onStop()

Когда активность больше не видна пользователю, она переходит в состояние Stopped, и система вызывает метод onStop(). Это может произойти, например, когда вновь запущенная активность охватывает весь экран. Система также может вызвать onStop(), когда активность завершила свою работу и вот-вот будет уничтожена.

В методе onStop() приложение должно освобождаться или регулировать ресурсы, которые не нужны, пока приложение не отображается пользователю. Например, приложение может приостановить анимацию или переключиться с более детального на менее детальное обновление местоположения. Использование onStop() вместо onPause() гарантирует, что работа, связанная с UI, продолжится, даже если пользователь просматривает активность в многооконном режиме.

onStop() также следует использовать для выполнения относительно затратных в плане расхода CPU операций. Например, если не удается найти более подходящее время для сохранения информации в базе данных, это можно сделать в onStop().

Когда активность переходит в состояние Stopped, экземпляр Activity сохраняется в памяти: он содержит всю необходимую информацию, но не привязан к менеджеру окон. Поэтому при восстановлении не нужно заново инициализировать все компоненты. Система также отслеживает текущее состояние для каждого объекта View в разметке, поэтому, если пользователь вводит текст в виджет EditText, то этот контент сохранится и затем восстановится.

Примечание: Как только активность окажется остановленной, система может уничтожить процесс, который содержит активность, чтобы чтобы освободить память для своих нужд. Даже если система уничтожит процесс, она продолжает сохранять состояния объектов View (например, текст в EditText) в Bundle (парах «ключ-значение«) и восстанавливать их, когда пользователь возвращается в активность.

В состоянии Stopped активность либо возвращается для взаимодействия с пользователем, либо полностью завершается. Если активность возвращается, система вызывает onRestart(). Если активность завершается, система вызывает метод onDestroy().

onDestroy()

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

  • Активность завершает свою работу поскольку пользователь закрывает активность либо в приложении вызывается метод finish().
  • Система временно уничтожает активность из-за изменения конфигурации (например, поворот устройства или использование многооконного режима).

Если активность прекращает работу, то onDestroy() — это последний коллбэк жизненного цикла активности. Если onDestroy() вызывается в результате изменения конфигурации, система немедленно создаёт новый экземпляр активности и затем вызывает onCreate() в новом экземпляре.

Метод onDestroy() освобождает все ресурсы, которые ещё не были освобождены в методах ранее, такими как onStop().

Активность и её жизненный цикл : 4 комментария

Почему забыли про onSaveBundleInstanceState() ?

Потому что этот метод не является метод жизненного цикла

Спасибо. Из десяток статей эта лучшая (для новичка)

Реально куча сайтов перечитала и ваше объяснение самое понятное для новичков! Спасибо огромное! Наконец-то в программе все работает!

Наше новое приложение на Android поможет решить незамысловатую задачу – куда поехать в отпуск. Нажимаем кнопку. и смартфон за нас определяет, в какую страну стоить полететь.


Почему на Kotlin? Потому что простой и современный.

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

Новый проект

Для начала создаем новый проект. Если у вас уже открыт Android Studio – выбираем File – New – New Project.



Выбираем Basic Activity. Жмем Next. Название приложения – Traveling. Не забываем выбрать Language – Kotlin. Минимальный API – 14. Жмем Finish. Готово, у вас открылся новый проект. В нем уже есть одно окно.


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


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

Несмотря на то, что мы будем использовать Kotlin для создания приложения – папка называется java. Это не должно вас запутать.

Первые настройки

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

Пока что наше приложение пустое, тем не менее, мы применим первую настройку для него. Добавим в AndroidManifest.xml такую строку:


Если она уже есть – отлично. Когда вы добавили эту настройку – соберите приложение и запустите его (на эмуляторе либо смартфоне). Попробуйте повернуть телефон – экран не будет поворачиваться, потому что используется настройка из файла AndroidManifest.xml

Gradle


Открываем слева раздел Gradle scripts и выбираем build.gradle (Module:app). Здесь мы можем увидеть стандартный набор для компиляции и другую дополнительную информацию:


Apply plugin. Эта команда применяет plugin-ы. В нашем случае добавляет поддержку kotlin (apply plugin: 'kotlin-android').

Android – здесь устанавливаются настройки на какой версии API будет работать приложение. (targetSdkVersion 28)

Dependencies – зависимости. Здесь можно добавить внешние библиотеки. В нашем случае строка 'com.android.support:appcompat-v7:28.0.0' означает совместимость приложения с более старыми API.


Устанавливаем внешние библиотеки

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

В нашем случае мы добавим анимацию картинки с помощью сторонней библиотеки. Для этого находим раздел dependencies в build.gradle (Module:app). Добавляем туда такой код:

Должно получиться так:


Android Studio автоматически поймет, что вы подключаете сторонние библиотеки и предложит их скачать и установить. Появится кнопка Sync Now. Нажмите ее. Библиотеки установлены.

Добавляем изображение

Загружать картинку в наше приложение мы будем немного другим способом, нежели в прошлой статье.

На Android-устройствах может применяться различное разрешение экрана. Чтобы картинки не растягивались и не сжимались, в зависимости от разрешения их можно загружать в нескольких версиях (mdpi, hdpi, xhdpi, xxhdpi, xxxhdpi). Самая распространенная сейчас xxhdpi. Эту версию картинки мы и загрузим в наше приложение.

Переключаемся в режим отображения Project и идем в app – src – main – res. Правой кнопкой мыши нажимаем на папке res и выбираем New - Android resource directory. В открывшем окне вверху выбираем drawable. Слева выбираем density и жмем >>. Далее из выпадающего меню выбираем XX-High Density и жмем OK.


После этого скачайте картинку ниже и назовите ее img_earth.jpg


Уже на компьютере скопируйте ее в буфер обмена (CTRL + C). Затем щелкните на папке drawable-xxhdpi и нажмите CTRL + V.


Появится окно с предложением добавить картинку в ваш проект. Жмите ОК. Картинка успешно добавлена.

Устанавливаем значения

Как профессиональные программисты мы определим некоторые значения в отдельных файлах.

Для этого откроем файл strings.xml (находится в папке res - values). В него добавим такой код:

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

Теперь откроем файл dimens.xml (находится в res - values) и добавим следующий код:

Здесь мы устанавливаем размер текста. Все что касается размеров – лучше прописывать в отдельный файл.

Создаем интерфейс

Теперь откроем файл content_main.xml (папка res - layout) и полностью заменим его содержимое на следующий код:

После этого переключитесь в режим Design. Вы увидите интерфейс нашего приложения. С помощью кода выше мы его построили. Общий блок ConstraintLayout вмещает в себя все элементы: 2 строки текста TextView, кнопка Button и картинка ImageView (с анимацией).


На этом этапе уже можно запустить приложение. Жмем Run app.

Вы увидите интерфейс, но кнопка все еще не работает. Пора сделать ее интерактивной!


Подключаем код

Писать код (на Kotlin) мы будем здесь app – java – com.example.traveling. Там откроем MainActivity.kt

После строк import … добавляем код:

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

Дальше добавляем код, чтобы в итоге Mainactivity выглядел так:

Что мы сделали по пунктам:

  1. Вызвали суперкласс.
  2. Определили, чтобы вызывался основной layout
  3. Определили значения 3 переменных, заданных ранее. Взяли id из ранее созданных файлов интерфейса.
  4. Повесили на кнопку (Button) простую функцию.
  5. Генерируем случайное выбор из массива стран – функция кнопки.
  6. Используем стороннюю библиотеку (мы ее подключили с помощью Gradle) для создания анимации картинки. Устанавливаем тип эффекта и длительность. Полный список эффектов есть тут. Можете выбрать свой.

Все почти готово! Жмем Build и Run App. У нас получается уже работающее приложение.


Кнопка работает и показывает, в какую страну мы едем.

Портит вид лишь розовый значок почты внизу справа. Он нам не нужен. Для того, чтобы его удалить, нужно зайти в res – layout и открыть activity_main.xml.

Вот этот блок нужно очистить:

Все! Теперь ненужная кнопка удалена.

Вот как выглядит приложение уже на смартфоне.


Logcat


Должно получиться так:



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

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