Android view для нескольких

Android view для нескольких

В процессе созданию фактически любого приложения разработчик использует бесконечное количество разных View элементов (TextView, GridView, ImageView и т.д.). Но часто возникает потребность в том, чтобы многократно использовать одну и ту же группу таких элементов в различных местах приложения. Можно конечно постоянно создавать их с нуля и загромождать программу однотипными кусками кода, но есть и другой способ. Довольно умным решением для этого случая является использование составных View элементов (Compound View), в которых сохранены все необходимые настройки и разметка нужной группы view элементов, и которые можно использовать сколько угодно раз в любой части программы. Согласитесь, это прилично экономит время и уменьшает количество нужного программе кода, ну и просто очень удобно. В этом уроке мы и научимся работать с такими составными view элементами.

В Android программировании, составным view ( Compound View ) элементом называется такой объект, которые состоит из группы view элементов. Также его иногда называют составным компонентом.

Создаем новый проект, названия оставим по умолчанию, выбираем любимый нами Blank Activity. Минимальную версию ОС для запуска нашей программы выбираем Android 4.0.

Теперь возьмемся за дело. Для созданию составного View объекта нужно создать отдельный класс, который будет управлять view элементами, входящими в Compound View. В папке res/layout создаем новый файл по имени sidespinner_view.xml и добавляем туда следующий код:

Далее нужно создать новый класс и связать его с выше созданным layout файлом и настроить созданным там кнопкам изображения стрелочек. Создаем новый класс по имени SideSpinner.java и добавим туда этот код:

Как видите, мы расширяем (extends) наш Compound View от LinearLayout. Это делается для того, чтобы предоставить Compound View объекту все свойства, которыми обладает LinearLayout. Когда мы добавим наш составной view в класс MainActivity, он будет восприниматься там как просто LinearLayout. Можно задавать расширение и от ViewGroup, но в нашем случае предпочтительнее сделать так, как сделали мы:).

Теперь перейдем к файлу activity_main.xml и добавим туда наш Compound View:

Как видите, атрибуты, используемые в теге SideSpinner, это атрибуты обычного LinearLayout. По поводу строки home.study.SideSpinner. Это строка адреса к нашему классу SideSpinner и у вас она будет другой. Смотрите какая она у вас по структуре своего проекта:

Сейчас наше приложение выглядит примерно вот так:

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

А теперь добавляем необходимый код:

Когда все элементы из Compound View заполнены и готовы к использованию, вызывается метод onFinishInflate. Также этот метод отвечает за поведение кнопок «Вперед», «Назад». Добавляем в этот же класс SideSpinner.java следующий код, обновив код метода onFinishInflate ( он уже создан нами выше ) :

Теперь нужно инициализировать переключатели в классе MainActivity.java и добавить строковый массив с словами, между которыми и будет происходить переключение при нажатии на кнопки. Обновим код метода onCreate в классе MainActivity.java :

Если сейчас запустить наше приложение, то оно должно уже работать нормально и при нажатии на переключатели слово между ними будет меняться. Слово «Апельсин» будет выбрано по умолчанию:

Здорово, да?:) Таким образом мы создали компонировку, соединение из 3 разных view элементов: двух кнопок Button и TextView, и все они взаимодействуют и работают совместно, образуя такой вот Compound View. Применяя эту технику, можно объединить любые элементы View. Надеюсь, вы почерпнули от этого урока много полезного, удачи!

Источник

Один интерфейс для нескольких фрагментов

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

Это упрощенный пример: у меня есть 1 действие и 2 фрагмента. У каждого фрагмента есть кнопка, при нажатии на которую щелчок возвращается к Activity, а в Activity появляется всплывающее окно Toast.

Я знаю, что фрагмент взаимодействует с действием через интерфейс. Но что, если у меня есть несколько фрагментов с одинаковым интерфейсом. Например, здесь оба фрагмента используют интерфейс типа onClick для обратной связи с Activity.

A) Создайте отдельный класс интерфейса и прикрепите его к обоим фрагментам. Например, фрагмент 1:

Б) Создайте индивидуальные интерфейсы, уникальные для конкретного фрагмента, и реализуйте их в MainActivity вместо одного интерфейса, как указано выше. Спасибо.

3 ответа

Сначала создайте свой собственный фрагмент, который находится в интерфейсе реализации.

Теперь вы можете добавить в каждый фрагмент

Существует принцип кода под названием SOLID. «I» означает https://en.wikipedia.org/wiki/Interface_segregation_principle. Это хорошая практика

Вы не должны делать универсальный интерфейс или большие, вам нужно создать интерфейс, который может быть «читаемым» и «понятным» для всех по имени интерфейса и его именам методов, например «articleSelected «или «loginProcessing(String loginName)» и т. Д.

Я бы не позволил деталям любых View , содержащихся в Fragment просочиться в Activity .

Лучшие интерфейсы будут основаны на семантическом действии, связанном с нажатием кнопки, например createThing() или deleteThing() .

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

Если вы создаете такие интерфейсы, вопрос о создании копий для разных Fragment отпадает.

Источник

Создание композитных компонентов на Android

Приветствую всех Хабра-жителей и Андроид-ценителей!
Композитный в нашем случае означает «состоящий из нескольких», но вы это и так знаете.
Итак, есть Задача:

• Необходимо вывести блок данных, включающий в себя текст, картинки, кнопки и т.д.
  (В нашем случае это будет короткий анонс передачи по ТВ)
• дизайн блока нарисован специально нанятым дизайнером и вам нельзя отсупать от него ни на пиксель
• Это блок может иметь какую-то внутреннюю логику работы и компоненты могут влиять друг на друга (у нас «внутренней логикой», будет установка символа «*» в заголовок передачи и смена цвета фона если была нажата кнопка «Буду смотреть»)
• Таких блоков может быть много и информация для них получается уже в процессе работы приложения
• как всегда, в процессе работы, дизайн может быть пересмотрен, и вам надо быстро внести изменения в программу не переписывая все с самого начала

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

или сложный финансовый блок с графиками

Для начала, рассмотрим альтернативные варианты и их недостатки в применении к нашему случаю.

Кастом-компоненты (custom component)

Позволяет менять дизайн и поведение компонента, но только в пределах одного компонента, что нам не подходит по-определению.
Пример:

Динамическое создание UI программными средствами

С помощью этого способа придется написать километры килобайты кода, в котором вы каждый TextView будете создавать вручную, передавать в него контекст, создавать для него LayoutParams для описания выравнивания, все это помещать в заранее созданные LinearLayout/FrameLayout/RelativeLayout, сотни раз запускать ваш код что бы добиться соответствия дизайну.
И как только дизайнер пришлёт вам новую версию дизайна, вы, мягко говоря, будете не очень этому рады…
Абстрактный пример создания нескольких полей в коде:

Табличный Layout

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

Canvas Draw

Суть данного метода в простом рисовании на канве, вашего UI компонента.
Данный метод мало того что обладает недостатками 2-го пункта (сложная ручная подгонка всех элементов UI в соответствии с дизайном), но и имеет еще один существенный недостаток — невозможность использования стандартных элементов управления EditText, Botton, CheckBox, SeekBar, в этом случае их либо придется писать вручную, либо накладывать поверх нашего UI. В любом случае это будет неадекватные затраты времени и сил на решение задачи.

Создание композитного компонента при помощи LayoutInflater

Наконец мы подошли к самой сути статьи — созданию компонента по приведенному заданию оптимальным способом.
Для начала мы, как уже привыкли, верстаем наш дизайн layout в XML вручную или при помощи визуального редактора который является частью Eclipse плагина ADT.
Обязательно всем ключевым элементам UI даем свои уникальные ID.
Для верстки воспользуемся RelativeLayout, для того что бы иметь возможность задавать относительное положение компонентов внутри родителя и друг относительно друга. Конкретно в этом случае было бы достаточно и вертикального LinearLayout, но мы в образовательных целях лёгких путей не ищем.
Ширина компонента выставлена жестко(288dip), что бы было как в исходной картинке, но ничего не мешает сделать «fill_parent».

Для задания свойств текста, можно было бы создать пару стилей, но обойдемся тем что есть, для наглядности. Так же не пинайте за то, что не вынес текстовые надписи в strings.xml, ухудшилась бы читаемость и пришлось бы цитировать еще один файл в статью.
Далее создаем класс нашего компонента и наследуем его от класса который мы использовали в нашей верстке — RelativeLayout.
Для того, что бы соединить наш класс и лейаут channel_layout, используем LayoutInflater.
Так же мы внутри класса определяем переменные для всех полей что бы связать поля класса с UI.

Теперь в двух словах что я тут наделал: сначала инициализируем все поля и создаем удобные методы для установки значений полей, так например, для установки логотипа есть 2 способа — через указание Id ресурса и через передачу Bitmap.
Так же наш класс является оберткой над «TVProgram parentProgram» — это еще один способ установки полей нашего UI компонента — вызывая setParentProgram и передавая заполненный объект программы, мы автоматом устанавливаем значения всех UI полей из парента.
Компонент готов, остается создать его экземпляры, установить значения полей и добавить их на форму:

И, на последок, скриншот того что у нас получилось:

И исходники.
Удачных проектов Вам!

Источник

Рисование собственных представлений (View) в Android

