📌 Для чего нужны сервисы ?

💬 Спрашивают в 40% собеседований

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

1️⃣ Выполнение фоновых задач

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

2️⃣ Воспроизведение музыки или выполнение других длительных операций

➕ Сервисы часто используются в приложениях для воспроизведения музыки или видео в фоне, позволяя пользователям продолжать использовать свое устройство для других задач.

3️⃣ Обработка сетевых запросов

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

4️⃣ Работа с внешними устройствами

➕ Сервисы могут использоваться для взаимодействия с внешними устройствами через Bluetooth или другие подобные технологии, выполняя длительные операции взаимодействия или мониторинга данных без необходимости активного вмешательства пользователя.

5️⃣ Выполнение периодических задач

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

6️⃣ Предоставление функциональности другим приложениям

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

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

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Чем MVVM отличается от MVP ?

💬 Спрашивают в 40% собеседований

MVVM (Model-View-ViewModel) и MVP (Model-View-Presenter) — это паттерны, используемые для разделения логики приложения на управляемые компоненты с целью упрощения разработки и обеспечения тестируемости. Хотя оба паттерна разделяют общую цель разделения ответственности в приложении, они реализуют её по-разному.

🤔 MVP (Model-View-Presenter)

➕ Model представляет собой слой данных и бизнес-логики приложения.
➕ View отвечает за отображение данных (UI) и перенаправляет пользовательские действия (например, нажатия кнопок) в Presenter.
➕ Presenter служит посредником между Model и View. Он содержит логику представления, реагирует на действия пользователя, обрабатывая их через Model и обновляя View.

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

🤔 MVVM (Model-View-ViewModel)

➕ Model аналогичен Model в MVP, содержит данные и бизнес-логику.
➕ View отображает пользовательский интерфейс и перенаправляет действия пользователя на ViewModel. В отличие от MVP, View в MVVM может напрямую обращаться к ViewModel через привязку данных (data binding).
➕ ViewModel служит абстракцией View и содержит логику представления. ViewModel взаимодействует с Model, обрабатывает данные и подготавливает их для отображения. Благодаря механизму привязки данных, ViewModel может автоматически обновлять View без необходимости напрямую взаимодействовать с ним.

🤔 Основное отличие MVVM от MVP заключается в том, как обновляется View:

➕ В MVVM обновления View происходят автоматически через механизмы привязки данных. Это уменьшает количество кода, необходимого для ручного управления UI, и делает код более чистым и понятным.
➕ В MVP Presenter активно управляет View, что требует более явного обновления пользовательского интерфейса в ответ на изменения данных или состояния приложения.

MVVM и MVP — это паттерны проектирования для разделения логики приложения, но они отличаются тем, как организовано взаимодействие между компонентами. MVVM использует привязку данных для автоматического обновления View, что упрощает управление интерфейсом. MVP требует, чтобы Presenter явно управлял View, что может привести к более сложному коду для управления пользовательским интерфейсом.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое inline функции ?

💬 Спрашивают в 33% собеседований

Inline функции — это специальный тип функций, при компиляции которых код функции встраивается в место её вызова. Это значит, что при вызове inline функции не происходит создание нового стека вызовов; вместо этого компилятор копирует код функции непосредственно в место вызова. Этот механизм особенно полезен при использовании функций высшего порядка, которые принимают функции в качестве параметров или возвращают их в результате.

🤔 Для чего они нужны:

1️⃣ Уменьшение накладных расходов на вызов функций: Поскольку не происходит дополнительных вызовов функций и не создаётся новый стек, использование inline функций может значительно уменьшить накладные расходы, особенно в критически важных с точки зрения производительности участках кода.

2️⃣ Улучшение производительности при использовании лямбда-выражений: Kotlin использует объекты для представления лямбда-выражений и анонимных функций, что может привести к дополнительной нагрузке на сборщик мусора и память. Inline функции позволяют избежать этого, поскольку лямбды, переданные в inline функции, также инлайнятся.

3️⃣ Возможность использования некоторых специфичных возможностей языка: Например, только inline функции могут использовать реифицированные типовые параметры (reified type parameters), что позволяет избежать ограничений, связанных с типовой стиранием во время выполнения и работать с типами как с обычными классами.

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

➕Допустим, у нас есть следующая inline функция:

inline fun <reified T> printIfTypeMatch(item: Any) {
    if (item is T) {
        println(item)
    }
}

// Вызов функции
printIfTypeMatch<String>("Hello, inline functions!")

