Android Interview Review
3.56K members
1 photo
234 links
Популярные вопросы и ответы с собеседований на Android-разработчика.

Канал для Java-разработчиков @JavaSobes

Связаться с нами @SobesAdmin

https://itsobes.ru
Download Telegram
to view and join the conversation
Из каких базовых компонент состоит приложение?

Базовые компоненты андроид приложения: Activity, Service, BroadcastReceiver, ContentProvider. Каждый из базовых компонент объявляется в андроид манифесте и может являться точкой входа в приложение.

Activity представляет UI и функциональность, видимые пользователю.

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

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

ContentProvider используется для обмена данными с другими приложениями.

Каждый из компонентов подробнее рассмотрим в будущем.

#Components
Может ли приложение быть запущено в нескольких процессах?

Короткий ответ – Да.

Но для начала давайте разберемся чем процесс отличается от потока.

Процесс – это сущность на уровне ОС. Каждая программа может быть запущена в одном или нескольких процессах.

Поток – это сущность на уровне Runtime Environment.

Программа может выполняться в нескольких процессах. В каждом из процессов может быть создано несколько потоков (Java Threads).

Вернемся к андроиду. В предыдущем посте мы рассмотрели базовые компоненты и узнали, что каждый из компонентов может быть точкой входа в приложение. По умолчанию компоненты приложения работают в дефолтном процессе, но каждый из компонентов <activity>, <service>, <receiver>, <provider> может иметь поле android:process=”<name>” в андроид манифесте. Кастомное значение этого поля явно говорит системе в каком процессе будет работать компонент.

Важно: При старте нового процесса создается инстанс приложения и снова вызывается Application.onCreate(). Если в этом методе вы инициализируете модули или библиотеки, которые используются только в главном процессе, то не забывайте проверять, в каком процессе вы находитесь в момент инициализации.

Подробнее про процессы и треды читайте в документации.

#System
Приоритеты процессов

Процессы делятся по приоритету на 4 вида, в порядке убывания:

1. Видимый активный процесс (Foreground process). В этом процессе работает приложение, с которым взаимодействует пользователь. Процесс находится в этом состоянии в следующих случаях:
- Activity, у которой вызван onResume(), но еще не вызван onPause()
- Во время выполнения BroadcastReceiver.onReceive()
- Запущен Service и выполняется один из колбэков: onCreate(), onStart(), onDestroy()

2. Видимый процесс. Пользователь знает о приложении, запущенном в этом процессе, но не взаимодействует с ним:
- Activity у которой вызван onPause(), но еще не вызван onStop().
- Service, который запущен через Service.startForeground(). В этом случае пользователь видит нотификацию, связанную с сервисом.
- Service, выполняющий функцию, о которой пользователь осведомлен. Например input method service.

3. Background Service. Процесс с сервисом, запущенным командой startService().

4. Закэшированный процесс. К ним относятся пустые процессы, используемые при старте приложений, и процессы, в которых все активити в onStop() состоянии.

Система убивает процессы в порядке возрастания их приоритета для восстановления ресурсов. Подробнее

#Lifecycle
#System
Activity: Что такое и как запустить?

Activity – основной компонент в андроиде. Активити – это экран, то что видит и с чем взаимодействует пользователь. Может содержать несколько View и фрагментов. Так же как и другие базовые компоненты, может быть точкой входа в приложение.

Активити с MAIN Intent Filter в манифесте запускается при старте приложения, когда пользователь кликает на иконку приложения.

#Activity
#Components
​​Activity: Жизненный цикл

Жизненный цикл активити состоит из шести основных коллбэков, вызываемых системой. В порядке вызова: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy().


onCreate() вызывается когда активити создается. В onCreate() вы должны вызвать метод setContentView().

onStart() вызывается когда активити отрисована и видима пользователю.

onResume() вызывается перед тем как активити станет доступна для взаимодействия с пользователем.

onPause() – метод симметричный onResume(). Пользователь больше не может взаимодействовать с активити, но активити частично видна пользователю. В этом состоянии UI активити может изменяться.

onStop() – метод симметричный onStart(). Вызывается, когда активити больше не видна пользователю.

onDestroy() – метод симметричный onCreate(). Вызывается перед тем, как активити будет уничтожена системой.


Несколько примеров:

1. Пользователь жмет Home. В этом случае активити больше не видна, поэтому вызываются onPause(), onStop(). Пользователь открывает приложение снова - onStart(), onResume().

