CompositionLocal в Jetpack Compose. Что это и как с его помощью реализовать реактивную локализацию приложения

    Власть в блоге Технократии переходит андроид-разработчикам. Владислав Титов рассказывает,  как  добиться непрерывающегося UI при смене локализации.

    В чем проблема

    Работа со строковыми ресурсами в Андроид устроена следующим образом:

    • строки хранятся в виде xml разметки в разных папках values 

    • Чтобы получить строку в коде, нужно обратиться к объекту Context’а.

    В объекте Context и заключается проблема. Чтобы сменить локализацию, нужно, во-первых, установить дефолтную Locale через Locale.setDefault(), во-вторых, приаттачить Context с новой Locale к активности в методе attachBaseContext(). Добиться вызова этого метода мы можем только при перезапуске активности, что приводит к прерывающемуся UI. Что же с этим можно сделать? Давайте разбираться.

    Как Jetpack Compose понимает, когда и как нужно (пере)рисовать виджеты

    Разберемся, как Compose обновляет состояние отображения — этот процесс называется рекомпозицией.

    Рассмотрим пример:

    @Composable
    fun Hello() {
        Text(text = "Hello Compose!")
    }

    Определяем экран с текстовым виджетом. Никакого состояния здесь нет, так как под ним понимается значение, которое может меняться с течением времени. Значит, этот экран перерисовываться не будет. Добавим состояние:

    
    @Composable
    fun Hello() {
        var name = "Compose"
        Text(text = "Hello $name!")
        TextField(
            value = name,
            onValueChanged = { name = it }
        )
    }

    Добавили TextField и переменную name, в которую записываются изменения. Подразумевается, что эта переменная наполняется из текстового поля и реактивно отображается в текстовом виджете. К сожалению, этот пример не работает. Compose не понимает, что при изменении переменной name нужно перерисовать Text. Как же его научить?

    Для этих целей фреймворк предоставляет инструмент State — прослушиваемый контейнер данных. Compose понимает, когда изменяется состояние, и реагирует на это. Данная реакция называется рекомпозицией. Далее мы увидим, как она происходит.

    @Composable
    fun Hello() {
        var name by mutableStateOf("Compose")
        Text(text = "Hello ${name}!")
        TextField(
            value = name,
            onValueChanged = { name = it }
        )
    }

    mutableStateOf — это функция-builder изменяемого состояния для Composable. Она возвращает объект MutableState, наследника State, у которого определено property value. В него мы можем класть значение и забирать его оттуда. Чтобы сделать работу со State более удобной, можно использовать его как property delegate с помощью оператора by (как в примере выше). Тогда мы сможем обращаться с состоянием как с переменной и не писать state.value.

    Небольшое отступление

    В нашем примере мы используем изменяемое состояние (MutableState), так как изменяем его в том же скоупе. Если же в приложении используется архитектурный паттерн, то, вероятнее всего, состояние будет храниться и изменяться вне скоупа view. Так, если использовать ViewModel, нужно var name by mutableStateOf("Compose") заменить на val name by viewModel.nameLiveData.observeAsState(""), а onValueChanged = { name = it } на onValueChanged = { viewModel.setName(it) }. Заметьте, что при переходе на неизменяемое состояние var name превращается в val name. Такая организация работы с состоянием хорошо описана здесь.

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

    Это происходит потому, что во время рекомпозиции Composable, которому принадлежит State, вызывается заново. При этом строка var name by mutableStateOf("Compose") выполняется снова и перезаписывает старое измененное состояние. Так мы оказываемся снова в отправной точке. Чтобы избежать такого поведения, нужно воспользоваться специальной функцией remember:

    
    @Composable
    fun Hello() {
        val name by remember { mutableStateOf("Compose") }
        Text(text = "Hello ${name}!")
        TextField(
            value = name,
            onValueChanged = { name = it }
        )
    }

    С помощью этой функции Composable “запоминает” значение, вычисленное при первоначальной композиции. В дальнейшем значение будет не вычисляться, а доставаться из памяти Composable-функции. 

    Такая реализация рекомпозиции наводит на мысль, что Composable функция не должна иметь side-эффектов. Из-за неопределенных порядка и количества вызовов Composable функции side-эффекты могут привести к нежелаемому поведению. Отсюда вытекает требование, чтобы абсолютно все данные приходили в Composable через параметры. Но это не всегда удобно, и далее мы увидим, как обойти это требование. Подробнее о рекомпозиции можно почитать здесь.

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

    CompositionLocal

    Как было сказано выше, идеальный вариант, когда все данные Composable-функции поступают через параметры. Но это не всегда удобно. Посмотрите на пример ниже. Будем считать, что получить пользователя в другом месте невозможно. Видно, что у MyApp нет зависимости от пользователя, но его необходимо передать своим потомкам. Поэтому приходится в MyApp добавлять лишний параметр.

    
    class MainActivity : AppCompatActivity() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContent {
                val viewModel: MainViewModel = viewModel()
                MyApp(viewModel.user)
            }
        }
    }
    
    @Composable
    fun MyApp(user: User) {
        UserWidget(user)
    }
    
    @Composable
    fun UserWidget(user: User) {
        Text(text = user.name)
    }

    Согласитесь, что в большой иерархии со множеством вложенных хорошо декомпозированных Composable, такой способ доставки данных может стать головной болью. 

    В данной ситуации на помощь приходит инструмент CompositionLocal. Как и State, по своей сути это прослушиваемый контейнер данных, который вы можете инстанцировать за пределами Composable скоупа и ссылаться на него статически. CompositionLocal используется для неявной передачи данных в Composable. У вас может возникнуть вопрос: “Не является ли в таком случае CompositionLocal side-эффектом?” Ответ - нет. А почему — узнаем ниже.

    
    val ActiveUser = compositionLocalOf<User> { error("No active user found!") }
    
    class MainActivity : AppCompatActivity() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContent {
                val viewModel: MainViewModel = viewModel()
                CompositionLocalProvider(ActiveUser provides viewModel.user) {
                    MyApp()
                }
            }
        }
    }
    
    @Composable
    fun MyApp() {
        UserWidget()
    }
    
    @Composable
    fun UserWidget() {
        val user = ActiveUser.current
        Text(text = user.name)
    }

    Итак, с помощью функции-билдера compositionLocalOf мы создаем объект класса CompositionLocal с типом User и записываем его в статическую переменную ActiveUser. В trailing лямбде можно вернуть дефолтный объект User’а, но если вам это не нужно, можно просто выкинуть исключение.

    Далее где-то в Composable контексте (скорее всего в корне, но это необязательно) мы должны поставить данные в этот CompositionLocal. Это делается с помощью конструкции CompositionLocalProvider(ActiveUser provides viewModel.user) { //contnt }. Таким образом мы устанавливаем в ActiveUser некоторое значение, которое будет доступно только в подиерархии, что будет установлена вместо комментария content. Такой конструкцией мы можем оборачивать множество подиерархий и устанавливать для каждой свое значение user. Это правило работает даже для вложенных Provider’ов. Вот поэтому CompositionLocal не является side-эффектом.

    Чтобы получить данные из CompositionLocal, нужно обратиться к Composable property CompositionLocal.current. Как и в случае со State, Compose понимает, что при изменении значения в конкретном CompositionLocal, нужно рекомпозировать зависимые от него Composable. Теперь данные из setContent идут напрямую в UserWidget, не касаясь при этом MyApp. Таким образом, мы достигли поставки данных в Composable в обход параметров, сохранив при этом возможность реагировать на изменение данных реактивно.

    Реактивная локализация: организация строковых ресурсов без Context

    Итак, настало время обсудить проблему, обозначенную в начале статьи. Нынешний вариант получения строковых ресурсов основан на LocalContext: через этот CompositionLocal мы получаем текущий Context и уже из него достаем строковые ресурсы всеми известным способом. То есть проблема, обозначенная в начале статьи, актуальна и для Jetpack Compose. Мы решили избавиться от этой досадной зависимости.

    data class Localization(
        val locale: Locale, 
        val strings: MutableMap<String, String> = mutableMapOf()
    )
    

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

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

    • localizationMap — это небольшая оптимизация, чтобы сложность поиска необходимой локализации по данной локали была O(1), а не O(n).

    • supportedLocales отвечает за отсутствие дублирований регистрируемых локалей

    • также устанавливаем дефолтную локализацию, в нашем случае английскую.

    internal val defaultLocalization: Localization = Localization(Locale.ENGLISH)
    
    private val supportedLocales: MutableSet<Locale> = mutableSetOf()
    
    private val localizationMap = hashMapOf<Locale, Localization>()
    
    fun registerSupportedLocales(vararg locales: Locale): Set<Locale> {
        locales.filter { it != Locale.ENGLISH }
            .forEach {
                if (supportedLocales.add(it)) {
                    registerLocalizationForLocale(it)
                }
            }
        return supportedLocales + Locale.ENGLISH
    }
    
    private fun registerLocalizationForLocale(locale: Locale) {
        localizationMap[locale] = Localization(locale)
    }

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

    fun Translatable(name: String, defaultValue: String, localeToValue: () -> Map<Locale, String>): Localization.() -> String {
        defaultLocalization.strings[name] = defaultValue
        for ((locale, value) in localeToValue().entries) {
            val localization = localizationMap[locale] ?: throw RuntimeException("There is no locale $locale")
            localization.strings[name] = value
        }
        return fun Localization.(): String {
            return this.strings[name] ?: defaultLocalization.strings[name] ?: throw RuntimeException("There is no string called $name in localization $this")
        }
    }
    
    fun NonTranslatable(name: String, defaultValue: String): Localization.() -> String {
        defaultLocalization.strings[name] = defaultValue
        return fun Localization.(): String {
            return defaultLocalization.strings[name] ?: throw RuntimeException("There is no string called $name in localization default")
        }
    }

    Данные функции принимают на вход три параметра (два в случае непереводимых строк):

    name — идентификатор строки. Он должен быть уникальным. 

    defaultValue  — строка, которая будет связана с дефолтной локализацией 

    closure localeToValue, который возвращает отображение локаль-строка.

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

    Оба строковых билдера возвращают extension-функции Локализации. Применяя их на различных локализациях, мы будем получать соответствующие переводы. Но как получить доступ к локализациям и как изменить текущую? Для организации метода доступа мы применим CompositionLocal:

    val LocalLocalization = compositionLocalOf { defaultLocalization } 

    Чтобы придать лучший вид, обернем LocalLocalization в object (по аналогии с MaterialTheme):

    object Vocabulary {
        @Composable
        @get:ReadOnlyComposable
        val localization: Localization get() = LocalLocalization.current
    }

    Осталось доставить данные в CompositionLocal:

    @Composable
    fun Localization(locale: Locale, content: @Composable () -> Unit) {
        CompositionLocalProvider(
            LocalLocalization provides (localizationMap[locale] ?: defaultLocalization),
            children = content
        )
    }

    Применение

    Шаг 1. Зарегистрировать поддерживаемые локали

    val RUSSIAN = Locale("ru")
    val TATAR = Locale("tt")
    
    val supportedLocalesNow = registerSupportedLocales(RUSSIAN, TATAR)

    Шаг 2. Описать необходимые строковые ресурсы

    val hello = Translatable("hello", "Hello!") {
        hashMapOf(
            RUSSIAN to "Привет!",
            TATAR to "Исәнме!"
        )
    }
    val nonTrans = NonTranslatable("format", "%1\$d:%2\$02d")

    Шаг 3. Применить при верстке

    class MainActivity : AppCompatActivity() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContent {
                Localization(locale = TATAR /*smth from supportedLocalesNow*/) {
                    val localization = Vocabulary.localization
                    Text(text = localization.hello())
                    Text(text = localization.nonTrans().format(20, 9))
                }
            }
        }
    }

    Шаг 4. Наслаждаемся!

    Теперь, подавая разные локали в функцию Localization, вы можете изменять локализацию экрана без пересоздания Activity

    P.S. Данное решение мы упаковали в библиотеку, которую вы можете найти по ссылке.

    Сейчас ведется работа над plurals, возможностью установки собственной дефолтной локали, сохранением выбранной локали между перезапусками приложения и рефакторинг функций Translatable и NonTranslatable. Так же есть мысли по созданию type-safety форматирования. Сейчас мы предлагаем воспользоваться стандартными инструментами для форматирования. Это либо всем известный Formatter, либо другой инструмент — MessageFormat, с помощью которого также можно организовать функционал количественных строк. 

    Мы считаем, что ваш опыт работы с нашими инструментами должен быть лучшим, поэтому вы можете участвовать в жизни проекта, улучшать его вместе с нами. Будем рады новым идеям и реализациям!

    Полезные ссылки

    Jetpack Compose Localization - https://github.com/TechnokratosDev/jetpack-compose-localization

    Основные концепции парадигмы Jetpack Compose - https://developer.android.com/jetpack/compose/mental-model

    Анатомия Composable - https://medium.com/androiddevelopers/under-the-hood-of-jetpack-compose-part-2-of-2-37b2c20c6cdd

    Codelab по основам Compose - https://codelabs.developers.google.com/codelabs/jetpack-compose-basics

    Видеоверсия

    Мы предоставлыем видеоверсию статьи в виде доклада с открытого митапа ОЭЗ «Иннополис». Начало выступления с 4:28.

    Подписывайтесь на наш Telegram-канал «Голос Технократии», где мы пишем о новостях из мира ИТ и высказываем свое мнение о важных событиях.

    Комментарии 0

    Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

    Самое читаемое