При компиляции кода компилятор Kotlin "встраивает" код функции printIfTypeMatch в место её вызова, избегая создания объекта для лямбды и вызова функции во время выполнения.

➕ Использование inline функций увеличивает размер скомпилированного кода, так как код функции копируется в каждое место её вызова.
➕ Не все функции стоит делать inline. Преимущества инлайнинга наиболее заметны для небольших функций и функций, принимающих лямбда-выражения.
➕ Inline функции могут содержать реифицированные типовые параметры, что невозможно в обычных функциях из-за стирания типов во время выполнения в JVM.

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Для чего нужен Manifest ?

💬 Спрашивают в 33% собеседований

Файл AndroidManifest.xml играет роль центрального конфигурационного файла, который содержит важную информацию о приложении для Android системы. В нём объявляются основные компоненты приложения, требуемые разрешения, поддерживаемые устройственные конфигурации и другие метаданные. Вот несколько ключевых аспектов, для которых он необходим:

1️⃣ Объявление компонентов приложения

➕ Manifest файл используется для объявления компонентов приложения, таких как Activity, Service, BroadcastReceiver, и ContentProvider. Для каждого из этих компонентов можно указать дополнительные настройки, например, интент-фильтры для Activity, которые определяют, какие интенты они могут обрабатывать.

2️⃣ Запрос системных разрешений

➕ Для доступа к защищённым частям API и функционалу устройства, например, камере, списку контактов или геопозиции, приложению необходимо запрашивать соответствующие разрешения. В AndroidManifest.xml указываются эти разрешения с помощью элемента <uses-permission>.

3️⃣ Определение уровня API

➕ Можно указать минимальный и целевой уровень API Android, с которым совместимо приложение. Это позволяет системе предотвращать установку приложения на несовместимых устройствах и оптимизировать его поведение для устройств с разными версиями Android.

4️⃣ Объявление библиотек

➕ Если приложение использует специализированные библиотеки оборудования (например, OpenGL ES), в нем необходимо объявить соответствующие функции и требования к оборудованию с помощью элементов <uses-feature> и <uses-library>.

5️⃣ Установка фильтров интентов (`<intent-filter>`)

➕ Объявляют, какие действия, данные или категории интентов может принимать компонент, позволяя другим приложениям взаимодействовать с ним. Например, Activity может объявить, что оно способно обрабатывать интенты для просмотра веб-страниц.

6️⃣ Конфигурация приложения

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

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что известно про корутины ?

💬 Спрашивают в 33% собеседований

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

🤔 Основные характеристики и преимущества:

1️⃣ Легковесность: Корутины позволяют запускать тысячи параллельных операций, потребляя гораздо меньше ресурсов по сравнению с традиционными потоками. Это достигается благодаря тому, что корутины не привязаны к системным потокам и могут переключаться между ними.

2️⃣ Понятный асинхронный код: С помощью корутин можно писать асинхронный код, который выглядит как обычный синхронный код, что упрощает его понимание и поддержку.

3️⃣ Управление асинхронностью: Корутины предоставляют механизмы для управления асинхронными операциями, такие как отмена операций, тайм-ауты и обработка ошибок.

4️⃣ Эффективность: Поскольку корутины уменьшают необходимость в использовании обратных вызовов и упрощают асинхронный код, они могут сделать приложение более отзывчивым и эффективным.

Ключевые компоненты:

➕ Coroutine Scope — определяет контекст выполнения корутины, управляя её жизненным циклом.
➕ Coroutine Context — содержит различные элементы, такие как диспетчеры, которые определяют, в каком потоке будет выполняться корутина.
➕ Dispatchers — помогают управлять потоками, на которых выполняются корутины. Например, Dispatchers.IO предназначен для ввода-вывода, Dispatchers.Main используется для взаимодействия с пользовательским интерфейсом.
➕ Builders — функции, которые используются для запуска корутин, такие как launch и async, последняя из которых позволяет получить результат асинхронной операции.

➕ Пример:

import kotlinx.coroutines.*

fun main() = runBlocking { // Создает корутину верхнего уровня
    launch { // Запускает новую корутину внутри блока runBlocking
        delay(1000L) // Неблокирующая задержка на 1 секунду (1000 миллисекунд)
        println("World!") // Печать после задержки
    }
    println("Hello,") // runBlocking ждет, пока вложенная корутина не завершится
}

Этот код демонстрирует запуск корутины с использованием launch, которая выводит "Hello," немедленно, затем ждет секунду перед выводом "World!".

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Как работает hashmap ?

