Что такое android annotations

Support Annotations — аннотации для кода

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

По умолчанию аннотации не включены, они идут как отдельная библиотека. Но она входит в состав библиотеки appcompat. Если вы не используете appcompat, то подключите библиотеку аннотаций самостоятельно.

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

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

Аннотации для ресурсов

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

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

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

Но никто вам не помешает написать и такие варианты:

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

Как избежать этих ошибок, перепишем метод с добавлением аннотации:

Теперь студия будет подчёркивать неправильные параметры 451 или R.mipmap.ic_launcher и выводить предупреждение, что она ожидает строковые ресурсы, а не любые выдуманные вами числа.

Вы можете использовать аннотации @AnimatorRes, @AnimRes, @AnyRes, @ArrayRes, @AttrRes, @BoolRes, @ColorRes, @DimenRes, @DrawableRes, @FractionRes, @IdRes, @IntegerRes, @InterpolatorRes, @LayoutRes, @MenuRes, @PluralsRes, @RawRes, @StringRes, @StyleableRes, @StyleRes, @XmlRes и т.д. Если у вас есть свой тип ресурсов «foo», то можете использовать аннотацию FooRes.

@NONNULL/@NULLABLE

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

Студия выводит предупреждение, но позволит запустить программу. Нажатие на кнопку и опять ваш труд коту под хвост — крах приложения.

@CheckResult — ожидание результата

Метод может возвращать какое-то значение, которое нужно применить. А можно просто вызвать метод, только какой в этом смысл, если возвращаемое значение нигде не используется? Для тех, кто страдает склерозом — встречайте аннотацию @CheckResult.

Студия укажет на ошибку и откажется запускать ваше приложение. Умница.

Аннотация для продвинутых. ProGuard удаляет неиспользуемые методы при компиляции. Если она делает это ошибочно или по каким-то другим причинам вам нужно оставить метод в приложении, то используйте @Keep:

Аннотации для потоков

Существуют специальные аннотации для указания потоков.

Например, мы знаем, что методы класса AsyncTask могут работать только в определённых потоках.

Если в методе doInBackground() обратиться к какому-нибудь компоненту, то студия предупредит, что так делать нельзя.

@UiThread и @MainThread практически совпадают, но в редких случаях могут различаться. Подробности в документации.

Аннотация для цвета

Вы можете задать цвет через ресурс, используя аннотацию @ColorRes. А если перед вами стоит противоположная задача — указать значение цвета через RGB/ARGB, то используйте аннотацию @ColorInt. В этом случае при использовании цветового ресурса студия покажет ошибку.

Диапазон значений

Можно указать диапазон значений для типов float/double через аннотацию @FloatRange:

В этом случае можно использовать значения от 0.0 до 1.0. Любая попытка ввести другое значение приведёт к предупреждению.

Аналогично работает для типов int/long через аннотацию @IntRange:

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

• Если коллекция не должна быть пустой — @Size(min=1)
• Максимальная длина строки 15 символов — @Size(max=15)
• Массив точно состоит из двух элементов — @Size(2)
• Длина массива должна быть кратна двум (например, координаты точек X и Y) — @Size(multiple=2)

Аннотации для разрешений

Если ваш метод использует функциональность, которая доступна через разрешения, то можете указать через аннотацию @RequiresPermission:

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

А если нужно выбрать несколько разрешений, то используйте атрибут allOf:

Разрешения для намерений

Если есть разрешения на чтение или запись, то можно указать нужный режим через аннотации @Read или @Write:

Суперкласс

Если метод должен использовать вызов суперкласса, то используем аннотацию @CallSuper:

Остальные аннотации

В документации вы можете узнать о других аннотациях: IntDef/StringDef, @VisibleForTesting и т.д.

Источник

Как улучшить читабельность нашего Android-кода или используем android-annotations

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

Библиотека android-annotations позволяет сократить объем кода на такие действия как:
1.Загрузка ресурсов
2.Поиск вьюшки по идентификатору(findViewById метод)
3.Привязка обработчиков к кнопкам
4.Получение сервисов(ссылок на классы сервисов), фоновую обработку и другие полезные штуки в простейшем виде.

Скачиваем по ссылке выше два jar-а:androidannotations-X.X.X.jar(процессор аннотаций) и сам апи: androidannotations-X.X.X-api.jar. Далее, заходим в Eclipse в свойства проекта в пункт Java Compiler, выбираем Annotation Processors, затем ставим галку в этом меню — Enable project specific settings. После этого необходимо зайти в подпункт Factory Path, снова поставить ту же галку и нажав на Add externak JARs добавить путь к процессору аннотаций.
Это еще не все. После проделанного необходимо зайти в пункт Java Build Path и добавить androidannotations-X.X.X-api.jar во вкладке Libraries данный JAR. Теперь все настроено и готово.