2. Пользователь переходит на другую активити внутри приложения (реализуется вызовом startActivity()) – onPause(), onStop(). Пользователь возвращается на предыдущую активити – onStart(), onResume().

3. Вызов finish()onPause(), onStop(), onDestroy(). Когда пользователь перейдет на эту активити снова, она будет создана с нуля без сохранения состояния.

4. Пользователь поворачивает телефон и ориентация активити меняется. Активити пересоздается и вызываются коллбеки onPause(), onStop(), onDestroy(), onCreate(), onStart(), onResume() с сохранением состояния.

Это базовые методы активити. Более подробно они описаны в документации.

В полный жизненный цикл также входят onRestart(), onSaveInstanceState(), onRestoreInstanceState(), onNewIntent() и другие методы, которые разберем в будущем.


#Activity
#Lifecycle
Activity: Как пережить поворот экрана?

При повороте экрана активити уничтожается и создается заново. Вызываются коллбэки onPause(), onStop(), onSaveInstanceState(), onDestroy()onCreate(), onStart(), onRestoreInstanceState(), onResume().

Чтобы сохранить состояние активити, вы должны переопределить метод onSaveInstanceState() и положить данные в Bundle.

При реинициализации активити, Bundle с сохраненным состоянием передается в onCreate() и в onRestoreInstanceState().

Система вызывает onSaveInstanceState() и onRestoreInstanceState() только в том случае, когда необходимо сохранить состояние, например при повороте экрана или при убийстве активити для освобождения памяти. Данные коллбэки не вызываются, если пользователь выходит из активити нажав Back или если активити убивается вызовом finish().

onSaveInstanceState() вызывается после onStop() на версии API ≥ 28. На API < 28 этот коллбэк вызывается перед onStop() и нет гарантий до или после onPause().

onRestoreInstanceState() вызывается после onStart().

#Activity
#Lifecycle
#State
Нужно ли думать о сохранении состояния, если приложение поддерживает только портретную ориентацию?

– Да.

Поворот экрана – это частный случай Configuration Changes. Другой пример – изменение языка системы.

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

#State
Fragment

Fragment используется для отображения части UI на экране. Фрагмент создается внутри активити или внутри другого фрагмента.

Для создания и управления фрагментами используется FragmentManager.

Класс-наследник класса Fragment должен иметь дефолтный конструктор без параметров. Система использует этот конструктор при пересоздании фрагмента.

Начиная с API v28 системный класс Fragment – deprecated. Рекомендуется использовать Fragment из Support Library.

#Fragment
Расскажите про способы добавления и переключения фрагментов. Как работать с бэкстэком?

Для управления фрагментами используются два класса: FragmentManager и FragmentTransaction.

Для получения FragmentManager используются метод активити getSupportFragmentManager() или метод фрагмента getChildFragmentManager().
FragmentManager начинает транзакцию и возвращает объект FragmentTransaction вызовом метода beginTransaction().

Методы класса FragmentTransaction, которые необходимо знать - add(), remove() и replace().

add() добавляет фрагмент на активити или другой фрагмент. Принимает аргументами containerViewId, в который добавляется фрагмент, инстанс фрагмента, тег.
Другой способ добавить фрагмент - определить в лэйауте с помощью тега <fragment>.

remove() - операция, обратная add(). Удаляет фрагмент.

replace() удаляет все фрагменты, добавленные методом add() в заданный контейнер, и добавляет переданный аргументом фрагмент в контейнер. Параметр tag может быть null.

Эти операции не выполняются сразу же после вызова методов. Метод commit() завершает транзакцию и выполняет операции транзакции.

Метод addToBackStack() добавляет транзакцию в Back Stack. Это значит, что когда пользователь нажмет Back транзакция откатится. addToBackStack() применяется ко всем операциям в транзакции. Например следующий код добавляет транзакцию из трех операций в бэкстэк:

fragmentTransaction
.add(R.id.fragmentContainer1, fragment1)
.add(R.id.fragmentContainer2, fragment2)
.replace(R.id.fragmentContainer1, fragment3)
.addToBackStack("tag")
.commit()


Метод popBackStack() удаляет транзакцию с верхушки бэкстэка, возвращает true, если бэкстэк хранил хотя бы одну транзакцию.

Документация.

#Fragment
Важен ли порядок, в котором добавляются операции в FragmentTransaction?

Документация описывает два случая, в которых порядок важен:

1. Метод commit() должен вызываться последним.

2. Если несколько фрагментов добавляются в один контейнер, то порядок добавления определяет порядок в котором фрагменты отрисовываются в иерархии view.