💬 Спрашивают в 33% собеседований

HashMap — это структура данных, которая использует хеш-таблицу для хранения пар "ключ-значение". Она позволяет выполнять операции вставки, удаления и поиска элементов с почти постоянным временем выполнения, что делает её очень эффективной для определённых задач. Вот как она работает:

🤔 Основы работы

1️⃣ Хеширование ключей: Каждый раз, когда добавляется новая пара "ключ-значение", HashMap использует хеш-функцию для вычисления хеш-кода ключа. Хеш-код затем используется для определения индекса в массиве, где будет храниться значение. Это позволяет быстро находить значения по ключам.

2️⃣ Разрешение коллизий: Два разных ключа могут иметь одинаковый хеш-код или хеш-коды, которые приводят к одному и тому же индексу в массиве (это называется коллизией). HashMap разрешает такие коллизии, сохраняя эти элементы в одной "корзине" или "ячейке" в виде списка (до Java 8 использовались связанные списки, начиная с Java 8 — сбалансированные деревья при большом количестве коллизий в одной корзине).

3️⃣ Вставка и поиск: При вставке нового элемента HashMap вычисляет индекс корзины для ключа и помещает значение в эту корзину. При поиске значения по ключу HashMap снова вычисляет индекс, находит соответствующую корзину и затем перебирает элементы в ней, чтобы найти нужное значение.

4️⃣ Масштабирование: Когда количество элементов в HashMap достигает определённого порога заполнения (загрузки), размер массива увеличивается, и все существующие элементы перераспределяются в новом массиве. Это необходимо для поддержания эффективности операций вставки и поиска.

Представьте, что у вас есть HashMap, где ключи — это имена пользователей, а значения — это их email. Когда вы добавляете новую пару "ключ-значение" ("John Doe", "[email protected]"), HashMap выполняет следующие действия:

1️⃣Вычисляет хеш-код для "John Doe".
2️⃣Использует хеш-код, чтобы найти индекс корзины, где должен быть сохранён email.
3️⃣Добавляет "[email protected]" в корзину этого индекса.

Когда вы пытаетесь найти email по имени "John Doe", HashMap снова вычисляет хеш-код для "John Doe", находит соответствующую корзину и возвращает сохранённый в ней email.

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что известно про типы any, unit, nothing в Kotlin ?

💬 Спрашивают в 33% собеседований

Существуют специальные типы Any, Unit и Nothing, которые имеют уникальные цели и применения в языке программирования:

🤔 Any

➕ Является корневым типом для всех ненулевых типов в Kotlin, аналогичным Object. Любой объект, за исключением null, наследуется от Any. Этот тип обычно используется там, где требуется представление любого возможного значения, за исключением null. Any определяет несколько базовых методов, таких как equals(), hashCode() и toString(), которые могут быть переопределены.

fun printAnyObject(obj: Any) {
    println(obj.toString())
}

🤔 Unit

➕ Аналогичен void, но в отличие от void, он является полноценным объектом. Функции в Kotlin, которые не возвращают значимый результат, на самом деле возвращают Unit. Этот тип обычно используется для указания, что функция выполняет действие, но не возвращает значение. Хотя возвращаемый тип Unit обычно опускается, его можно указать явно.

fun printHello(): Unit {
    println("Hello, World!")
}

🤔 Nothing

➕ Это тип, который не имеет значений. Он используется для обозначения "невозможности", то есть ситуаций, когда функция никогда корректно не завершает своё выполнение. Например, функция может вечно зацикливаться или всегда выбрасывать исключение. Его указание в качестве возвращаемого типа функции помогает понять, что эта точка кода недостижима.

fun failWithErrorMessage(message: String): Nothing {
    throw IllegalArgumentException(message)
}

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

➕Any — это базовый тип для всех объектов в Kotlin, кроме null.
➕Unit указывает, что функция не возвращает полезное значение, аналогично void в других языках программирования, но является объектом.
➕Nothing используется для обозначения "невозможности" выполнения кода после определённой точки, например, после выброса исключения.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Зачем нужен класс nothing ?

💬 Спрашивают в 33% собеседований

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

1️⃣ Обозначение "недостижимого" кода

➕В некоторых случаях логика приложения может предусматривать, что определённая функция или участок кода никогда не вернёт управление (например, всегда выбрасывает исключение или выполняет бесконечный цикл). Указание возвращаемого типа Nothing ясно демонстрирует этот намеренный аспект поведения функции.

2️⃣ Помощь в статическом анализе кода

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

