Что такое dp ?
Спросят с вероятностью 13%

dp означает "density-independent pixels" или "пиксели, не зависящие от плотности". Это виртуальная единица измерения, которая используется для обеспечения одинакового визуального размера элементов пользовательского интерфейса на экранах с различной плотностью пикселей. Это важно, поскольку устройства Android могут иметь различные размеры и разрешения экранов, и использование dp помогает создать консистентный пользовательский интерфейс на всех этих устройствах.

Как он работает?

1️⃣Базовый расчёт: Базовая логика такова, что 1 dp равен одному пикселю на экране с плотностью 160 точек на дюйм (dpi). Это плотность соответствует "среднему" уровню, который называется "mdpi" в терминах Android. На таком экране:
✅1 dp = 1 px

2️⃣Масштабирование на других устройствах: На устройствах с более высокой или ниже плотностью экрана dp масштабируются соответственно:
✅На устройстве с плотностью 320 dpi (high density, hdpi), 1 dp = 2 px.
✅На устройстве с плотностью 240 dpi (high density, hdpi), 1 dp = 1.5 px.
✅И так далее.

Зачем его использовать?

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

При определении макета в XML-файлах Android вы можете указать размеры в dp, чтобы обеспечить независимость от плотности:

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Click me!"
    android:padding="16dp" />

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

В чем особенность sealed классов ?
Спросят с вероятностью 20%

Особенность запечатанных классов (sealed class) заключается в ограничении иерархии наследования: все их подклассы должны быть объявлены в том же файле, что и сам запечатанный класс. Это делает его идеальным инструментом для создания ограниченных иерархий классов, в которых требуется строго контролировать набор возможных подтипов, особенно при моделировании состояний или результатов операций в виде дерева наследования.

Ключевые особенности и преимущества:

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

2️⃣Поддержка выразительного механизма сопоставления с образцом: В сочетании с when выражением, он позволяет эффективно и безопасно обрабатывать различные типы, гарантируя, что все случаи будут обработаны. Компилятор Kotlin будет проверять, обработаны ли все возможные подклассы в выражении when, что обеспечивает дополнительную безопасность при выполнении кода.

3️⃣Улучшенная поддержка в IDE: Получают дополнительную поддержку от IDE, например, предупреждения о необработанных случаях в when выражениях, что помогает предотвратить ошибки во время компиляции.

4️⃣Гибкость в определении подклассов: Подклассы sealed class могут быть как другими sealed class, так и обычными классами или объектами. Это предоставляет гибкость в организации иерархии типов.

5️⃣Использование в функциональном программировании: Особенно полезны в функциональном программировании для представления алгебраических типов данных (ADT), где тип может быть одним из ограниченного набора вариантов. Это позволяет строить более предсказуемые и надежные системы типов.

sealed class Result<out R> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
}

fun handleResult(result: Result<Int>) = when (result) {
    is Result.Success -> println("Success with data ${result.data}")
    is Result.Error -> println("Error with exception ${result.exception}")
}

В этом примере Result является sealed class, который имеет два подкласса: Success и Error. Использование sealed class гарантирует, что функция handleResult обрабатывает все возможные варианты Result, что обеспечивает безопасность и предсказуемость выполнения кода.

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Что известно про жизненные циклы View ?
Спросят с вероятностью 20%

Каждый виджет (View) и ViewGroup имеет свой жизненный цикл, который тесно связан с жизненным циклом активности или фрагмента, в котором этот виджет используется. Жизненный цикл в большей степени касается этапов создания, макетирования (layout), отрисовки (drawing) и его уничтожения. В отличие от жизненного цикла Activity или Fragment, у View нет встроенных коллбэков, как onPause() или onResume(), для управления этапами их жизненного цикла. Тем не менее, понимание процессов, происходящих с View, важно для эффективной разработки пользовательского интерфейса.

Основные этапы жизненного цикла:

1️⃣Инфляция (Inflation): Создаются из XML файлов с помощью процесса, называемого инфляцией. В этот момент происходит чтение XML и создание объектов View в памяти.

2️⃣Прикрепление к окну (Attachment): После создания View прикрепляются к окну. Метод onAttachedToWindow() вызывается, когда View добавляется к окну. Здесь View начинает быть частью видимого пользовательского интерфейса.

3️⃣Макетирование (Layout): На этапе макетирования для каждой View определяются размеры и позиция в окне. Метод onLayout() вызывается в ViewGroup для расположения дочерних View. Для индивидуальных View метод onMeasure() определяет размеры View.

4️⃣Рисование (Drawing): Когда макет готов, начинается процесс рисования. Метод onDraw() вызывается для отрисовки содержимого View на экране.

5️⃣Обновление (Update): Если данные, отображаемые в View, изменяются или если требуется изменить внешний вид, View может быть обновлена. Для этого можно использовать методы invalidate() (для перерисовки) или requestLayout() (если изменения затрагивают макет).

6️⃣Отсоединение от окна (Detachment): Когда View удаляется из окна, например, при закрытии активности, вызывается метод onDetachedFromWindow(). Это последний этап в жизненном цикле View, где можно освободить ресурсы.

