Вопросы на собеседовании по Android

class MyFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater, 
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.fragment_my, container, false)
    }
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // Настройка UI и инициализация компонентов
        view.findViewById<Button>(R.id.button).setOnClickListener {
            // Обработка клика
        }
    }
}

// Создание фрагмента с аргументами
fun newInstance(data: String): DetailFragment {
    val fragment = DetailFragment()
    val args = Bundle()
    args.putString("KEY_DATA", data)
    fragment.arguments = args
    return fragment
}
 
// Получение данных в фрагменте
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    arguments?.let {
        val data = it.getString("KEY_DATA")
        // Использовать data
    }
}

// Общая ViewModel
class SharedViewModel : ViewModel() {
    val selectedItem = MutableLiveData<String>()
    
    fun select(item: String) {
        selectedItem.value = item
    }
}
 
// В первом фрагменте
private lateinit var viewModel: SharedViewModel
 
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    viewModel = ViewModelProvider(requireActivity()).get(SharedViewModel::class.java)
    // При клике на элемент
    viewModel.select("выбранные данные")
}
 
// Во втором фрагменте
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    viewModel = ViewModelProvider(requireActivity()).get(SharedViewModel::class.java)
    viewModel.selectedItem.observe(viewLifecycleOwner) { item ->
        // Обновляем UI на основе полученных данных
    }
}

supportFragmentManager.beginTransaction()
    .replace(R.id.container, newFragment)
    .addToBackStack(null)
    .commit()

// В XML-навигационном графе
<navigation>
    <fragment android:id="@+id/listFragment" android:name=".ListFragment">
        <action android:id="@+id/action_to_detail" app:destination="@id/detailFragment" />
    </fragment>
    <fragment android:id="@+id/detailFragment" android:name=".DetailFragment" />
</navigation>
 
// В коде для навигации
findNavController().navigate(R.id.action_to_detail)

companion object {
    // Утечка!
    private var staticViewReference: View? = null
}

// Потенциальная утечка, если обработчик живёт дольше фрагмента
SomeManager.getInstance().registerCallback(object : Callback {
    override fun onEvent() {
        updateUI() // Ссылка на фрагмент
    }
})

override fun onDestroyView() {
    super.onDestroyView()
    SomeManager.getInstance().unregisterCallback(callback)
    binding = null // Очистка ссылки на binding
}

// Настройка анимации перехода
val options = ActivityOptions.makeSceneTransitionAnimation(
    this,
    Pair(imageView, "shared_image")
)
val intent = Intent(this, DetailActivity::class.java)
startActivity(intent, options.toBundle())

// Пример интерфейса View в MVP
interface MainView {
    fun showLoading()
    fun hideLoading()
    fun showUsers(users: List<User>)
    fun showError(message: String)
}
 
// Пример Presenter
class MainPresenter(
    private val view: MainView,
    private val repository: UserRepository
) {
    fun loadUsers() {
        view.showLoading()
        repository.getUsers(object : Callback<List<User>> {
            override fun onSuccess(data: List<User>) {
                view.hideLoading()
                view.showUsers(data)
            }
 
            override fun onError(error: Exception) {
                view.hideLoading()
                view.showError(error.message ?: "Неизвестная ошибка")
            }
        })
    }
}

// ViewModel в MVVM
class UserViewModel(private val repository: UserRepository) : ViewModel() {
    private val _users = MutableLiveData<List<User>>()
    val users: LiveData<List<User>> = _users
 
    private val _loading = MutableLiveData<Boolean>()
    val loading: LiveData<Boolean> = _loading
 
    private val _error = MutableLiveData<String?>()
    val error: LiveData<String?> = _error
 
    fun loadUsers() {
        _loading.value = true
        viewModelScope.launch {
            try {
                val result = repository.getUsers()
                _users.value = result
                _error.value = null
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _loading.value = false
            }
        }
    }
}

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    
    viewModel.users.observe(viewLifecycleOwner) { users ->
        adapter.submitList(users)
    }
    
    viewModel.loading.observe(viewLifecycleOwner) { loading ->
        progressBar.isVisible = loading
    }
    
    viewModel.error.observe(viewLifecycleOwner) { error ->
        error?.let { errorTextView.text = it }
        errorContainer.isVisible = error != null
    }
    
    viewModel.loadUsers()
}

// Состояние UI
data class UiState(
    val users: List<User> = emptyList(),
    val isLoading: Boolean = false,
    val error: String? = null
)
 
// Действия
sealed class UserIntent {
    object LoadUsers : UserIntent()
    object RefreshUsers : UserIntent()
    data class FilterUsers(val query: String) : UserIntent()
}
 
// ViewModel в стиле MVI
class UserViewModel(private val repository: UserRepository) : ViewModel() {
    private val _state = MutableStateFlow(UiState())
    val state: StateFlow<UiState> = _state.asStateFlow()
 
    fun processIntent(intent: UserIntent) {
        when (intent) {
            is UserIntent.LoadUsers -> loadUsers()
            is UserIntent.RefreshUsers -> loadUsers(forceRefresh = true)
            is UserIntent.FilterUsers -> filterUsers(intent.query)
        }
    }
 
    private fun loadUsers(forceRefresh: Boolean = false) {
        viewModelScope.launch {
            _state.update { it.copy(isLoading = true, error = null) }
            try {
                val users = repository.getUsers(forceRefresh)
                _state.update { it.copy(users = users, isLoading = false) }
            } catch (e: Exception) {
                _state.update { it.copy(isLoading = false, error = e.message) }
            }
        }
    }
 
    private fun filterUsers(query: String) {
        // Логика фильтрации
    }
}

val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
    .setInputData(workDataOf("key" to "value"))
    .setConstraints(Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .build())
    .build()
 
WorkManager.getInstance(context).enqueue(workRequest)
 
// Определение Worker
class MyWorker(context: Context, params: WorkerParameters) 
    : Worker(context, params) {
    
    override fun doWork(): Result {
        val inputData = inputData.getString("key") ?: ""
        
        // Выполняем долгую операцию
        // ...
        
        // Возвращаем результат
        val outputData = workDataOf("result" to "completed")
        return Result.success(outputData)
    }
}

// Запись данных
val sharedPrefs = getSharedPreferences("my_prefs", Context.MODE_PRIVATE)
val editor = sharedPrefs.edit()
editor.putString("username", "VasukiDr")
editor.putInt("score", 100)
editor.apply() // асинхронная запись
// или editor.commit() - синхронная запись
 
// Чтение данных
val username = sharedPrefs.getString("username", "")
val score = sharedPrefs.getInt("score", 0)

// Определение Entity
@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    @ColumnInfo(name = "name") val name: String,
    @ColumnInfo(name = "age") val age: Int
)
 
// DAO (Data Access Object)
@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): List<User>
    
    @Insert
    fun insert(user: User)
    
    @Delete
    fun delete(user: User)
}
 
// Database
@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}
 
// Инициализация базы данных
val db = Room.databaseBuilder(
    applicationContext,
    AppDatabase::class.java, "my-database"
).build()
 
// Использование
viewModelScope.launch(Dispatchers.IO) {
    val users = db.userDao().getAll()
    withContext(Dispatchers.Main) {
        // Обновить UI
    }
}

// Определение схемы хранения
val EXAMPLE_COUNTER = intPreferencesKey("example_counter")
 
// Создание DataStore
val dataStore = context.createDataStore(
    name = "settings"
)
 
// Запись данных
viewModelScope.launch {
    dataStore.edit { settings ->
        val currentCounterValue = settings[EXAMPLE_COUNTER] ?: 0
        settings[EXAMPLE_COUNTER] = currentCounterValue + 1
    }
}
 
// Чтение данных
val exampleCounterFlow: Flow<Int> = dataStore.data
    .map { preferences ->
        preferences[EXAMPLE_COUNTER] ?: 0
    }

// Пример запроса к ContentProvider для получения контактов
val contentResolver = contentResolver
val cursor = contentResolver.query(
    ContactsContract.Contacts.CONTENT_URI,
    arrayOf(ContactsContract.Contacts._ID, ContactsContract.Contacts.DISPLAY_NAME),
    null,
    null,
    null
)
 
cursor?.use { 
    while (it.moveToNext()) {
        val id = it.getString(it.getColumnIndex(ContactsContract.Contacts._ID))
        val name = it.getString(it.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME))
        // Обработка данных
    }
}

// Определение API интерфейса
interface ApiService {
    @GET("users")
    suspend fun getUsers(): List<User>
    
    @GET("users/{id}")
    suspend fun getUserById(@Path("id") userId: Int): User
    
    @POST("users")
    suspend fun createUser(@Body user: User): Response<User>
}
 
// Настройка Retrofit
val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()
 
val apiService = retrofit.create(ApiService::class.java)
 
// Использование в корутине
viewModelScope.launch {
    try {
        val users = apiService.getUsers()
        // Обработка результата
    } catch (e: Exception) {
        // Обработка ошибки
    }
}

class AuthInterceptor(
    private val tokenProvider: TokenProvider
) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val originalRequest = chain.request()
        val token = tokenProvider.getToken()
        
        val requestWithToken = originalRequest.newBuilder()
            .header("Authorization", "Bearer $token")
            .build()
            
        val response = chain.proceed(requestWithToken)
        
        if (response.code == 401) { // Unauthorized
            synchronized(this) {
                val newToken = tokenProvider.refreshToken()
                if (newToken != null) {
                    val newRequest = originalRequest.newBuilder()
                        .header("Authorization", "Bearer $newToken")
                        .build()
                    return chain.proceed(newRequest)
                }
            }
        }
        
        return response
    }
}

class UserRepository(
    private val apiService: ApiService,
    private val userDao: UserDao
) {
    suspend fun getUsers(forceRefresh: Boolean = false): List<User> {
        // Если не нужно обновлять из сети и в кэше есть данные
        if (!forceRefresh) {
            val cachedUsers = userDao.getAll()
            if (cachedUsers.isNotEmpty()) {
                return cachedUsers
            }
        }
        
        // Если нужно обновить или кэш пуст
        return try {
            val users = apiService.getUsers()
            userDao.insertAll(users)
            users
        } catch (e: IOException) {
            // При проблемах с сетью вернуть кэш, если он есть
            val cachedUsers = userDao.getAll()
            if (cachedUsers.isNotEmpty()) {
                return cachedUsers
            }
            throw e
        }
    }
}

dependencies {
    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.7'
}

val diffCallback = object : DiffUtil.ItemCallback<User>() {
    override fun areItemsTheSame(oldItem: User, newItem: User): Boolean {
        return oldItem.id == newItem.id
    }
 
    override fun areContentsTheSame(oldItem: User, newItem: User): Boolean {
        return oldItem == newItem
    }
}
 
val adapter = UserAdapter(diffCallback)

val viewPool = RecyclerView.RecycledViewPool()
recyclerView1.setRecycledViewPool(viewPool)
recyclerView2.setRecycledViewPool(viewPool)

// Запуск корутины в ViewModel
viewModelScope.launch {
    try {
        val users = userRepository.getUsers()
        _uiState.value = UiState.Success(users)
    } catch (e: Exception) {
        _uiState.value = UiState.Error(e.message)
    }
}

// Параллельное выполнение запросов с async
viewModelScope.launch {
    val usersDeferred = async { api.getUsers() }
    val postsDeferred = async { api.getPosts() }
    
    val users = usersDeferred.await()
    val posts = postsDeferred.await()
    
    // Обработка результатов
}
 
// Переключение контекста с withContext
viewModelScope.launch {
    val result = withContext(Dispatchers.IO) {
        // Тяжелая операция в IO-потоке
        database.getItems()
    }
    // Продолжение в основном потоке
    updateUI(result)
}

class UserRepository(private val api: ApiService, private val db: UserDatabase) {
    fun getUsers(): Flow<List<User>> = flow {
        // Сначала эмитим данные из базы
        emit(db.getUsers())
        
        // Затем получаем с сервера
        try {
            val fresh = api.getUsers()
            db.saveUsers(fresh)
            emit(fresh)
        } catch (e: Exception) {
            // Ошибка обрабатывается, поток не прерывается
        }
    }.flowOn(Dispatchers.IO)
}
 
// Использование в ViewModel
val users = userRepository.getUsers()
    .map { users -> users.sorted() }
    .catch { e -> _error.value = e.message }
    .stateIn(
        viewModelScope,
        SharingStarted.WhileSubscribed(5000),
        emptyList()
    )

@Module
class NetworkModule {
    @Provides
    @Singleton
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
    
    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
}
 
@Component(modules = [NetworkModule::class, DatabaseModule::class])
@Singleton
interface AppComponent {
    fun inject(activity: MainActivity)
    fun inject(fragment: UserFragment)
}

@HiltAndroidApp
class MyApplication : Application()
 
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject lateinit var userRepository: UserRepository
    
    // ...
}
 
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    @Provides
    @Singleton
    fun provideUserRepository(
        api: ApiService,
        db: UserDatabase
    ): UserRepository {
        return UserRepositoryImpl(api, db)
    }
}

val appModule = module {
    single { Room.databaseBuilder(get(), AppDatabase::class.java, "app-db").build() }
    single { get<AppDatabase>().userDao() }
    single { Retrofit.Builder().baseUrl("https://api.example.com").build().create(ApiService::class.java) }
    single { UserRepositoryImpl(get(), get()) as UserRepository }
    viewModel { UserViewModel(get()) }
}
 
// В Application
startKoin {
    androidContext(this@MyApplication)
    modules(appModule)
}
 
// Использование
class UserFragment : Fragment() {
    private val viewModel: UserViewModel by viewModel()
}

@Composable
fun Greeting(name: String) {
    Text(text = "Привет, $name!")
}

// Не переживает пересоздание Activity
val count = remember { mutableStateOf(0) }
 
// Переживает пересоздание Activity
val persistentCount = rememberSaveable { mutableStateOf(0) }

val expanded = remember { mutableStateOf(false) }
 
Button(onClick = { expanded.value = !expanded.value }) {
    Text(if (expanded.value) "Свернуть" else "Развернуть")
}

@Test
fun `когда введён корректный email, функция возвращает true`() {
    // Arrange
    val emailValidator = EmailValidator()
    val validEmail = "test@example.com"
    
    // Act
    val result = emailValidator.isValid(validEmail)
    
    // Assert
    Truth.assertThat(result).isTrue()
}

// До рефакторинга
fun process() {
    val data = getData() // Блокирующий вызов API
    val processed = data.map { it.uppercase() }
    saveToDatabase(processed) // Блокирующий вызов БД
    updateUI(processed)
}
 
// После рефакторинга
fun process() {
    viewModelScope.launch {
        try {
            val data = withContext(Dispatchers.IO) { getData() }
            val processed = data.map { it.uppercase() }
            withContext(Dispatchers.IO) { saveToDatabase(processed) }
            updateUI(processed)
        } catch (e: Exception) {
            handleError(e)
        }
    }
}