Untitled

# Android Interview Questions

### Жизненный цикл
  * **Activity**
    * <img src="https://github.com/nowiwr01/Interview/blob/master/materials/activity_lifecycle.png" width="350px" />
  * **Fragment**
    * <img src="https://github.com/nowiwr01/Interview/blob/master/materials/fragments_lifecycle.jpg" width="250px" />
  * **Service**
    * <img src="https://github.com/nowiwr01/Interview/blob/master/materials/service_lifecycle.jpg" width="300px" />

### Activity
  * **Как сохранять состояние Activity при повороте экрана?**
    * Чтобы сохранить состояние активити, нужно переопределить метод onSaveInstanceState() и положить данные в Bundle. При реинициализации активити, Bundle с сохраненным состоянием передается в onCreate() и в onRestoreInstanceState(). Система вызывает onSaveInstanceState() и onRestoreInstanceState() только в том случае, когда необходимо сохранить состояние, например при повороте экрана или при убийстве активити для освобождения памяти. Данные коллбэки **не** вызываются, если пользователь выходит из активити нажав Back или если активити убивается вызовом finish().
  * **Когда вызывается onSavedInstanceState() и onRestoreInstanceState()?**
    * onSaveInstanceState() вызывается после onStop() на версии API ≥ 28. На API < 28 этот коллбэк вызывается перед onStop() и нет гарантий до или после onPause(). А onRestoreInstanceState() вызывается после onStart()
  * **Может ли Android убить Activity, которая находится на переднем плане? Если да, то в каких случаях?**
    * Может, если Activity, находящаяся на переднем плане, потребляет слишком много памяти. Когда с помощью этой Activity достигнуто состояние подкачки памяти, она уничтожается, чтобы UI сохранял свою отзывчивость.

### Fragment
  * Что такое Fragment и где он может использоваться?
  * Можно ли создать Fragment без UI? Если да, то в каких случаях это можно использовать?
  * Что такое FragmentManager?
  * Что такое FragmentTransaction?
  * Как восстановить состояние Fragment?
  * **Какие методы вызываются только 1 раз за жизненный цикл?**
    * onAttach(), onCreate(), onDestroy(), onDetach()
  * **Чем отличаются Fragment и Activity? Объяснить их взаимоотношения.**
    * Обычно Activity - отдельный целенаправленный модуль с чётким предназначением (набор номера, просмотр карты, сделать снимок или отправить электронное письмо). Хотя, разработчику ничего не мешает сделать более сложный интерфейс, который содержит в себе несколько сложных модулей. Обычно такие модули принято разделять на Fragments, которые имеют свой жизненный цикл, а так же могут быть добавлены или удалены по желанию. Важно помнить, что жизненный цикл Fragment напрямую зависит от жизненного цикла его Activity. То есть, когда действие приостановлено, то все фрагменты в нем также приостановлены, и когда Activity разрушена, все его фрагменты тоже.
  * Почему рекомендуется использовать только стандартный конструктор при создании Fragment?
  * Как взаимодействовать между двумя фрагментами без участия Activity??