Рассмотрение слушателей событий:

Хотя эти этапы описывают основные аспекты жизненного цикла View, важную роль играют также слушатели событий (event listeners), через которые View может реагировать на взаимодействия пользователя, такие как касания или клики.

Важные моменты:

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Зачем нужен crossinline ?
Спросят с вероятностью 13%

Ключевое слово crossinline используется в контексте встроенных функций (inline functions) и имеет важное значение для корректного управления лямбда-выражениями, передаваемыми в эти функции как параметры. Встроенные функции позволяют избежать затрат на вызов функций и создание объектов лямбда-выражений при каждом вызове, что может улучшить производительность кода, особенно в критичных сценариях. Однако использование inline функций влечёт за собой определённые ограничения и возможности, среди которых и возможность "невстроенного" вызова лямбды.

Зачем он нужен

Необходим для обеспечения безопасности и корректности программы при передаче лямбда-выражений, которые не должны содержать нелокальных возвратов (например, возвратов из внешней функции), в inline функции. Это ключевое слово гарантирует, что лямбда-выражение не будет использовать нелокальный возврат, что позволяет безопасно встраивать лямбды, даже если они используются в контексте, где нелокальные возвраты могут привести к неожиданному поведению или ошибкам.

Рассмотрим следующий код без использования crossinline:

inline fun runOperation(f: () -> Unit) {
    f()
}

fun main() {
    runOperation {
        println("Operation started")
        return // Нелокальный возврат из main
    }
    println("Operation finished") // Этот код не выполнится
}

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

Слово crossinline позволяет избежать таких проблем:

inline fun runOperation(crossinline f: () -> Unit) {
    val localFunction = object {
        fun run() {
            f()
        }
    }
    localFunction.run()
}

fun main() {
    runOperation {
        println("Operation started")
        //return // Компилятор выдаст ошибку, если раскомментировать
    }
    println("Operation finished") // Этот код выполнится
}

В этом примере, использование crossinline запрещает нелокальные возвраты в лямбда-выражении, передаваемом в runOperation. Таким образом, код становится предсказуемым и безопасным для использования в различных контекстах.

Использование crossinline важно для разработчиков, которые стремятся создать безопасный и надёжный код при использовании inline функций с лямбда-выражениями. Оно предотвращает непреднамеренные и потенциально вредоносные нелокальные возвраты, улучшая модульность и повторное использование кода.

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Как связан жизненный цикл фрагментов с Activity ?
Спросят с веротяностью 20%

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

Когда активити создаётся (вызывается onCreate()), она может начать транзакцию фрагментов для добавления, удаления или замены фрагментов в своём контейнере. Каждый фрагмент проходит через свои собственные этапы жизненного цикла (например, onAttach(), onCreate(), onCreateView(), onActivityCreated(), onStart(), onResume(), и так далее), которые синхронизированы с жизненным циклом активити. Например, когда активити переходит в состояние "возобновлено" (onResume()), все присоединённые к ней фрагменты также переходят в это состояние.

Если активити останавливается или уничтожается, все фрагменты внутри этой активити также пройдут через соответствующие этапы остановки или уничтожения. Например, если активити останавливается (вызывается onStop()), все вложенные фрагменты также получат вызов onStop().

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

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Для чего нужен let ?
Спросят с вероятностью 13%

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

Основные цели использования let:

1️⃣Обработка nullable-значений: Часто используется для безопасной работы с переменными, которые могут быть null. С let, вы можете выполнить блок кода, если переменная не null, минимизируя риск NullPointerException.

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

3️⃣Цепочки вызовов: Часто используется для создания цепочек вызовов методов, что делает код более читаемым и удобным.

Примеры:

1️⃣Обработка nullable-значений

val name: String? = getName() // Функция может вернуть null

name?.let {
    println("Имя: $it") // Код внутри let выполнится только если name не null
}

В этом примере, если name не null, то выполняется печать имени. Использование it внутри let является стандартным именем для доступа к текущему объекту name.

2️⃣Цепочки вызовов

val result = person?.let {
    println("Обработка персоны ${it.name}")
    it.process() // Обрабатываем person и возвращаем результат
} ?: "Default Value"

Здесь let используется для выполнения блока кода, если person не null. После выполнения блока кода, результат (или "Default Value", если person был null) присваивается переменной result.

3️⃣Ограничение области видимости

val message = getMessage().let {
    "Получено сообщение: $it" // Преобразуем сообщение
}
println(message)

В этом случае let используется для создания строки message, основанной на результате функции getMessage(). Область видимости временной переменной it ограничена блоком let.

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Канал приближается к 20к подписчиков, а здесь так и нет нормального контент плана 😒

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

Важно глубокое понимание IT индустрии, вы должны иметь опыт работы в ней

Если интересно отправьте мне свое резюме @kivaiko

Что означает в Android-разработке подход Single Activity ?
Спросят с веротяностью 20%