Есть еще третий случай. Если метод addToBackStack(String name) вызывается несколько раз на одной транзакции, то транзакция добавляется в бэкстэк один раз с тегом, который передается в последнем вызове метода.

Пример:

supportFragmentManager.beginTransaction()
.add(R.id.fragmentContainer, Fragment1())
.addToBackStack("add1")
.add(R.id.fragmentContainer, Fragment2())
.addToBackStack("add2")
.commit()


Создается одна транзакция с тегом add2, которая добавляет сразу два фрагмента. При нажатии кнопки Back оба фрагмента будут удалены.

Поведение нескольких addToBackStack() не задокументировано и может различаться на разных версиях ОС, так что не забудьте на собеседовании сказать, что вы бы так никогда делать не стали.

#Fragment
Чем отличается tag в методах add() и addToBackStack()?

Tag в методе add() присваивается фрагменту. Fragment.getTag() возвращает этот тег.
Тег фрагмента используется в методе findFragmentByTag().

Tag в методе addToBackStack() это на самом деле не tag, а name. Имя транзакции, которое присваивается объекту BackStackEntry и возвращается методом getName().

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

val tag = "home_fragment"
supportFragmentManager.beginTransaction()
.add(R.id.fragmentContainer, HomeFragment, tag)
.addToBackStack(tag)
.commit();



val lastEntryIndex = supportFragmentManager.backStackEntryCount - 1
val tag = supportFragmentManager.getBackStackEntryAt(lastEntryIndex).name
val topFragment = supportFragmentManager.findFragmentByTag(tag)


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

Удобно? Нет! Не надо так делать.

#Fragment
Метод FragmentManager.commit() – синхронный или нет?

– Асинхронный.

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

Чтобы выполнить транзакцию синхронно, можно воспользоваться методом commitNow() вместо commit() или вызвать executePendingTransactions() после метода commit().

#Fragment
Что такое Activity State Loss Exception? Для чего нужен commitAllowingStateLoss()? (1/2)

Это два вопроса на одну и ту же тему.
Под Activity State Loss Exception понимается исключение вида:
java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState with MyFragment.

Это исключение случается, когда метод FragmentTransaction.commit() вызывается после Activity.onSaveInstanceState(). Его не всегда удается поймать во время тестирования, потому что место вызова onSaveInstanceState() зависит от версии ОС.

В чем же причина исключения?
Когда пользователь уходит с активити, состояние сохраняется на случай, если активити будет уничтожена системой. Сохранение состояния происходит в методе onSaveInstanceState(). Если транзакция применяется после сохранения состояния, то транзакция не может быть сохранена и система бросает исключение.

#Fragment
#State
Что такое Activity State Loss Exception? Для чего нужен commitAllowingStateLoss()? (2/2)

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

Хорошей практикой считается использование commit(), а не commitAllowingStateLoss(). Если вы получаете репорты о state loss крэшах, пробуйте решить корень проблемы. Для этого не вызывайте commit() в onPause() или следующих после него методах.

Тема Activity State Loss хорошо раскрывается в этом посте.

#Fragment
#State
Как получить ссылку на фрагмент из активити?

Отвечая на этот вопрос, не рассказывайте, пока не спросят, об использовании в активити объекта List<MyFragment>, в который вы добавляете фрагменты при вызове onAttach() и удаляете в onDetach(). Интервьюер хочет услышать знаете ли вы стандартные методы API.

Системное API предоставляет два метода для поиска и получения фрагмента внутри активити: findFragmentByTag() и findFragmentById().

findFragmentByTag() принимает параметром тег, который передается в методе add() или replace() или в XML в элементе <fragment>. Возвращает null, если фрагмент не найден.

findFragmentById() принимает параметром id фрагмента. Если фрагмент добавляется методом add() или replace(), то id фрагмента – это id контейнера, который передается первым параметром. В случае добавления фрагмента через XML, id задается в элементе <fragment>. findFragmentById() возвращает null, если фрагмент не найден.

#Fragment
Опишите жизненный цикл фрагмента.

Часть методов жизненного цикла фрагмента аналогична методам жизненного цикла активити.

Методы жизненного цикла фрагмента в порядке вызова:

onAttach() – Вызывается когда фрагмент присоединяется к активити.

onCreate() – Вызывается когда фрагмент создается.

onCreateView() – Метод, в котором создается иерархия View, связанная с фрагментом.

onActivityCreated() – Вызывается после того, как отрабатывает метод Activity.onCreate().

onViewStateRestored() – Вызывается, когда состояние иерархии View восстановлено.

onStart() – Вызывается, когда фрагмент становится видим пользователю, после Activity.onStart().

onResume() – Вызывается перед тем как фрагмент станет доступен для взаимодействия с пользователем, после Activity.onResume().

onPause() – Пользователь не может взаимодействовать с фрагментом, но часть фрагмента видима пользователю.

onStop() – Фрагмент становится не видим пользователю.

onDestroyView() – Метод, в котором фрагмент очищает ресурсы, связанные с иерархией View.

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

onDetach() – Вызывается перед тем, как фрагмент будет отсоединен от активити.

Когда фрагмент удаляется методом remove() или replace() и транзакция добавляется в back stack, то у удаленного фрагмента вызывается onStop() и не вызывается onDestroy(). Если пользователь нажимает Back, то транзакция откатывается и у фрагмента вызывается onStart().
Если же транзакция не добавляется в back stack, то у удаленного фрагмента вызывается onDestroy().
Документация.


#Fragment
#Lifecycle
Что такое Target Fragment и для чего нужен?

Target Fragment используется как способ взаимодействия между фрагментами. Идея аналогична механизму startActivityForResult(), но отличается в деталях реализации.

Target Fragment назначается методом Fragment.setTargetFragment(Fragment fragment, int requestCode).

Для получения target fragment и request code используются методы getTargetFragment() и getTargetRequestCode().

Target fragment лучше колбэка тем, что он переживает configuration changes. Система сама подставляет новый инстанс таргет фрагмента, когда он пересоздается.

Примеры использования: раз и два.

#Fragment
В чем разница между Dialog и DialogFragment?

Класс Dialog используется для отображения диалогового окна. Использование класса Dialog напрямую не рекомендуется, потому что управление состоянием диалога при configuration changes сложно и неочевидно (не делайте так, если вы не в 2009м). Диалоги были частой причиной крэшей на ранних этапах разработки под андроид. Метод активити showDialog() deprecated начиная с API level 15.

DialogFragment – фрагмент, который содержит внутри себя объект Dialog и выступает как интерфейс для взаимодействия с диалогом. У DialogFragment жизненный цикл фрагмента. Система сама заботится о пересоздании DialogFragment при configuration changes.

Всегда используйте DialogFragment, а не Dialog.

#Fragment
Чем отличается activity Context от application Context?

Activity Context создается при создании активити и уничтожается вместе с активити. Контекст – тяжелый объект. Когда говорят об утечке памяти в андроиде, имеют в виду утечку контекста, т.е. ситуацию, когда контекст активити хранится после вызова Activity.onDestroy(). Не передавайте контекст активити в другой объект, если не известно как долго этот объект проживет. Подробнее о memory leak.

Application Context – синглтон. Application Context создается при создании объекта Application и живет, пока жив процесс приложения. По этой причине Application Context можно безопасно инжектить в другие синглтоны в приложении. Не рекомендуется использовать Application Context для старта активити, потому что необходимо создание новой задачи, и для layout inflation, потому что используется дефолтная тема.

Подробнее про виды контекстов.

#Activity
#Application
#Components
Что такое и зачем нужен Service? Какие бывают виды сервисов?

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

Сервисы делятся на два вида по способу использования: Started и Bound, и на два вида по способу взаимодействия с пользователем: Background и Foreground.
Когда спрашивают о видах сервисов обычно имеют в виду способ использования.

Started Service Запускается методом startService(Intent intent). Intent должен быть явным (explicit), это значит, что при создании объекта Intent было передано имя класса сервиса.
После запуска сервиса вызывается метод onStartCommand().
Остановить сервис можно вызовом метода stopSelf() из самого сервиса или методом stopService() из другого компонента.

Bound Service привязывается к компоненту вызовом метода bindService(Intent service, ServiceConnection serviceConnection, int flags).
Аргумент serviceConnection используется для взаимодействия с привязанным сервисом. Сервис стартует после вызова bindService(), если аргумент flags имеет значение BIND_AUTO_CREATE.
После вызова bindService() у сервиса вызывается метод onBind().
Для отвязывания компонента от сервиса используется метод unbindService(). У сервиса вызывается метод onUnbind().
Если у сервиса больше нет привязанных компонентов, вызывается метод onDestroy().

Компонент может быть привязан к сервису, запущенному методом startService(). В этом случае сервис относится сразу и к Started и к Bound.

Bound и Started сервисы важно различать, потому что у них разные жизненные циклы.

Подробная статья про сервисы.

#Service
#Components