### Service & AsyncTask
  * **Что такое Service?**
    * Service - компонент Android приложения, который может выполнять длительные операции в фоновом режиме и не содержит UI. Другой компонент приложения может запустить Service, который продолжит работу в фоновом режиме даже в том случае, когда пользователь перейдет в другое приложение.
    * Это не значит, что работает в другом потоке.
    * И это не значит, что вы сможете бесконечно долго что-то делать в фоне. Система убьёт вас, если вы будете злоупотреблять этим.
  * В каких случаях использование Services полезно?
  * **Чем отличаются Intent Service от Service?**
    * `Service` - базовый класс для всех сервисов, расширив который, можно создать любой сервис. Класс, который расширяет сервис, будет выполняться в Main Thread, поэтому, будет блокировать UI, если таковой имеется. Поэтому, нужно либо создавать отдельный поток в Service, либо использовать его для не слишком долгих операций.
    * `IntentService` - Подкласс Service. Он Используется, если в сервисе нужно выполнять какие-то тяжелые задачи, и мы не хотим сами возиться с асинхронностью. Принцип работы этого вида сервиса прост. Он создает новый поток для своей работы. Затем берет все Intent пришедшие ему в onStartCommand и отправляет их на обработку в этот поток. Как именно обрабатываются Intent – зависит от нас, т.к. мы сами кодим это в методе onHandleIntent.
  * **Какие типы Services бывают?**
    * `Backgound-Services` запущенны с помощью `context.startService(Intent)`. Они живут до тех пор, пока не вызвали stopSelf() или пока система не убила их.
    * `Foregraund-Services` - аналогично `Background`, но внутри себя вызвали `startForeground()` и показали уведомление в верхней панели. Системе нравится такой подход больше, потому что мы ничего не скрываем от пользователя.
    * `Bound-Services` - тоже запускаются через `context.startService(Intent)` и будут жить, пока есть привязанные клиенты (контролировать это можем `bindService()/unbindService()`). Используется для одно/двустороннего взаимодействия.
  * Какие режимы бывают у Services?
    * `onStartCommand()` возвращает режим, в котором будет запущен сервис.
      * `START_NO_STICKY` - если система убила сервис, то не перезапустит его.
      * `START_STICKY` - если система убила сервис, то перезапустит с intent=null.
      * `START_REDELIVER_INTENT` - так же, как и `START_STICKY`, но восстановит intent.
  * **Как остановить Service?**
    * Ответ зависит от того, с каким типом Service мы имеем дело. Если это `Background/Foregraund-Services` - нужно вызывать stopSelf() или ждать, пока система сама остановит его. Если это `Bounded-Services`, нужно вызывать unbindService().
  * Какой метод отличает его, чтобы служба работала в фоновом режиме?
  * **Какие проблемы могут возникнуть при использовании Services?**
    * С каждой версией Android всё больше заботится о батарейке, поэтому нещадно убивает приложения, а иногда не позволяет даже просто так запустить Background-Service. А ещё может убить (и убьёт) их раньше, чем мы закончим всё, что хотели, если приложение не активно и у него нет запущенных экранов. Поэтому, чтобы не возникало проблем, нужно уведомляять пользователя о долгих фоновых операциях с помощью `startForeground().`
  * Что такое AsyncTask?
  * Когда нужно использовать Service, а когда AsyncTask?
  * Какие есть проблемы у Activity и AsyncTask? Как их избежать или решить?

### Intent
  * Что такое Intent?
  * Что такое Action?
  * Что такое Intent Filter?
  * Что такое StikyIntent?
  * Что такое PendingIntent?
  * Объясните основные 3 случая, когда используется Intent.
  * Отличия Explicit Intent и Implicit Intent.

### Общие
  * Как происходит отрисовка любого (почти) View в Android?
  * Расскажите структуру Manifest.xml
  * Назовите основные компоненты Android приложения.
  * Что такое Context?
  * Что такое BroadcastReciever?
  * Что такое LocalBroadcastManager?
  * Что такое ContentProvider?
  * Какая разница между обычным растровым изображением и 9-patch изображениями?
  * Что за ошибка Application Not Respondin и как избежать её появления в приложении?
  * Разница между Serializable и Parcelable? Что лучше подходит для Android?
  * Что такое Views и ViewGroups и чем они отличаются?
  * Как создать приложение, которое поддерживает все размеры экрана?
  * Что такое утечки памяти? Приведите пример, когда это может произойти.
  * Назовите плюсы и минусы хранения данных в SharedPreferences.

### Архитектура
  * MVC
  * MVP
  * MVVM
  * MVI
  * Какие приемущества у MVVM над MVP?

### Retrofit2
  * В чём плюсы использования Retrofit вместо AsyncTask?
  * Как обрабатывать несколько сетевых вызовов с помощью Retrofit?

### RxJava2
  * В чём смысл и какие плюсы у реактивного программирования?
  * Основные принципы Observable и Observer
  * **Какие типы Observables существуют?**
    * Observable, Flowable, Single, Completable, Maybe
  * **Разница и сходство между Observable и Flowable**
    * В RxJava 2 источники представлены двумя основными типами — Flowable и Observable. Они устроены очень похоже. Оба генерируют от 0..n элементов. Оба могут завершаться успешно или с ошибкой. Зачем два разных типа для представления одной и той же структуры данных? Всё сводится к такой штуке, как backpressure. `Backpressure` позволяет замедлить работу источника данных. Существующие системы имеют ограниченные ресурсы. И с помощью backpressure мы можем сказать всем, кто шлёт нам данные, чтобы они притормозили, потому что мы не можем обрабатывать информацию с той скоростью, с которой она к нам поступает.
  * **Что такое Backpressure?**
    * Backpressure - это просто процесс работы с быстрым производителем предметов. Если Observable производит 1.000.000 элементов в секунду, то как обработчик будет обрабатывать подписчик, который может обрабатывать только 100 элементов в секунду? Класс Observable имеет неограниченный размер буфера, это означает, что он буферизует все и передает его подписчику, где вы получаете исключение OutOfMemoryException. Применяя Backpressure к потоку, можно обрабатывать элементы по мере необходимости, ненужные элементы можно отбрасывать или даже сообщать Observable, когда создавать и отправлять новые элементы.
  * **Какие бывают стратегии работы с Backpressure?**
    * `Drop` Это одна из самых простых стратегий. Мы просто указываем, что будем игнорировать все потоковые элементы, которые не могут быть обработаны, пока downstream не сможет принять больше из них.
    * `Buffer` Сохраняет элементы в буфере, пока они не будут обработаны.
    * `Latest` Если downstream не может справиться с потоком элементов, он прекращает излучать их и ждет, пока он снова не станет доступным. Он продолжает отбрасывать элементы, кроме последнего, который прибыл, и отправляет последний, когда снова становится доступным. В отличии от `Drop` гарантируется, что хотя бы элемент сохраняется.
  * **Что такое Single?**
    * `Single` - асинхронный источник одного элемента. Содержит либо один элемент, либо выдаёт ошибку. Он не поддерживает `Backpressure`. Можно представлять его себе как обычный метод.
  * **Что такое Completable?**
    * `Completable` ведет себя подобно `Observable`, за исключением того, что он может излучать только сигнал завершения или ошибки (нет onNext() или onSuccess(), как с другими реактивными типами)
  * **Что такое Maybe?**
    * `Maybe` представляет отложенное вычисление и выдачу одного значения, вообще никакого значения или исключения. Как и в `Observable`, работающий `Maybe` может быть остановлен через экземпляр `Disposable`, а так же может быть ленивым, может быть «горячим» или «холодным», синхронным или асинхронным.
  * **from, just — для чего и в чем отличия?**
    * `just()` - генерит только 1 излучение. Например, `Observable.just(new Integer[]{1, 2, 3})` сгенерит одно излучение с Observer callback `onNext(Integer[] integers)`
    * `from()` - генерит N излучений: берёт каждый элемент из листа. Например, `Observable.fromArray(new Integer[]{1, 2, 3})` сгенерит 3 излучения с Observer callback `onNext(Integer integer)`
  * map, flatMap, concatMap, switchMap — для чего и в чем отличия?
  * **Что делают observeOn() и subscribeOn()?**
    * `subscribeOn()` - с помощью этого оператора можно указать Scheduler, в котором будет выполняться процесс Observable до встречи observeOn() (в каком потоке будет работать наш источник данных)
    * `observeOn()` - применение этого оператора приводит к тому, что последующие операции над “излученными” данными будут выполняться с помощью Scheduler, переданным в этот метод (в каком потоке мы будем использовать наш результат)
    * Комбинируя эти два метода, можно добиться асинхронной загрузки данных из интернета и отображения их на экране в главном потоке приложения.
  * **Что будет, если вызвать несколько subscribeOn()? А если несколько observeOn()?**
    * Многократный вызов `subscribeOn()` ни к чему не приведёт - будет использован тот, который ближе всего к Observable источнику.
    * Каждый следующий вызов `observeOn()` будет приводить к тому, что последющие операции после использования данного метода будут выполняться в другом потоке, указанном Scheduler`ом.
  * **Что такое Producer?**
    * `Producer` - источник данных/значений для нашего Observable. Это может быть итератор, или что-то зацикленное над массивом. По сути, это все, что мы используем, чтобы получить значения и передать их в Observer.next().
  * **Что такое Cold Observable?**
    * Observable является «холодным», если его основной Producer создается и активируется во время подписки. Это означает, что если наблюдаемые являются функциями, то производитель создается и активируется путем вызова этой функции.
  * **Что такое Hot Observable?**
    * Observable является «горячим», если его основной производитель либо создан, либо активирован вне подписки.
  * **Разница между Hot Observable и Cold Observable?**
    * `Cold Observable`
      * Не рассылает объекты, пока на него не подписался хотя бы один подписчик;
      * Если observable имеет несколько подписчиков, то он будет рассылать всю последовательность объектов каждому подписчику.
      * `Пример` Любой Observable, созданный через Observable.create()
    * `Hot Observable`
      * Рассылает объекты, когда они появляются, независимо от того есть ли подписчики;
      * Каждый новый подписчик получает только новые объекты, а не всю последовательность.

### Room & SQL
  * **Что такое PrimaryKey?**
    * Аннотацией `@PrimaryKey` мы помечаем поле, которое будет ключом в таблице. Так же в таблице может быть несколько ключей, для этого нужно использовать `@Entity(primaryKeys = {"column1","column2"})`
  * Что такое ForeignKey?
    * Внешние ключи позволяют связывать таблицы между собой.
  * Как избавиться от проблемы вложенных классов?
    * Использовать аннотацию `@Embedded`, которая подскажет Room, что надо просто взять поля из указанного класса и считать их полями текущей таблицы.
  * Как из таблицы Markers достать уникальные элементы?

  * Что такое Pattern Matching в SQL?