3️⃣ Улучшение читабельности и понимания кода

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

➕ Рассмотрим функцию, которая используется для обработки ошибок и всегда выбрасывает исключение:

fun throwError(message: String): Nothing {
    throw IllegalArgumentException(message)
}

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

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌Что такое сериализация?

💬 Спрашивают в 7% собеседований

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

🤔 Почему это нужно?
Когда мы работаем с объектами в приложении, они находятся в оперативной памяти. Но, если нужно сохранить состояние объекта между запусками программы или передать его через сеть, нам нужно как-то его "упаковать". Вот тут и приходит на помощь сериализация. Например, вы можете сериализовать объект, сохранить его в файл, а потом прочитать этот файл и десериализовать объект обратно.

🤔 Как это используется?

В Android для сериализации часто используется интерфейс Serializable или Parcelable. Вот пример использования Serializable:

import java.io.Serializable;

public class User implements Serializable {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // геттеры и сеттеры
}

Чтобы сериализовать объект User и сохранить его в файл, можно сделать так:

User user = new User("John", 30);
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
    oos.writeObject(user);
} catch (IOException e) {
    e.printStackTrace();
}

Для десериализации объекта из файла:

try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
    User user = (User) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}

🤔 Пример использования `Parcelable` в Android:

Parcelable предпочтительнее в Android, так как он быстрее работает по сравнению с Serializable.

import android.os.Parcel;
import android.os.Parcelable;

public class User implements Parcelable {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    protected User(Parcel in) {
        name = in.readString();
        age = in.readInt();
    }

    public static final Creator<User> CREATOR = new Creator<User>() {
        @Override
        public User createFromParcel(Parcel in) {
            return new User(in);
        }

        @Override
        public User[] newArray(int size) {
            return new User[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
    }

    // геттеры и сеттеры
}

Теперь можно передавать объект User между активити:

Intent intent = new Intent(this, AnotherActivity.class);
User user = new User("John", 30);
intent.putExtra("user", user);
startActivity(intent);

И получить его в AnotherActivity:

User user = getIntent().getParcelableExtra("user");

🤔 Кратко:
Сериализация – это способ сохранения или передачи объектов, преобразовывая их в поток байтов. В Android можно использовать Serializable или Parcelable для этих целей.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Как подключить BroadcastReceiver, чтобы он смог получать сообщения?

💬 Спрашивают в 7% собеседований

Подключение BroadcastReceiver в Android состоит из двух основных шагов: создание самого ресивера и его регистрация. Ресивер можно зарегистрировать как статически в манифесте, так и динамически в коде.

1️⃣ Создание BroadcastReceiver

Создадим простой BroadcastReceiver, который будет реагировать на определённое событие, например, на получение SMS.

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class MyBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context, "Сообщение получено!", Toast.LENGTH_SHORT).show();
    }
}

2️⃣ Регистрация ресивера

2️⃣🔤1️⃣ Статическая регистрация в манифесте

Можно зарегистрировать ресивер в файле AndroidManifest.xml. Это удобно, когда вы хотите, чтобы ресивер всегда был активен и слушал определённые системные события, например, перезагрузку устройства или получение SMS.

<manifest xmlns:android="https://schemas.android.com/apk/res/android"
    package="com.example.myapp">

    <application
        android:allowBackup="true"
        android:label="@string/app_name"
        android:icon="@mipmap/ic_launcher"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

        <receiver android:name=".MyBroadcastReceiver">
            <intent-filter>
                <action android:name="android.provider.Telephony.SMS_RECEIVED" />
            </intent-filter>
        </receiver>

    </application>

</manifest>

2️⃣🔤2️⃣ Динамическая регистрация в коде

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

import android.content.IntentFilter;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    private MyBroadcastReceiver myBroadcastReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        myBroadcastReceiver = new MyBroadcastReceiver();
    }

    @Override
    protected void onStart() {
        super.onStart();
        IntentFilter filter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");
        registerReceiver(myBroadcastReceiver, filter);
    }

    @Override
    protected void onStop() {
        super.onStop();
        unregisterReceiver(myBroadcastReceiver);
    }
}

В этом примере ресивер регистрируется в методе onStart() и отписывается в методе onStop(). Это позволяет ресиверу быть активным только тогда, когда активность видима.

🤔 Кратко:

Чтобы подключить BroadcastReceiver, создайте его и зарегистрируйте либо в манифесте, либо в коде. Статическая регистрация через манифест делает ресивер активным всегда, а динамическая регистрация в коде позволяет контролировать время его активности.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых