Android как делать свои компоненты в ide

Обновлено: 07.07.2024

Это будет серия постов на тему создания пользовательского view компонента для Android. Я покажу как нарисовать содержимое компонента, как работают layouting и measuring, как реализовать view groups и как анимировать содержимое компонента. В этом посте я объясню, как расширить стандартный view, как его использовать и как создать свои собственные xml атрибуты.

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

Предположим, вы работаете над приложением, которое содержит статистику тренировок пользователя. Например, общая дистанция, общее время и так далее, в зависимости от типа тренинга. Для того чтобы отображать данные в удобном виде, вы решили их адаптировать, основываясь на их продолжительности. Если это 2378 секунд, вы хотите отображать это время как "40 минут", а если это 18550 секунд, то лучше было бы отображать на дисплей "5 часов 9 минут".

Один из способов решения этой задачи - создать специализированный view, который будет должным образом обрабатывать ваш текст. Давайте начнем с создания нашего собственного класса DurationTextView, который будет расширять класс TextView.

TextView, как и все view классы, имеет три различных конструктора: первый просто принимает контекст (Context), второй принимает контекст и набор атрибутов (AttributeSet), а третий еще дополнительно принимает стиль "по умолчанию". В большинстве случаев вам достаточно реализовать второй конструктор, который показан выше.

Теперь мы создали view и чтобы его использовать, мы добавим его в файл разметки:

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

В данный момент этот класс практически идентичен стандартному TextView, поэтому давайте добавим ему некоторую функциональность.

Поскольку этот view будет отображать длительность, давайте добавим метод setDuration().

Что делает этот метод? Он получает значение длительности, переводит его в текстовую строку в определенном формате, используя некую логику, а затем выводит с помощью метода setText(). В данном случае логика заключается в переводе секунд в минуты и дальнейшем разделении на часы и минуты. Также в методе присутствует логика для корректного отображения одной минуты: "1 minute" вместо "1 minute(s)".

В конце метода отформатированное время преобразуется в строку с помощью шаблона.

private static final String TEMPLATE = "Duration: <strong>%s</strong>";

Шаблон начинается со слова "Duration", а далее жирными буквами отображается отформатированная строка.

Для простоты я использовал в коде строковые литералы. В нормальном коде, эти строковые литералы лучше перенести в strings.xml, это позволяет в дальнейшем локализовать их.

Попробуем использовать наш view. В xml файл разметки добавим 5 custom View.

А в activity в методе onCreate() после метода setContentView() добавим следующие строки.

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

Если бы мы могли задавать шаблон, то созданный нами компонент был бы более универсальным. По идее можно добавить метод, который позволит нам устанавливать шаблон, однако это не так просто. Если подумать, длительности нам нужно устанавливать динамически, а шаблон скорее всего будет все время одинаковым. Поэтому вместо метода, давайте добавим нашему custom view новые xml атрибуты.

В первую очередь нужно создать в папке values файл attrs.xml, где мы сможем определить атрибуты. Для этого view мы добавим один атрибут - template типа string. Выглядеть это будет так:

Мы записали тег declare-styleable и задали имя TemplateTextView. Имя может быть произвольным, но обычно задают имя, совпадающее с именем view. В данном случае я не задаю имя DurationTextView, потому что планирую использовать template атрибут еще в другом view.

Далее мы определили новый атрибут, установив ему имя template и формат string. Помимо string существует множество других форматов, например, Color, Integer, Boolean, Reference и так далее.

Использовать новый атрибут в layout xml можно так.

Обратите внимание, в корневом элементе мы добавляем такую строчку.

xmlns:app= "http://schemas.android.com/apk/res-auto"

Это позволяет нам использовать атрибуты, которые определены в файле attrs.xml, в нашем layout. В данном случае мы задали префикс "app", хотя он может быть произвольным.

Для того чтобы использовать новый атрибут, нужно получить его значение в нашем custom view. Сначала заменяем приватную статическую константу "TEMPLATE" переменной "template". Затем добавляем в наш конструктор следующий код.

В первой строке мы получаем набор атрибутов, который содержит все атрибуты, существующие в xml файле. Метод obtainStyledAttributes() делает две основные вещи. Во-первых, он фильтрует все атрибуты из attrs с помощью контекста, применяет стили и resolves reference to values. Во-вторых, он возвращает только те атрибуты, которые вы определили. Они задаются вторым аргументом, который представляет собой массив ссылок на требуемые атрибуты. В данном случае в R.styleable.TemplateTextView у нас только один атрибут R.attr.template, который мы создали в файле attrs.xml.

Далее мы используем массив attributes, чтобы получить значение атрибута. Если значение шаблона не было определено или не содержит "%s", мы устанавливаем template = "%s". И в заключении нужно не забыть освободить ресурсы с помощью функции recycle().

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

Здесь я установил шаблон для первых трех custom view

Большая часть view в Android имеет методы, которые позволяют устанавливать значения XML атрибутов в коде. Возможно вам тоже понадобиться добавить какой-нибудь метод, это зависит от того, как вы будете использовать view.

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

Исходники к статье можно скачать c GitHub.
По материалам сайта Jayway
Вольный перевод - Pavel Bobkov.

На прошлом уроке мы создавали компоненты в методе Activity.onCreate, т.е. при создании приложения. На этом уроке будем создавать уже в работающем приложении. Создавать будем Button-ы, т.к. они наглядней всего отображаются. Будем указывать текст, который будет отображен на кнопке и выравнивание: слева, по центру или справа. Также предусмотрим возможность удаления созданных элементов.

Project name: P0171_DynamicLayout2
Build Target: Android 2.3.3
Application name: DynamicLayout2
Package name: ru.startandroid.develop.dynamiclayout2
Create Activity: MainActivity

Создадим экран, который поможет нам создавать View-компоненты. Открываем main.xml и пишем там следующее:

Рассмотрим подробно экран.

rgGravity – это RadioGroup, с тремя RadioButton (rbLeft, rbCenter, rbRight). Этот компонент мы используем для выбора выравнивания создаваемого компонента
etName – текстовое поле, здесь будем указывать текст, который будет отображаться на созданном компоненте
btnCreate – кнопка, запускающая процесс создания.
btnClear – кнопка, стирающая все, что создали
llMain – вертикальный LinearLayout, в котором будут создаваться компоненты

Экран готов, давайте кодить реализацию. Открываем MainActivity.java. Начнем с того, что опишем и найдем все необходимые нам компоненты. Кстати, у нас есть пара кнопок, которые мы будем использовать, значит им нужен обработчик. В качестве обработчика назначим Activity (т.е. необходимо дописать: implements OnClickListener) и создадим пустой пока метод обработки onClick:

Я также создал переменную wrapContent и буду хранить в ней значение LinearLayout.LayoutParams.WRAP_CONTENT. Делаю это только для снижения громоздкости кода.

Теперь опишем процесс создания Button-компонента заполнив метод onClick:

Разберем написанное. Для начала мы проверяем, что была нажата кнопка btnCreate – т.е. кнопка создания. Затем создаем LayoutParams с высотой и шириной по содержанию. Здесь я использовал переменную, про которую писал выше – wrapContent. Иначе получилось бы довольно громоздко.

Далее создаем переменную btnGravity, в которую по умолчанию запишем значение выравнивания LEFT. Для определения, какой RadioButton выделен в данный момент, используем метод getCheckedRadioButtonId – он для RadioGroup возвращает ID «чекнутого» RadioButton-а. Мы его сравниваем с нашими тремя ID и заносим соответствующее значение в переменную btnGravity. Скидываем это значение в gravity у LayoutParams.

Далее создаем кнопку и присваиваем ей текст из etName. Обратите внимание, что недостаточно написать getText, т.к. это не даст текста. Необходимо еще вызвать метод toString. Ну и в конце добавляем созданный Button в наш LinearLayout.

Сохраним все и запустим приложение. Добавим несколько кнопок.

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

Осталось нереализованной кнопка Clear, которая призвана удалять все созданное. Для этого нам необходимо дополнить метод onClick, добавим в switch ( v.getId ()) еще один case:

В итоге у нас получилось очень даже динамическое приложение, которое умеет менять само себя.

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

1) При создании вы можете сами присваивать компонентам ID. Это делается методом setId . И потом по этим ID просто вызываете findViewById.

2) Вы можете сохранять созданные компоненты в свой массив или список. Либо можете воспользоваться методом getChildAt. Вызов этого метода для llMain позволит получить его дочерние компоненты по индексу. Получить кол-во дочерних элементов позволит метод getChildCount.

Полный код урока:

На следующем уроке:

- изменяем layout-параметры для уже существующих компонентов экрана

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

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

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

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

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

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

Я потратил довольно много времени на его реализацию. К счастью, этот Custom View-компонент можно использовать и в других проектах, поэтому чтобы сэкономить личное время и время других разработчиков, я решил оформить всё это дело в виде библиотеки. Если вам нужен похожий функционал и не хватает времени на его реализацию собственными силами, можете взять его с этого GitHub репозитория.

Рисуем!

Так как в большинстве случаев разработка Custom View-комопонента занимает больше времени, чем работа с обычными View-компонентами, создавать их целесообразно только тогда, когда нет более простого способа реализовать специфичную особенность, или когда у вас есть ниже перечисленные проблемы, которые Custom View-компонент может решить:

Производительность. Если у вас есть много View-компонентов в одном layout-файле и вы хотите оптимизировать это с помощью создания единственного Custom View-компонента;
Большая иерархия View-компонентов, которая сложна в эксплуатации и поддержке;
Полностью настраиваемый View-компонент, которому нужна ручная отрисовка;

Если вы ещё не пробовали разрабатывать Custom View, то эта статья - отличная возможность окунуться в эту тему. Здесь будет показана общая структура View-компонента, как реализовывать специфичные вещи, как избежать распространённые ошибки и даже как анимировать ваш View-компонент!

Первая вещь, которую нам нужно сделать, это погрузиться в жизненный цикл View. По какой-то причине Google не предоставляет официальную диаграмму жизненного цикла View-компонента, это довольно распространённое среди разработчиков непонимание, поэтому давайте рассмотрим её.

Constructor

Каждый View-компонент начинается с Constructor'а. И это даёт нам отличную возможность подготовить его, делая различные вычисления, устанавливая значения по умолчанию, ну или вообще всё что нам нужно.

Но для того чтобы сделать наш View-компонент простым в использовании и установке, существует полезный интерфейс AttributeSet. Его довольно просто реализовать и определённо стоит потратить на это время, потому что он поможет вам (и вашей команде) в настройке вашего View-компонента с помощью некоторых статических параметров на последующих экранах. Во-первых, создайте новый файл и назовите его "attrs.xml". Этот файл может содержать все атрибуты для различных Custom View-компонентов. Как вы можете видеть в этом примере есть View-компонент названный PageIndicatorView и один атрибут piv_count.

Во-вторых, в конструкторе вашего View-компонента, вам нужно получить атрибуты и использовать их как показано ниже.

При создании кастомных атрибутов, добавьте простой префикс к их имени, чтобы избежать конфликтов имён с другими View-компонентами. Обычно добавляют аббревиатуру от названия View-компонента, поэтому у нас префикс "piv_";
Если вы используете Android Studio, то Lint будет советовать вам использовать метод recycle() до тех пор пока вы сделаете это с вашими атрибутами. Причина заключается в том, что вы можете избавиться от неэффективно связанных данных, которые не будут использоваться снова;

onAttachedToWindow

После того как родительский View-компонент вызовет метод addView(View), этот View-компонент будет прикреплён к окну. На этой стадии наш View-компонент будет знать о других View-компонентах, которые его окружают. Если ваш View-компонент работает с View-компонентами пользователя, расположенными в том же самом "layout.xml" файле, то это хорошее место найти их по идентификатору (который вы можете установить с помощью атрибутов) и сохранить их в качестве глобальной ссылки (если нужно).

onMeasure

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

При переопределении этого метода, всё что вам нужно сделать, это установить setMeasuredDimension(int width, int height).

При настройке размера Custom View-компонента вы должны обработать случай, когда у View-компонента может быть определённый размер, который пользователь (прим. переводчика: программист работающий с вашим View-компонентом) будет устанавливать в файле layout.xml или программно. Для вычисления этого свойства, нужно проделать несколько шагов:

Рассчитать размер необходимый для содержимого вашего View-компонента (ширину и высоту);
Получить MeasureSpec вашего View-компонента (ширину и высоту) для размера и режима;
Проверить MeasureSpec режим, который пользователь устанавливает и регулирует (для ширины и высоты);

Посмотрите на значения MeasureSpec:

MeasureSpec.EXACTLY означает, что пользователь жёстко задал значения размера, независимо от размера вашего View-компонента, вы должны установить определённую ширину и высоту;
MeasureSpec.AT_MOST используется для создания вашего View-компонента в соответствии с размером родителя, поэтому он может быть настолько большим, насколько это возможно;
MeasureSpec.UNSPECIFIED - на самом деле размер обёртки View-компонента. Таким образом, с этим параметром вы можете использовать желаемый размер, который вы расчитали выше.

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

onLayout

Этот метод позволяет присваивать размер и позицию дочерним View-компонентам. У нас нет дочерних View-компонентов, поэтому нет смысла переопределять этот метод.

onDraw

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

Создавая Custom View-компонент, всегда учитывайте, что вызов onDraw занимает довольно много времени. При каких-то изменениях, сроллинге, свайпе вы будете перерисовывать. Поэтому Andorid Studio рекомендует избегать выделение объекта во время выполнения onDraw, вместо этого создайте его один раз и используйте в дальнейшем.

При отрисовке, имейте в виду переиспользование объектов вместо создания новых. Не полагайтесь на вашу IDE, которая должна подсветить потенциальную проблему, а сделайте это самостоятельно, потому что IDE может не увидеть этого, если вы создаёте объекты внутри методов вызываемых в onDraw;
Во время отрисовки, не задавайте размер прямо в коде. Обрабатывайте случай, когда у других разработчиков может быть тот же самый View-компонент, но с другим размером, поэтому делайте ваш View-компонент зависимым от того размера, который ему присвоен;

View Update

Из диаграммы жизненного цикла View-компонента, вы можете заметить что существует два метода, которые заставляют View-компонент перерисовываться. Методы invalidate() и requestLayout() могут помочь вам сделать ваш Custom View-компонент интерактивным, что собственно поможет изменять его внешний вид во время выполнения. Но почему их два?

Метод invalidate() используется когда просто нужно перерисовать View-компонент. Например, когда ваш View-компонент обновляет свой текст, цвет или обрабатывает прикосновение. Это значит, что View-компонент будет вызывать только метод onDraw, чтобы обновить своё состояние.

Метод requestLayout(), как вы можете заметить будет производить обновление View-компонента через его жизненный цикл, только из метода onMeasure(). А это означает, что сразу после обновления View-компонента вам нужно его измерить, чтобы отрисовать его в соответствии с новыми размерами.

Animation

Анимации в Custom View-компонентах, это по кадровый процесс. Это означает, что если вы например захотите сделать анимированным процесс изменения радиуса круга от маленького к большому, то вам нужно увеличивать его последовательно и после каждого шага вызывать метод invalidate для отрисовки.

Ваш лучший друг в анимации Custom View-компонентов - это ValueAnimator. Этот класс будет помогать вам анимировать любые значения от начала до конца и даже обеспечит поддержку Interpolator (если нужно).

Не забывайте вызывать метод Invalidate каждый раз, когда изменяется значение анимации.

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

Есть несколько способов подойти к разработке Android, но, безусловно, самый официальный и эффективный – использовать Android Studio. Это официальная IDE (интегрированная среда разработки) для платформы Android, разработанная Google и используемая для создания большинства приложений, которые вы, вероятно, используете ежедневно.

Android Studio была впервые анонсирована на конференции Google I / O в 2013 году и была выпущена для широкой публики в 2014 году после различных бета-версий. До его выпуска разработка Android выполнялась преимущественно с помощью Eclipse IDE, которая является более общей Java IDE, которая также поддерживает множество других языков программирования.

Android Studio значительно упрощает жизнь по сравнению с неспециализированным программным обеспечением, но еще предстоит пройти небольшой путь, прежде чем она сможет претендовать на то, чтобы стать полностью интуитивно понятным и плавным. Для новичков здесь есть чему поучиться, и большая часть информации, доступной – даже по официальным каналам, – либо устарела, либо слишком объемна, чтобы понять ее.

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

Так что же такое Android Studio?

Те из вас, у кого нет опыта программирования, все еще могут задаться вопросом, какова роль Android Studio, когда дело касается разработки… что такое IDE?

Таким образом, работа Android Studio как IDE заключается в том, чтобы предоставить вам интерфейс для создания ваших приложений и выполнять большую часть сложного управления файлами за кулисами. Вы будете использовать язык программирования Java или Kotlin., Если вы выберете Java, она будет установлена на вашем компьютере отдельно. Android Studio – это просто место, где вы будете писать, редактировать и сохранять свои проекты и файлы, составляющие указанные проекты. В то же время Android Studio предоставит вам доступ к Android SDK или «Software Development Kit». Думайте об этом как о расширении кода Java, которое позволяет ему бесперебойно работать на устройствах Android и использовать преимущества встроенного оборудования. Java необходима для написания программ, Android SDK необходим для запуска этих программ на Android, а Android Studio должна собрать все это за вас. В то же время Android Studio также позволяет запускать код либо через эмулятор, либо через аппаратное обеспечение, подключенное к вашей машине. Затем вы также сможете «отлаживать» программу во время ее работы и получать отзывы, объясняющие сбои и т.д.

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

Настройка

Настройка Android Studio довольно проста и проще, чем когда-либо, благодаря тому, что почти все объединено в один установщик. Загрузите его здесь, и вы получите не только Android Studio, но также Android SDK, диспетчер SDK и многое другое. Единственное, что вам понадобится, это Java Development Kit, который вы можете скачать здесь. Помните: Android Studio – это только ваше окно в Java! Примечание. Android Studio и SDK довольно большие, поэтому перед началом работы убедитесь, что у вас есть свободное место на диске C: .

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

Выберите каталог для SDK, в котором нет пробелов. Обратите внимание, что папка AppData, которую здесь выбрала Android Studio, является скрытой папкой в Windows. Это означает, что вам нужно выбрать «Показать скрытые папки», если вы хотите перейти к нему с помощью проводника.

Запуск нового проекта

После того, как Android Studio будет запущена, вы захотите погрузиться в нее и создать новый проект. Вы можете сделать это, запустив Android Studio и выбрав «Новый проект», или вы можете в любой момент выбрать «Файл»> «Создать»> «Новый проект» в самой среде IDE.

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

Часто вы выбираете «Базовое действие», которое является стилем по умолчанию для нового приложения для Android. Это будет включать в себя меню в правом верхнем углу, а также кнопку FAB – Floating Action Button – выбор дизайна, который Google пытается поощрять. «Пустое действие» – это то же самое, но без добавления хрома.

Выберите вариант, который лучше всего подходит для приложения, которое вы собираетесь создать, и это повлияет на тип файлов, которые вам будут представлены при первом запуске. На этом этапе вы также сможете выбрать имя своего приложения, минимальный Android SDK, который вы хотите поддерживать, и имя пакета. Имя пакета – это окончательное имя файла, которое будет иметь приложение, когда вы загрузите его в Play Store, – сочетание имени приложения и имени разработчика.

Что это за файлы?

Я помню, что мое первое использование Android Studio (ну, Eclipse) было довольно сложным по сравнению с тем опытом программирования, который у меня был ранее. Для меня программирование означало ввод одного сценария, а затем запуск этого сценария. Тем не менее, Android-разработка отличается и включает в себя множество разных файлов и ресурсов, которые необходимо структурировать определенным образом. Android Studio раскрывает этот факт, поэтому трудно понять, с чего начать!

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

Однако фактический макет вашего приложения полностью обрабатывается другим фрагментом кода. Этот код представляет собой файл с именем activity_main.xml. XML – это язык разметки, который определяет макет документа, подобно HTML, который используется для создания веб-сайтов. Это не совсем «программирование», это своего рода код.

Итак, если вы хотите создать новую кнопку, вы должны сделать это, отредактировав activity_main.xml, и если вы хотите описать, что происходит, когда кто-то нажимает на эту кнопку, вы, вероятно, поместите это в MainActivity.Java. Чтобы немного усложнить задачу, вы можете использовать любой XML-файл для определения макета любого Java-скрипта (называемого классом). Это устанавливается прямо в верхней части вашего Java-кода со строкой:

Это просто означает, что Android Studio будет иметь макет, установленный в activity_main.xml. Это также означает, что теоретически можно использовать один и тот же XML-файл для задания макетов для двух разных классов Java.

А в некоторых случаях у вас действительно будет несколько XML-файлов, описывающих разные аспекты макета вашей деятельности. Если, например, вы выберете «Базовое действие» вместо «Пустое действие», тогда у вас будет activity_main.xml, который будет устанавливать положение FAB и других элементов пользовательского интерфейса, а также content_main.xml, в котором будет размещаться контент, который вы хотите добавить в в середине экрана. В конечном итоге вы можете добавить «представления» (такие элементы, как кнопки, текстовые поля и списки), и некоторые из них также могут иметь свои собственные макеты XML!

Найти свой путь

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

Новое пустое занятие, я люблю запах возможностей по утрам!

Если вы хотите открыть что-то новое, вы сможете сделать это через иерархию файлов слева. Здесь вы найдете все папки и папки внутри них. Ваши файлы Java размещаются под java, а затем под именем пакета вашего приложения. Дважды щелкните MainActivity.Java (при условии, что вы используете Java), и он выйдет на первый план в окне справа.

Когда вы редактируете файлы XML, вы можете заметить две вкладки внизу. Они позволяют переключаться между представлением «Текст» и «Дизайн». В текстовом представлении вы можете вносить изменения в код XML напрямую, добавляя и редактируя строки. В представлении «Дизайн» вы сможете добавлять, удалять и перетаскивать отдельные элементы по экрану и смотреть, как они будут выглядеть. В текстовом представлении также есть окно предварительного просмотра для визуализации того, что вы создаете – если ваш монитор достаточно широкий!

Больше типов файлов

Еще одна полезная папка – это папка res. Это сокращение от «ресурсы» и включает «чертежи» (изображения, которые вы будете размещать в своем приложении), а также «макет», в котором находятся ваши файлы XML. Все в папке ресурсов должно быть написано в нижнем регистре, поэтому подчеркивание часто используется для разделения имен файлов на читаемые заголовки в отсутствие верблюжьего регистра.

«Values» – это также полезная папка, в которой можно рыться. Она содержит больше файлов XML, в которых хранятся значения переменных – например, имена приложений и значения цвета.

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

You can create additional Java classes, XML files or entire activities at any point in order to add more functionality to your app. Simply right click on the relevant directory and then choose ‘New’ and then whatever it is you want to add. You can also open up the directory of your project by right clicking and choosing ‘Show in Explorer’. This is handy if you want to edit an image for example.

Meet Gradle

Android Studio tries to keep things nice and simple for users by providing all of the necessary tools and features in one place. Things only get more complicated once you need to interact with some of these other elements.

Например, вы могли заметить, что Android Studio иногда упоминает Gradle. Это «инструмент автоматизации сборки», который по сути помогает Android Studio превратить все эти разные файлы в один APK. Вы должны иметь возможность оставить Gradle делать свою работу большую часть времени, но иногда вам нужно будет переходить к файлам build.gradle, если вы хотите добавить новую «зависимость», позволяющую расширенные функции для вашего приложения. Иногда, если что-то перестает работать, вы можете выбрать «Сборка»> «Очистить проект», и это по сути подтвердит, где находятся все файлы и каковы их роли. Обычно таких файлов сборки Gradle будет два: один для всего проекта и один для «модуля» (приложения).

Отладка, виртуальные устройства и менеджер SDK

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

Запустить его на своем устройстве очень просто. Просто подключите его через USB, убедитесь, что вы разрешили USB-отладку и установку из неизвестных источников в настройках вашего телефона, а затем нажмите зеленую кнопку воспроизведения вверху или «Выполнить> Запустить приложение».

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

AVD Manager

Маловероятно, что вы когда-нибудь захотите разрабатывать для Android без какого-либо Android-устройства. Однако одна из самых больших проблем для разработчиков Android – это фрагментация. Другими словами: недостаточно того, чтобы ваше приложение работало на вашем устройстве, оно также должно работать на устройствах 10 и 15 дюймов. И он должен работать на устройствах, которые работают под управлением более старых версий Android или очень маломощны.

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

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

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

После того, как вы настроили несколько устройств для использования, вы сможете выбрать одно из них при запуске приложения и отладке точно так же, как на физическом устройстве. Однако обратите внимание, что для запуска виртуального устройства вам потребуются довольно приличные характеристики. Я не могу заставить его работать, например, на Surface Pro 3, но на моем MSI GT72VR 6RE он может работать в ускоренном режиме, что довольно быстро. Для тех, кому интересно, вы можете относиться к этому так же, как к любому другому эмулятору, и даже получить доступ к Play Store для загрузки своих приложений. Если у вас есть оборудование, это реальный способ запускать некоторые приложения на ПК с Windows!

Менеджер SDK

Если вы хотите настроить таргетинг на определенную версию Android или создать виртуальное устройство с определенной версией, вам потребуется загрузить необходимую платформу и инструменты SDK. Вы можете сделать это с помощью диспетчера SDK, который вы найдете, выбрав Инструменты> Диспетчер SDK. Здесь вы также сможете найти дополнительные ресурсы, такие как Google Glass Development Kit или Android Repository, которые предоставляют вам дополнительные функции для использования в вашем приложении.

Просто установите флажок рядом с тем, что вы хотите загрузить, и нажмите «ОК». Android Studio также время от времени будет предупреждать вас, когда пришло время обновить саму среду IDE или любой из этих элементов. Будьте в курсе последних событий!

Создание подписанных APK

Наконец, когда вы закончите тестирование своего приложения и будете готовы выпустить его в большой мир, вам нужно будет выбрать Сборка> Создать подписанный APK. Это даст вам файл, который вам нужно будет загрузить в Google Play, и который будет содержать все различные файлы, ресурсы и многое другое.

Вам будет предложено создать или ввести хранилище ключей. Это своего рода «сертификат подлинности», подтверждающий, что загружаемый APK – это приложение, о котором вы говорите. Это предотвращает взлом вашей учетной записи Google Play и последующую загрузку вредоносного APK-файла в качестве «обновления» в ваше приложение! Вам нужно будет сохранить этот файл в безопасности, так как, если он потерян, вы уже не сможете обновить приложение снова! Выберите «выпуск» в качестве типа сборки, если вы хотите сделать что-то, что вы можете выпустить, а затем нажмите «Готово».

Путешествие только начинается …

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

Например, если вы хотите создавать облачные приложения, вам нужно начать разбираться с Firebase. Google упростил это, встроив поддержку прямо в саму среду IDE. Просто выберите «Инструменты»> «Firebase», и тогда вы сможете приступить к настройке облачных функций. Точно так же вам может потребоваться использовать GitHub, который позволяет создавать резервные копии ваших приложений в Интернете и обеспечивает контроль версий для упрощения совместной работы. Затем есть Android NDK (Native Development Kit) для разработки на C / C ++. Конечно, вам также необходимо познакомиться с Java и / или Kotlin, если вы собираетесь делать что-нибудь полезное! Вам также необходимо научиться использовать внешние библиотеки.

Google также постоянно обновляет Android Studio и добавляет в платформу новые функции и возможности, за которыми может быть сложно не отставать. Последняя версия на момент написания – Android Studio 3.3, и новые концепции, которые заставят вас задуматься, включают мгновенные приложения и пакеты приложений. Кроме того, в составе Android Jetpack представлены новые компоненты, такие как компонент архитектуры навигации и фрагменты. Это никогда не заканчивается.

Хотя все это может показаться головной болью, Google прилагает огромные усилия, чтобы сделать эти процессы максимально простыми и легкими. Несколько лет назад этот урок был бы намного более запутанным, даже на этапе настройки! И о многом из этого вам не нужно беспокоиться, пока оно вам не понадобится (а может и никогда, в зависимости от того, что вы создаете). Лучшая стратегия – придерживаться простого проекта приложения и изучать более продвинутые функции только по мере необходимости. Делайте это шаг за шагом, и вы обнаружите, что Android Studio на самом деле замечательный и очень полезный инструмент.

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