Данная библиотека требует от вас следующего: когда вы используете аннотации из данной библиотеки, то ваш активити в манифесте должен заканчиваться знаком «_». То бишь, у вас есть активити SMSSender, тогда в манифест необходимо добавить активити SMSSender_. Вот такие дела.

Далее приведу кусок примера:

Красиво не так ли? Заметьте, что у нас нет привычного метода onCreate и прекрасно все работает! Но ничто не мешает его добавить, как и другие методы состояний активити.

Как это работает? Заглянем в вики: «AndroidAnnotations works in a very simple way. It automatically adds an extra compilation step that generates source code, using the standard Java Annotation Processing Tool.» Собственно потому и нужно добавлять прекфик в манифест или при старте активити. Также замечу, что если не указывать id, то ресурс будет подгружаться по имени переменной, что также удобно для читаемости кода.

Стоит отметить, что аннотацию @BeforeViews(как в коде по ссылке выше) я так и не нашел, но зато есть @BeforeCreate.

Вот некоторые доступные аннотации:
@ColorRes
@StringRes
@AnimationRes
@BooleanRes
@ColorStateListRes
@DimensionRes
@DimensionPixelOffsetRes
@DimensionPixelSizeRes
@DrawableRes
@IntArrayRes
@IntegerRes
@LayoutRes
@MovieRes
@TextRes
@TextArrayRes
@StringArrayRes
Extra
@SystemService
Background
@UiThread
@UiThreadDelayed
@RoboGuice

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

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

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

Источник

Что такое Android Annotations и почему мы используем аннотации Android?

Я хочу узнать об аннотациях Android, лучше ли это использовать во всех проектах Android.

Если правильно, как его реализовать. Есть ли хороший учебник для этого?

Если это неправильный путь. какова черта аннотаций Android?

Заранее благодарим за помощь.

ОТВЕТЫ

Ответ 1

Аннотации Android — это аннотация, основанная на аннотациях, которая позволяет упростить код в ваших приложениях и уменьшает шаблон шаблонов общих шаблонов, например, устанавливать прослушиватели кликов, принудительно выполнять выполнение никовых/фоновых потоков и т.д..

У вас может получиться что-то вроде этого:

Что-то вроде этого:

Как это работает

Вы комментируете свои действия и компоненты, тогда обработчик аннотаций генерирует классы (во время компиляции), которые расширяют ваши действия и компоненты (т.е. ваши действия не могут быть окончательными) с суффиксом подчеркивания по умолчанию, поэтому, если у вас есть MainActivity , теперь у вас также будет класс MainActivity_ .

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

Как реализовать

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

Этот учебник действительно на сегодняшний день, используя Android Studio 1.5.1, и он пытается немного объяснить, как работает внутренняя часть.

Следует ли использовать его?

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

Из-за того, что Android Аннотации работают, они внедряются в жизненный цикл и делают это, теперь вы зависите от их жизненного цикла (например, если вы аннотируете свои представления с помощью @ViewById , то вы не можете ссылайтесь на них в onCreate() , вам нужно сделать метод и аннотировать его с помощью @AfterViews , и когда этот метод будет выполнен, ваши представления готовы к использованию). Это не обязательно проблема, вам просто нужно хорошо понимать поведение Android и хорошо, поведение Android Аннотации также.

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

Ответ 2

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

Если вы хотите его использовать, на на своем сайте есть много уроков.

Альтернатива: Если вы хотите уменьшить количество кода, делая его очень простым в использовании и понимании, я предлагаю вам библиотеку Butter Knife. Я использую много и до сих пор не встречал никаких ошибок. Очень прост в использовании и чтении.

Ответ 3

Вот пример с Android Studio.

Создайте проект Android с шаблоном «Empty Activity».

Отредактируйте приложение /build.gradle

Добавьте TextView и кнопку в основной макет, activity_main.xml

Измените имя активности на «MainActivity_» в AndroidManifest.xml

Теперь ваш MainActivity.java можно упростить, как показано ниже

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

Ответ 4

Аннотации Android — это библиотека, которая «автогенерирует» код для нас, используя некоторые атрибуты или анотации, такие как @EActivity, @ViewById, @OnClick. Он предназначен для облегчения и сокращения времени кодирования.

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

Но. Мы не используем его, я полностью согласен с ответом DDsix. Используйте принципы и код SOLID, которые следует кодировать, когда и где это должно быть.

