Context и глубины Android

// Ошибка: ApplicationContext не имеет темы
val dialog = AlertDialog.Builder(applicationContext).create()
 
// Правильно: используем Activity как контекст с темой
val dialog = AlertDialog.Builder(this).create()

// Неэффективно: Activity контекст избыточен и может вызвать утечку
private fun scheduleJob(context: Context) {
    jobScheduler = context.getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
    // ...
}
 
// Лучше:
private fun scheduleJob(context: Context) {
    jobScheduler = context.applicationContext
        .getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
    // ...
}

// В BroadcastReceiver.onReceive():
override fun onReceive(context: Context, intent: Intent) {
    // Начиная с Android 8.0, это будет работать только если приложение на переднем плане
    context.startService(Intent(context, MyService::class.java))
    
    // Лучше использовать JobScheduler или WorkManager
    val jobScheduler = context.getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
    // ...
}

// Потенциальная проблема: Activity может быть уничтожена к моменту завершения задачи
fun loadData() {
    CoroutineScope(Dispatchers.IO).launch {
        val data = fetchDataFromNetwork()
        withContext(Dispatchers.Main) {
            // Если Activity уничтожена, это вызовет крэш
            updateUI(data)
        }
    }
}

// Безопасное использование с lifecycle-aware компонентами
fun loadData() {
    lifecycleScope.launch {
        val data = fetchDataFromNetwork()
        // Корутина будет автоматически отменена, если lifecycle завершится
        updateUI(data)
    }
}

interface ResourceProvider {
    fun getString(resId: Int): String
    fun getDrawable(resId: Int): Drawable?
    // ...
}
 
class ContextResourceProvider(private val context: Context) : ResourceProvider {
    override fun getString(resId: Int): String = context.getString(resId)
    override fun getDrawable(resId: Int): Drawable? = ContextCompat.getDrawable(context, resId)
    // ...
}

// В тесте:
val mockProvider = mock(ResourceProvider::class.java)
`when`(mockProvider.getString(R.string.app_name)).thenReturn("Test App")
 
val viewModel = MyViewModel(mockProvider)
// Теперь можно тестировать без реального Context

fun isNetworkAvailable(): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val networkInfo = connectivityManager.activeNetworkInfo
    return networkInfo != null && networkInfo.isConnected
}

class NetworkUtils(private val context: Context) {
    private val connectivityManager = context.applicationContext
        .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    
    fun isNetworkAvailable(): Boolean {
        val networkInfo = connectivityManager.activeNetworkInfo
        return networkInfo != null && networkInfo.isConnected
    }
}

override fun onBindViewHolder(holder: ViewHolder, position: Int) {
    val item = items[position]
    holder.title.text = context.getString(R.string.item_title, item.name)
    holder.icon.setImageDrawable(ContextCompat.getDrawable(context, item.iconResId))
    // ...
}

class MyAdapter(context: Context, private val items: List<Item>) : RecyclerView.Adapter<ViewHolder>() {
    private val titleFormat = context.getString(R.string.item_title)
    private val iconCache = SparseArray<Drawable>()
    
    init {
        // Предзагрузка иконок для частых элементов
        items.distinctBy { it.iconResId }.forEach { item ->
            ContextCompat.getDrawable(context, item.iconResId)?.let {
                iconCache.put(item.iconResId, it)
            }
        }
    }
    
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val item = items[position]
        holder.title.text = String.format(titleFormat, item.name)
        holder.icon.setImageDrawable(iconCache.get(item.iconResId))
        // ...
    }
}

// В фоновом потоке
val bitmap = loadBitmapFromNetwork()
runOnUiThread {
    ImageView(context).setImageBitmap(bitmap) // Создание ImageView в UI-потоке
}

// Заранее создаем View
val imageView = ImageView(context)
layout.addView(imageView)
 
// В фоновом потоке
val bitmap = loadBitmapFromNetwork()
runOnUiThread {
    imageView.setImageBitmap(bitmap) // Только обновление, без создания
}

class PreferencesWrapper(private val context: Context) {
    private val prefs by lazy {
        context.applicationContext.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
    }
    
    fun saveUserToken(token: String) {
        prefs.edit().putString("user_token", token).apply()
    }
    
    fun getUserToken(): String? {
        return prefs.getString("user_token", null)
    }
    
    // Другие методы...
}

class UserRepository(private val contextProvider: ContextProvider) {
    fun getUserProfile(): UserProfile {
        val context = contextProvider.getContext()
        // Получение данных из локального хранилища или сети
        return UserProfile(...)
    }
}
 
// Интерфейс-провайдер для инверсии зависимостей
interface ContextProvider {
    fun getContext(): Context
}
 
// Реализация для продакшена
class AppContextProvider(private val app: Application) : ContextProvider {
    override fun getContext() = app
}
 
// Реализация для тестов
class TestContextProvider(private val testContext: Context) : ContextProvider {
    override fun getContext() = testContext
}

// В базовом модуле:
object ContextRegistry {
    private var applicationContext: Context? = null
    
    fun init(context: Context) {
        if (applicationContext == null) {
            applicationContext = context.applicationContext
        }
    }
    