Подход Single Activity представляет собой архитектурный подход, при котором вся пользовательская интеракция с приложением происходит в рамках одной активити (Activity), а различные экраны реализуются с помощью фрагментов (Fragment). Этот подход отходит от традиционной модели, в которой для каждого нового экрана создается отдельная активити. Вместо этого он использует одну активити как контейнер для всех пользовательских интерфейсов и навигации между экранами.

Зачем он нужен?

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

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

Улучшение пользовательского опыта: Single Activity позволяет создать более плавную и непрерывную навигацию для пользователя, т.к. переходы и анимации между экранами могут быть более естественными и менее затратными по времени.

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

В приложении с одной активити все экраны приложения реализуются как фрагменты. Для управления этими фрагментами и навигации между ними обычно используется Jetpack Navigation Component. Этот компонент предоставляет навигационный граф, который описывает все возможные пути пользователя по приложению. Разработчики могут легко настраивать анимации переходов, передавать данные между экранами и управлять стеком навигации, всё в контексте одной активити.

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Что такое лямбды с точки зрения синтаксиса в Java и Kotlin ?
Спросят с вероятностью 13%

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

Лямбда-выражения

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

Синтаксис:

(parameters) -> expression

или

(parameters) -> { statements; }

Примеры:

1️⃣Лямбда без параметров:

  () -> System.out.println("Hello, World!");
   

2️⃣Лямбда с одним параметром:

(int a) -> a * a
   

3️⃣Лямбда с несколькими параметрами:
(int a, int b) -> a + b
   

4️⃣Лямбда с телом, содержащим несколько выражений:
 (String s) -> {
       System.out.println(s);
       return s.length();
   }
   

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

Лямбда-выражения

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

Синтаксис:

{ parameters -> code body }

Примеры:

1️⃣Лямбда без параметров:

      { println("Hello, World!") }
   

2️⃣Лямбда с одним параметром:

      { a: Int -> a * a }
   

3️⃣Лямбда с несколькими параметрами:

      { a: Int, b: Int -> a + b }
   

4️⃣Лямбда с телом, содержащим несколько выражений:

      { s: String ->
       println(s)
       s.length
   }
   

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Что для такое качественный код ?
Спросят с веротяностью 20%

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

Читаемость

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

Поддерживаемость

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

Производительность

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

Надежность

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

Тестируемость

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

Совместимость и безопасность

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

Пример качественного кода — это функция, которая загружает данные из сети:

public void fetchData(String url, Callback callback) {
    new Thread(() -> {
        try {
            // Имитация загрузки данных
            Thread.sleep(2000);
            String result = "Успешно загружено";
            callback.onSuccess(result);
        } catch (InterruptedException e) {
            callback.onError(e);
        }
    }).start();
}

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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

Что такое Hilt и для чего он используется ?
Спросят с вероятностью 13%

Hilt — это фреймворк для внедрения зависимостей (Dependency Injection, DI), разработанный командой Google, специально для платформы Android. Он основан на популярном DI фреймворке Dagger и предназначен для упрощения процесса внедрения зависимостей в Android-приложениях. Предоставляет стандартизированную и упрощённую систему управления зависимостями, что значительно облегчает конфигурацию и управление жизненным циклом компонентов приложения.

Для чего он используется?

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

2️⃣Управление жизненным циклом: Автоматически управляет жизненным циклом зависимостей в соответствии с жизненным циклом Android компонентов, таких как активности, фрагменты, сервисы и т.д. Это уменьшает риск утечек памяти и других проблем, связанных с неправильным управлением ресурсами.

3️⃣Улучшенная тестируемость: Облегчает создание изолированных модульных тестов за счёт предоставления инструментов для замещения реальных зависимостей тестовыми аналогами (mock или fake).

4️⃣Интеграция с Jetpack: Эффективно работает с другими библиотеками Jetpack, такими как ViewModel, WorkManager и т.д., предоставляя встроенные аннотации и классы для их интеграции.

Чтобы использовать Hilt, необходимо добавить соответствующие зависимости в файл build.gradle и аннотировать Android-компоненты и классы зависимостей соответствующими аннотациями Hilt.

// Добавление зависимостей в build.gradle
dependencies {
    implementation "com.google.dagger:hilt-android:2.38.1"
    kapt "com.google.dagger:hilt-android-compiler:2.38.1"
}

// Application класс, аннотированный @HiltAndroidApp
@HiltAndroidApp
class MyApplication : Application()

// Использование Hilt для внедрения зависимости в Activity
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject lateinit var analytics: AnalyticsAdapter
}

// Определение модуля и предоставление зависимости
@Module
@InstallIn(ActivityComponent::class)
object AnalyticsModule {
    @Provides
    fun provideAnalyticsAdapter(): AnalyticsAdapter {
        return AnalyticsAdapterImpl()
    }
}

Hilt значительно упрощает управление зависимостями, сокращает количество кода, необходимого для настройки и использования Dagger, и помогает создавать более чистые, тестируемые и удобные в обслуживании приложения. Благодаря его интеграции с жизненным циклом Android и поддержке Jetpack, Hilt становится отличным выбором для современной Android разработки.

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 1078 вопросов на Android разработчика. Ставь 👍 если нравится контент

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