Ответ 5

Аннотации Android — это сторонняя библиотека, которая была сделана для всех в одном инструменте для Android. Он способен к инъекции зависимостей, обработке потоков и т.д. Я не рекомендую использовать его; он глючит и нестабилен. В моей текущей работе я работаю над проектом, и моя задача — удалить аннотации Android. Я бы предложил использовать кинжал 2, Butterknife и RxJava

Источник

AndroidAnnotations — упрощаем и укорачиваем код без вреда для здоровья проекта (I часть)

Преимущества

Первое — это сокращение кода, вам больше не нужно искать по id вьюшки и отдельно определять для них слушателей.
Второе — это реализованная, как в самых эротических снах разработчиков под Android, работа с потоками.
Третье — удобное и лаконичное храние состояния активити/фрагмента
Четвертое — простое обращение с адаптерами ListView.
И еще много разных вкусностей.

Что внутри и как работает

Работает это великолепно! Вам не нужно наследоваться от RoboGreendroidOrmliteActionBarFragmentActivity и добавлять в проект тяжеловесные библиотеки. Аннотации обрабатываются на одном из шагов во время компиляции, в собранный проект добавляется лишь 50кб jar, остальное лежит и не лезет в собранный apk.
После аннотации Activity, во время компиляции AndroidAnnotations создаст наследника от него, в котором будут реализованы стандартные методы Android. А остальной код, который мы написали будет вызываться из предка. Из-за этого нам нужно в манифесе декларировать, a MyActivity_ — класс наследник MyActivity, автоматически генерируемый AndroidAnnotations.
Звучит страшно, но самом деле благодаря такому подходу мы как разработчики только выигрываем.
Производительность не падает — используются стандартные методы. А удобство написания растет во много раз.
И еще одна важная особенность: нам не нужно переписывать весь проект — достаточно аннотировать наши Activity/Fragment/View и использовать внутри только, те аннотации, которые нам нужны. А остальное писать, как мы привыкли это делать ранее, и как нам говорит официальная документация. К примеру, нужны в проекте только аннотации для потоков — их и аннотацию Activity/Fragment добавляем, а остальное пишем через стандартные методы.

Имлементация в проект

Здесь и далее всё описано для версии 2.6. Об изменениях в следующих версиях читайте чейнжлог

Настройки проекта

• Скачиваем архив с библиотекой
• androidannotations-2.6-api.jar — помещаем в папку «libs» нашего проекта.
• androidannotations-2.6.jar — поместим в новую папку внутри проекта с названием «ext-libs».
• Затем зайдем в «Project/Properties/Java compiler/Annotation Processing».
• Ставим галочки «Enable project specific settings», «Enable annotations processing», «Enable processing in editor».
• Заходим в подвкладку «Factory path»: ставим галочку «Enable project specific settings» и жмем «Add jar». Добавляем из папки «ext-libs» «androidannotations-2.6.jar». Жмем «apply» и «yes».
• Во вкладке «Java Compiler» убеждаемся, что у нас «1.6» версия компилятора.
• Во вкладке «Java Build Path/Source» жмем «Add Folder» и добавляем новую папку «.apt_generated».
• Жмем ОК

Самое нудное закончилось, дальше начинается песня.

Простая Activity

Для начала аннотируем MainActivity — в манифесте:

заменим .MainActivity на .MainActivity_
Аннотируем класс:

Теперь перегрузку onCreate можно смело удалить и попробовать скомпилировать.

Запуск последующих Activity

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

Вот таким простым способом запускаются аннотированные Activity
Для запуска с передачей экстры: TestActivity_.intent(context).myDateExtra(someDate).start();
где myDateExtra — аннотированное @ Extra сериализуемое protected-поле в TestActivity
Для запуска с флагами: TestActivity_.intent(context).flags(FLAG_ACTIVITY_CLEAR_TOP).start();

Аннотируем Activity по полной

Для сохранения состояния не нужно вынимать сохраненные объекты instance state вручную, достаточно:

И при измененнии состояния, например при повороте экрана — это поле не будет пересоздано, а сохранит свое значение.

Получение ресурсов, например строк:

Слушаем изменения текста:

Наиудобнейшая работа с потоками

В основном эту библиотеку в своих проектах я использую для работы с потоками.
Для этого используются две аннотации:
@ Background — аннотированный так метод выполнится в фоне
@ UiThread — так должен аннотироваться метод, вызываемый в фоновом потоке, но выполняющийся в потоке UI
Вот код примера:

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

Источник