Получите полный контроль над представлением и оптимизируйте его производительность

В преддверии старта курса «Android Developer. Professional» приглашаем всех желающих принять участие в открытом вебинаре на тему «Пишем gradle plugin».

А пока делимся переводом полезного материала.

Введение

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

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

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

Зачем создавать собственные представления?

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

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

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

Необходимо создать специализированное представление, требующее рисования вручную.

Общий подход

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

Создать класс, расширяющий базовый класс или подкласс представления.

Реализовать конструкторы, использующие атрибуты из XML-файла.

Переопределить некоторые методы родительского класса (onDraw(), onMeasure() и т. д.) в соответствии с нашими требованиями.

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

Пример

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

Шаг 1. Создадим класс с именем CircularTextView .

Шаг 2. Расширим класс виджета TextView. Здесь под TextView в IDE выдается ошибка, в которой сообщается, что у этого типа есть конструктор и он должен быть инициализирован.

Шаг 3. Добавим конструкторы в класс.

Это можно сделать двумя способами.

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

Другой способ заключается в добавлении аннотации @JvmOverloads к вызову конструктора, как показано ниже.

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

View(Context context)

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

View(Context context, @Nullable AttributeSet attrs)

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

Шаг 4. Самый важный шаг в отрисовке собственного представления — это переопределение метода onDraw() и реализация необходимой логики отрисовки внутри этого метода.

Метод OnDraw (canvas: Canvas?) имеет параметр Canvas (холст), с помощью которого компонент представления может отрисовывать себя. Для рисования на холсте необходимо создать объект Paint.

Как правило, процесс рисования определяется двумя аспектами:

что рисовать (определяется объектом Canvas);

как рисовать (определяется объектом Paint).

Например, Canvas предоставляет метод для рисования линии, а Paint предоставляет методы для определения цвета этой линии. В нашем случае объект Canvas в классе CircularTextView предоставляет метод для рисования окружности, а объект Paint заполняет ее цветом. Проще говоря, Canvas определяет, какие фигуры можно нарисовать на экране, а Paint определяет свойства нарисованных фигур — цвет, стиль, шрифт и т. д.

Давайте займемся кодом. Мы создаем объект Paint и присваиваем ему некоторые свойства, а затем рисуем фигуру на холсте (объект Canvas), используя наш объект Paint. Метод onDraw() будет выглядеть так:

IDE показывает предупреждение о том, что следует избегать выделения объектов во время операций отрисовки или операций с макетом. Это предупреждение возникает потому, что метод onDraw() много раз вызывается при отрисовке представления, в котором каждый раз создаются ненужные объекты. Поэтому, чтобы избежать ненужного создания объектов, мы вынесем соответствующую часть кода за пределы метода onDraw() , как показано ниже.

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

Шаг 5. Мы закончили с рисованием. Теперь давайте внесем этот класс представления в XML.

Добавьте этот XML-макет в вашу активность (Activity) и запустите приложение. Вот что будет на экране.

Выглядит неплохо, правда? Теперь сделаем так, чтобы значение динамическому свойству цвета в circlePaint назначалось из активности, а также добавим контур к кружку. Для этого в классе CircularTextView необходимо создать несколько методов-сеттеров, чтобы можно было вызывать эти методы и устанавливать свойства динамически.

Для начала давайте реализуем настройку цвета отрисовки. Для этого создадим сеттер, как показано ниже.

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

Неплохо, правда? Теперь давайте добавим контур к кружку. Контур будет задаваться двумя входными параметрами: шириной линии контура и ее цветом. Чтобы задать цвет линии контура, нам нужно создать объект Paint точно так же, как мы это делали для кружка. Чтобы задать ширину линии контура, мы создадим переменную, установим для нее нужное значение и используем его в методе onDraw() . Полный код будет выглядеть так:

Теперь в активности можно динамически настраивать эти атрибуты нужным образом.

Далее давайте запустим приложение, устанавливая различные цвета для нашего виджета.

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

Для начала создадим файл с именем attrs.xml в папке values. Этот файл будет содержать все атрибуты для различных представлений, которые мы создаем сами. В приведенном ниже примере у нашего представления под названием CircularTextView имеется атрибут ct_circle_fill_color , который принимает значение цвета. Аналогичным образом мы можем добавить и другие атрибуты.

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

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

В моем случае результат был таким:

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

Обновление представления

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

invalidate()

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

requestLayout()

Если в какой-то момент происходит изменение состояния представления, то метод requestLayout() сообщает системе представлений, что необходимо сделать перерасчет фаз «измерение» (Measure) и «макет» (Layout) для данного представления (измерение → макет → рисование). Проще говоря, метод requestLayout() следует вызывать в случае, когда требуется изменение границ представления.

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

Источник