    fun getContext(): Context = applicationContext 
        ?: throw IllegalStateException("Context not initialized")
    
    // Можно добавить cleanup для тестов
    fun reset() {
        applicationContext = null
    }
}
 
// Использование в модулях:
class FeatureManager {
    fun doSomething() {
        val context = ContextRegistry.getContext()
        // Использование контекста
    }
}

class ReactiveContextProvider(private val lifecycle: Lifecycle) {
    private val contextFlow = MutableStateFlow<Context?>(null)
    
    init {
        lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    contextFlow.value = null
                } else if (event == Lifecycle.Event.ON_CREATE) {
                    contextFlow.value = source as? Context
                }
            }
        })
    }
    
    fun getContextFlow(): Flow<Context?> = contextFlow
    
    suspend fun awaitContext(): Context {
        return contextFlow.filterNotNull().first()
    }
}

class TrackingContext(private val baseContext: Context) : Context by baseContext {
    override fun startActivity(intent: Intent) {
        // Логирование или отслеживание аналитики перед запуском Activity
        analyticsTracker.trackScreenOpen(intent.component?.className ?: "unknown")
        baseContext.startActivity(intent)
    }
    
    override fun getSystemService(name: String): Any? {
        // Можно перехватывать запросы к определенным сервисам
        return when(name) {
            Context.LOCATION_SERVICE -> {
                // Возвращаем модифицированный или мониторящий сервис
                LocationServiceWrapper(baseContext.getSystemService(name) as LocationManager)
            }
            else -> baseContext.getSystemService(name)
        }
    }
}

class MockContext : Context() {
    private val resourceMap = mutableMapOf<Int, String>()
    private val serviceMap = mutableMapOf<String, Any>()
    private val permissionResults = mutableMapOf<String, Int>()
    
    // Устанавливаем ожидаемые значения для тестов
    fun setStringResource(id: Int, value: String) {
        resourceMap[id] = value
    }
    
    fun setSystemService(name: String, service: Any) {
        serviceMap[name] = service
    }
    
    fun setPermissionResult(permission: String, result: Int) {
        permissionResults[permission] = result
    }
    
    // Переопределяем только нужные методы
    override fun getString(id: Int): String {
        return resourceMap[id] ?: "mock_string_$id"
    }
    
    override fun getSystemService(name: String): Any? {
        return serviceMap[name]
    }
    
    override fun checkSelfPermission(permission: String): Int {
        return permissionResults[permission] ?: PackageManager.PERMISSION_DENIED
    }
    
    // Остальные методы реализуем минимально
    // или выбрасываем UnsupportedOperationException
    // ...
}

@Test
fun testFeatureWithMockContext() {
    val mockContext = MockContext().apply {
        setStringResource(R.string.app_name, "Test App")
        setPermissionResult(Manifest.permission.CAMERA, PackageManager.PERMISSION_GRANTED)
        
        // Настраиваем моки для системных сервисов
        val mockLocationManager = mock(LocationManager::class.java)
        [INLINE]when[/INLINE](mockLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)).thenReturn(true)
        setSystemService(Context.LOCATION_SERVICE, mockLocationManager)
    }
    
    val feature = MyFeature(mockContext)
    val result = feature.doSomething()
    
    assertTrue(result)
}

class ResourceCache(context: Context) {
    private val appContext = context.applicationContext
    private val cache = ConcurrentHashMap<Pair<Int, Array<out Any>?>, String>()
    
    fun getString(resId: Int, vararg formatArgs: Any): String {
        val key = Pair(resId, formatArgs.takeIf { it.isNotEmpty() })
        return cache.getOrPut(key) {
            if (formatArgs.isEmpty()) {
                appContext.getString(resId)
            } else {
                appContext.getString(resId, *formatArgs)
            }
        }
    }
    
    fun clearCache() {
        cache.clear()
    }
}

// Вместо:
val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
 
// Лучше использовать:
val locationManager = context.getSystemService(LocationManager::class.java)

class SecureContext(private val baseContext: Context) : ContextWrapper(baseContext) {
    override fun getSystemService(name: String): Any? {
        // Перехватываем получение сервисов, требующих особых разрешений
        return when (name) {
            Context.TELEPHONY_SERVICE -> {
                // Проверяем, есть ли у приложения нужные разрешения
                if (checkCallingOrSelfPermission(Manifest.permission.READ_PHONE_STATE) 
                        != PackageManager.PERMISSION_GRANTED) {
                    SecureTelephonyManager() // Ограниченная реализация
                } else {
                    super.getSystemService(name)
                }
            }
            else -> super.getSystemService(name)
        }
    }
}

// В Domain-слое (чистая бизнес-логика)
interface ResourceProvider {
    fun getString(id: Int, vararg args: Any): String
    fun getQuantityString(id: Int, quantity: Int, vararg args: Any): String
    // другие методы...
}
 
interface PreferencesStore {
    fun saveString(key: String, value: String)
    fun getString(key: String, defaultValue: String = ""): String
    // другие методы...
}

// В Data-слое (Android-зависимый код)
class AndroidResourceProvider(private val context: Context) : ResourceProvider {
    override fun getString(id: Int, vararg args: Any): String {
        return if (args.isEmpty()) {
            context.getString(id)
        } else {
            context.getString(id, *args)
        }
    }
    
    override fun getQuantityString(id: Int, quantity: Int, vararg args: Any): String {
        return context.resources.getQuantityString(id, quantity, *args)
    }
}
 
class SharedPreferencesStore(context: Context) : PreferencesStore {
    private val prefs = context.applicationContext
        .getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
        
    override fun saveString(key: String, value: String) {
        prefs.edit().putString(key, value).apply()
    }
    
    override fun getString(key: String, defaultValue: String): String {
        return prefs.getString(key, defaultValue) ?: defaultValue
    }
}

@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    
    @Provides
    @Singleton
    fun provideContext(@ApplicationContext context: Context): Context {
        return context
    }
    
    @Provides
    @Singleton
    fun provideResourceProvider(context: Context): ResourceProvider {
        return AndroidResourceProvider(context)
    }
    
    @Provides
    @Singleton
    fun providePreferencesStore(context: Context): PreferencesStore {
        return SharedPreferencesStore(context)
    }
}

@HiltViewModel
class ProfileViewModel @Inject constructor(
    private val userRepository: UserRepository,
    private val resourceProvider: ResourceProvider
) : ViewModel() {
    
    fun getUserGreeting(): LiveData<String> = liveData {
        val user = userRepository.getCurrentUser()
        val greeting = resourceProvider.getString(
            R.string.greeting_format, 
            user.name
        )
        emit(greeting)
    }
}

interface UiContextProvider {
    fun getUiContext(): Context
}
 
// Реализация в Activity
class MainActivity : AppCompatActivity(), UiContextProvider {
    override fun getUiContext(): Context = this
    
    // Внедряем через Hilt/Dagger в нужные компоненты
}

class ContextResourcePool private constructor(private val context: Context) {
    private val drawableCache = LruCache<Int, Drawable>(100)
    private val stringCache = ConcurrentHashMap<Int, String>()
    private val systemServiceCache = ConcurrentHashMap<String, Any>()
    
    // Счетчики для метрик производительности
    private val cacheHits = AtomicInteger(0)
    private val cacheMisses = AtomicInteger(0)
    
    fun getDrawable(resId: Int): Drawable? {
        return drawableCache.get(resId) ?: run {
            cacheMisses.incrementAndGet()
            ContextCompat.getDrawable(context, resId)?.also {
                drawableCache.put(resId, it)
            }
        }
    }
    
    fun getString(resId: Int): String {
        return stringCache.getOrPut(resId) {
            cacheMisses.incrementAndGet()
            context.getString(resId)
        }.also { cacheHits.incrementAndGet() }
    }
    
    @Suppress("UNCHECKED_CAST")
    fun <T> getSystemService(serviceClass: Class<T>): T {
        val name = getServiceName(serviceClass)
        return systemServiceCache.getOrPut(name) {
            cacheMisses.incrementAndGet()
            context.getSystemService(serviceClass)
        } as T
    }
    
    fun getCacheMetrics(): CacheMetrics {
        return CacheMetrics(
            hits = cacheHits.get(),
            misses = cacheMisses.get(),
            drawableCacheSize = drawableCache.size(),
            stringCacheSize = stringCache.size
        )
    }
    
    // Очистка по необходимости
    fun trimMemory(level: Int) {
        if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
            drawableCache.evictAll()
        }
    }
    
    companion object {
        @Volatile
        private var INSTANCE: ContextResourcePool? = null
        
        fun getInstance(context: Context): ContextResourcePool {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: ContextResourcePool(context.applicationContext).also {
                    INSTANCE = it
                }
            }
        }
    }
}
 
data class CacheMetrics(
    val hits: Int,
    val misses: Int,
    val drawableCacheSize: Int,
    val stringCacheSize: Int
)

class ResourcePoolManager(private val application: Application) : ComponentCallbacks2 {
    private val resourcePool = ContextResourcePool.getInstance(application)
    
    init {
        application.registerComponentCallbacks(this)
    }
    
    override fun onTrimMemory(level: Int) {
        resourcePool.trimMemory(level)
    }
    
    override fun onConfigurationChanged(newConfig: Configuration) {
        // Сбросить кэши, зависящие от конфигурации
        // (например, при смене языка или ориентации)
    }
    
    override fun onLowMemory() {
        resourcePool.trimMemory(ComponentCallbacks2.TRIM_MEMORY_COMPLETE)
    }
    
    fun getMetrics(): CacheMetrics = resourcePool.getCacheMetrics()
}

fun reportMetrics() {
    val metrics = resourcePoolManager.getMetrics()
    val hitRatio = if (metrics.hits + metrics.misses > 0) {
        metrics.hits.toFloat() / (metrics.hits + metrics.misses)
    } else 0f
    
    FirebasePerformance.getInstance().newTrace("resource_pool_metrics")
        .putMetric("hit_ratio", (hitRatio * 100).toLong())
        .putMetric("cache_size", metrics.drawableCacheSize.toLong() + metrics.stringCacheSize.toLong())
}