Полный список

OEM-разблокировка

Как вы знаете, большинство Android-устройств дают вам свободу ПОЛЬЗОВАТЕЛЬСКАЯ УСТАНОВКА ПЗУ , который заменяет операционную систему по умолчанию на новую. Для этого нужно сначала разблокировать пользовательский загрузчик. Без этого процесс установки, который заменяет вашу текущую операционную систему, не будет работать.

Обратите внимание, что включение этого параметра фактически не разблокирует загрузчик; Это просто дает телефону возможность сделать это позже с помощью команд fastboot. Таким образом, вам не следует включать эту опцию, если вы не планируете установить на свое устройство пользовательское ПЗУ

Включение этого делает ваш телефон более уязвимым. Проверять Как использовать ADB и Fastboot на Android (и почему вам это нужно).

Deploy Continuously

Feature flags are one of the main enablers of continuous deployment. Using feature flags consistently, you can literally deploy any time, because all unfinished changes are hidden behind (disabled) feature flags and don’t pose a risk to your users.

Make use of the fact that you can deploy any time and implement a continuous deployment pipeline that deploys your code to production every time you push to the mainline!

Continuous deployment doesn’t mean that the code has to go out directly to production without tests. The pipeline should definitely include automated tests and it can also include a deployment to a staging environment for a smoke test.

Feature flags bring advantages even without continuous deployment, but continuous deployment is a big one! High-performance teams use continuous deployment!

Feature branches are complicated

However, there are a few drawbacks to using feature branches. For one thing, they exist outside of the main branch, which is where the service or application that end users interact with lives.

This means that, for a feature to be enabled, it has to be merged into the main branch. This can be complex, especially if many developers have been working on the main branch while the feature branch was being developed.

To try and avoid merging complexity, some teams use different branching strategies.

For example, they might sync changes from the main branch into the feature branch on a regular basis. The idea is to reduce the complexity of merging the feature branch back into the main branch.

However, the team working on the feature branch still needs to spend time making sure their branch is up-to-date with the main branch. Maintenance time takes away from development time.

Another issue with feature branches is that it can be hard to share code between parallel feature branches. This is often the case when a new feature has dependencies. In this situation, a developer needs to test the two feature branches together as early as possible.

However, if the features are being developed in separate feature branches, end-to-end testing usually happens very late in the process. This often leads to a significantly longer time-to-market for the new feature.

More Granular Feature Flags

Sometimes we find ourselves in more complex scenarios. For A/B testing or canary releases, our previous approach is simply not enough.

To get feature flags at a more granular level, we may need to create our solution. This could involve customizing our user entity to include feature-specific information, or perhaps extending our web framework.

Polluting our users with feature flags might not be an appealing idea for everybody, however, and there are other solutions.

As an alternative, we could take advantage of some built-in tools such as Togglz. This tool adds some complexity but offers a nice out-of-the-box solution and provides first-class integration with Spring Boot.

Togglz supports different activation strategies:

1. Username: Flags associated with specific users
2. Gradual rollout: Flags enabled for a percentage of the user base. This is useful for Canary releases, for example, when we want to validate the behavior of our features
3. Release date: We could schedule flags to be enabled at a certain date and time. This might be useful for a product launch, a coordinated release, or offers and discounts
4. Client IP: Flagged features based on clients IPs. These might come in handy when applying the specific configuration to specific customers, given they have static IPs
5. Server IP: In this case, the IP of the server is used to determine whether a feature should be enabled or not. This might be useful for canary releases too, with a slightly different approach than the gradual rollout – like when we want to assess performance impact in our instances
6. ScriptEngine: We could enable feature flags based on arbitrary scripts. This is arguably the most flexible option
7. System Properties: We could set certain system properties to determine the state of a feature flag. This would be quite similar to what we achieved with our most straightforward approach

How to connect an Android mobile app to ConfigCat?

The first step is to add the ConfigCat Android (Kotlin) SDK into the project:

Enter fullscreen modeExit fullscreen mode

And import it wherever is needed:

Enter fullscreen modeExit fullscreen mode

The ConfigCat SDK serves as the backbone of the overall feature flag system. You have to create your feature flags on the ConfigCat Dashboard then the feature flag evaluation is done locally on the client-side in the SDK, therefore you don’t have to wait for a request made to ConfigCat every time a feature flag is called, as the values are served from local cache. You can read about .

The client and a special value

In this example, a single component will be implementing the feature flagging mechanism, but feel free to scale it and use it for your entire application. As I want to keep things straightforward for now, all I need is the located by the and its adaptor, the class.

First, I ought to create a ConfigCat client:

Enter fullscreen modeExit fullscreen mode

Note: the placeholder ties the application with ConfigCat’s service, so make sure you replace it with the uniquely-generated SDK key from your dashboard.

Enter fullscreen modeExit fullscreen mode

Now that I’ve established my client, I need the feature flag’s value to assess the application’s state: when the flag is , the holiday season is over, and consumers may purchase usual specialties. I activate the festive menu otherwise.

There are several methods to get the flag’s value, but for the sake of simplicity, I’ll use the default mode with no user targeting. However, you can if you want to get different feature flag values for different users.

Enter fullscreen modeExit fullscreen mode

The function will return the actual feature flag value, so it is called along with the feature flag’s name and the default value. In the example above, the variable holds the current flag’s value. The default value will be returned if the flag is not found or the local cache is empty.

Last but not least

All that’s left is to override the function (which is located in the class) depending on the feature flag value. If the value is true then the holiday menu is used, otherwise the standard menu is displayed. To achieve this, I use the lists below to change the menu’s regular layout.

Enter fullscreen modeExit fullscreen mode

Whenever I toggle the holiday feature flag in my dashboard the menu items change accordingly.

Флаги для Intent

Флаги применяются к Intent с помощью метода . Эти флаги повлияют на поведение вызываемого Activity.

FLAG_ACTIVITY_NEW_TASK

— в хелпе пишут, что этот флаг аналогичен значению singleTask в launchMode. У меня почему-то не совсем так. Activity находит свой таск, но не ищет в этом таске себя, а просто создает новое Activity сверху.

FLAG_ACTIVITY_CLEAR_TOP

– ищет в таске создаваемое Activity. Если находит, то открывает, а все, что выше – закрывает. Можно сказать, что этот флаг в комбинации с FLAG_ACTIVITY_NEW_TASK является аналогом singleTask в launchMode.

FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET

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

Рассмотрим на примере.  В MainActivity второго приложения перепишем метод onClick:

  public void onClick(View v) {
    startActivity(new Intent("mngtasks1_activity_c")
        .addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET));
  }

Будем вызывать ActivityC с этим флагом. Сохраняем, запускаем второе приложение. Жмем Start, открывается ActivityC, жмем еще раз Start, открывается ActivityD. Таск сейчас такой: Main-C-D.

Свернем приложение, нажав Home. Далее запускаем его с рабочего стола. Система находит таск и открывает его. На экране MainActivity второго приложения. Т.к. ActivityC было запущено с вышеуказанным флагом, оно и все вышестоящие Activity были закрыты при запуске приложения. В таске теперь только MainActivity.

FLAG_ACTIVITY_NO_HISTORY

– Activity не будет сохранено в таске. Например, мы вызываем B с таким флагом из A. Далее из B вызываем C. Теперь жмем Назад и попадаем сразу в A, т.к. B не сохранилось в таске.

FLAG_ACTIVITY_REORDER_TO_FRONT

– если Activity уже есть в таске оно переместится в топ. Например, есть таск A-B-C-D. Если D вызывает B с таким флагом, то таск станет таким A-C-D-B.

Пара флагов, появившихся с API Level 11. Используются совместно с FLAG_ACTIVITY_NEW_TASK.

FLAG_ACTIVITY_CLEAR_TASK

– таск для вызываемого Activity будет очищен, а вызываемое Activity станет в нем корневым. Сделаем пример.

В MainActivity второго приложения перепишем метод onClick:

  public void onClick(View v) {
    startActivity(new Intent("mngtasks1_activity_c").addFlags(
        Intent.FLAG_ACTIVITY_CLEAR_TASK).addFlags(
        Intent.FLAG_ACTIVITY_NEW_TASK));
  }

Очистим таски. Запускаем первое приложение, жмем три раза Start, получаем A-B-C-D. Запускаем второе приложение, жмем Start, открывается ActivityC. Жмем Info:

Count: 1Root: ru.startandroid.develop.p1161mngtasks1/.ActivityCTop: ru.startandroid.develop.p1161mngtasks1/.ActivityC——————Count: 1Root: ru.startandroid.develop.p1162mngtasks2/.MainActivityTop: ru.startandroid.develop.p1162mngtasks2/.MainActivity

Таск первого приложения полностью очистился, в нем теперь только ActivityC.

FLAG_ACTIVITY_TASK_ON_HOME

– таск для вызываемого Activity будет располагаться сразу после Home. Если из этого нового таска выходить кнопкой Назад, то попадешь не в предыдущий таск, а в Home. Сделаем пример.

В MainActivity второго приложения перепишем метод onClick:

  public void onClick(View v) {
    startActivity(new Intent("mngtasks1_activity_c").addFlags(
        Intent.FLAG_ACTIVITY_TASK_ON_HOME).addFlags(
        Intent.FLAG_ACTIVITY_NEW_TASK));
  }

Очистим таски. Запускаем второе приложение. Жмем Start. Открывается таск первого приложения, ActivityC. В нормальном режиме, если нажать сейчас Назад, то мы бы вернулись в таск второго приложения, в MainActivity. Но мы использовали флаг, поэтому нажимаем Назад и попадаем в Home.

Развертывание поэтапное с помощью feature flags

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

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

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

Развертывание поэтапное с помощью feature flags является ценным подходом, позволяющим разработчикам выпускать новые функции и признаки без риска проблем и сбоев в работе системы. Feature flags обеспечивают гибкость и управляемость при внедрении изменений и помогают командам разработки достичь высокой стабильности и безопасности системы.

How Feature Flags Work

When marketers are targeting users based on various attributes — age, location, gender, etc. — they want to ensure the information they want to share gets to the specific users. Thus, user targeting gives control over what is shared, with whom, and when. Something similar happens with feature flagging. 

When a web application loads, it will use the specific user’s attributes to determine what features will be shown. For example, canary launches imply a specific feature functioning only for a small group of users. The group can be chosen from the internal users, based on demographics, or deliberately at random; it varies from company to company. 

That way, after logging in, all the ‘canaries’ will see the newest features firsthand. The other users won’t see anything new yet. With time, when new features prove their efficiency, they will be gradually introduced to a larger audience. If new features prove to be less than hoped for, they can be turned off.

According to Martin Fowler, feature toggles can be classified as follows:

1. Release toggles. These toggles are used to hide incomplete features from groups of users or from all users. 
2. Experiment toggles. This type is used for A/B testing.
3. Ops toggles. These toggles are used to control the operational aspects of a system.
4. Permissioning toggles. This type is used to manage what features are available for different groups of users (e.g., premium users).

Add the feature flag in code

1. Add the new flag to the feature flag struct located in .
2. Set a default value in the function in the same file.
3. Use the feature flag in code as you would use a regular configuration setting. In tests, manipulate the configuration value to test value changes, such as activation and deactivation of the feature flag.
4. Code may be merged regardless of setup in the management system. In this case it will always take the default value supplied in the function.
5. Create a removal ticket for the feature flag. All feature flags should be removed as soon as they have been verified by Cloud. The ticket should encompass removal of the supporting code and archiving in the management system.

Feature flag code guidelines 

• A ticket should be created when a feature flag is added to remove the feature flag as soon as it isn’t required anymore.
• Tests should be written to verify the feature flag works as expected. Note that in cases where there may be a migration or new data, off to on and on to off should both be tested.
• Log messages by the feature should include the feature flag tag, with the feature flag name as a value, in order to ease debugging.

Принципы использования feature flags в разработке приложений для Android

• Гибкость и контроль: Основная идея заключается в том, что разработчики могут легко изменять поведение и функциональность приложения, не выпуская новые версии. Флаги функциональности позволяют выключать или включать функциональности в ручном или автоматическом режиме, давая разработчикам контроль над экспериментами и релизами. Это позволяет избежать ситуации, когда вследствие одной ошибки нужно выпускать новую версию приложения.
• Управление абонентами: Флаги функциональности могут быть использованы для управления экспериментами с малой долей пользователей, прежде чем представить изменения для всех пользователей. Разработчики могут включить новую функциональность только для определенного процента пользователей или определенной группы, чтобы получить обратную связь и оценить стабильность.
• Анти-фичи: Флаги функциональности также могут использоваться для включения/отключения функций или исправлений, которые могут вызывать проблемы или негативное влияние на определенных пользователях. Это позволяет разработчикам быстро реагировать на обратную связь пользователей и отключать проблемные функции или исправления до их исправления.
• Анимация и переключение: Если включение/отключение флагов функциональности происходит на уровне сервера, то приложение может обновить состояние флагов без необходимости обновления всего приложения. Это снижает затраты на обновление приложения и дает возможность быстро реагировать на запросы и обратную связь пользователей.

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

3 Who uses feature flags?

Developers have been the primary user of feature flags for many years. Because flags are implicated in code, they have typically required a developer or engineer to configure them.

Traditionally, developers used Boolean flags, a simple toggle that turned a feature on or off. It stores only true or false values and is basic in its complexity.

Now, thanks to advanced feature management solutions, product managers have gained more control over releases with the ability to update feature flags and even run product experiments. Developers can deploy code whenever they want, but product managers can decide who sees the changes in production and when.

This enables product teams to do more with feature flags.

Below is a summary of how feature flags may be used across R&D and product teams:

• Developers: configure flags for use across the product team.
• Product managers: roll out features incrementally, run feature experiments, and provide feature access to different user populations for feedback and testing.
• Quality Assurance (QA): use feature flags to test features in production, validate them internally first, and then release to a clearly defined production audience. Rolling out using feature flags also enables features to be rolled back if they’re problematic.

Because so many different teams can be using feature flags, they’re best managed with the help of a comprehensive and unified management tool.

Don’t Nest Feature Flags

You probably have seen code before that is deeply nested like this:

This code has a high cyclomatic complexity, meaning there are a lot of different branches the code can go through. This makes the code hard to understand and reason about.

The same is true for feature flags. Every evaluation of a feature flag in your code opens up another branch that may or may not be executed depending on the value of the feature flag.

It’s bad enough that feature flags increase the cyclomatic complexity of our code so we shouldn’t make it worse by unnecessarily nesting feature flags.

In the above code, the feature only has an effect if the features and are also enabled. There may be valid reasons for this, but this is very hard to understand. Every time you want to enable or disable the feature for a cohort of users, you have to make sure that the other two features are also enabled or disabled for the same cohort.

At some point, you will make a mistake and not get the results you expect!

9 Using Kameleoon to manage feature flags

Managing and implementing feature flags has never been easier, thanks to Kameleoon’s Full Stack Experimentation solution.

Kameleoon is the only optimization solution with web, full stack, and feature experimentation capabilities in a single unified platform. This means marketing and product teams can work in one platform, in their preferred environment. Working in a unified platform that creates transparency for all team members is especially important today, when various stages of the buyer experience are co-owned by these teams.

If marketing manages customer acquisition and product drives retention and monetization, it’s crucial to have a single view of the end-to-end customer experience. (Not to mention a single source of truth for data.)

Needless to say, a unified platform promotes closer collaboration between the product and engineering teams as well. With Kameleoon’s feature management and feature flag capabilities, product managers no longer have to ask developers to manually code every feature version. Feature flags can be easily managed and configured from an intuitive UI.

Here’s how product managers can simplify feature flag management with Kameleoon:

• Configure a flag, decide how it should be released using our Rollout Planner, and use advanced scheduling options to determine a release plan.
• Set alerts to roll back features based on goal performance.
• View, sort, and filter feature flags with a single dashboard.

Feature flags are more than just a tool for developers. They’re an integral part of any high-performing product team.

How feature flags work

Feature flags are usually managed in some sort of admin interface where you can choose which features should exist behind a feature flag and which people should have access to those features.

Once feature flags are set in the admin interface, the feature flags settings can be recovered and then used within an application’s API or web application to decide what block of code should be run (and hence which feature should be made available to a user).

Example taken from the Flagsmith landing page.

Side note
Lazy loading and feature flags

Ideally, code behind feature flags is lazy loaded since it doesn’t make sense to load code that a user will not be able to execute.

There are feature flag services available that provide the admin interface used to manage feature flags and also an API that can be called to get feature flags available for a particular user. Here’s a list of some feature flag services:

• LaunchDarkly
• Flagsmith
• Unleash (Open source)

If you’d rather not use a 3rd party service to manage feature flags, you could also build out your own feature flag service without too much trouble. A custom feature flag service might work as follows:

• In a feature flag admin page (that you could build out with a front-end framework), create a feature flag and specify which email accounts (or user IDs) should have access to that feature
• The feature flag settings are saved in a database
• When a user comes to visit the application, it will trigger an API call on initial app load that will request the feature flags enabled for that user
• The API will read the feature flag settings from the database and see if the currently authenticated user, which can be figured out via a JWT cookie or something similar, has access to the feature flag.
• Once the API determines which feature flags a user has access to, it will pass a list of feature flags to the front-end that correspond with the features the current user has access to
• The UI will conditionally display new features depending of whether a user has the feature flag corresponding with the particular feature

Feature flags can also be used on the server side if you’d like to prevent certain API functionality. For example, if you introduce a new API route related to a new feature, then you could check if the user that is calling the new API route has access to the new feature before trying to return/resolve data.

Feature Flags in Java

Feature flags in Java work by the same principle — they help when it’s still too early to introduce new features in a Java application, or if they should be available, only for specific users. Reasons may vary. For example, the business or application itself, might not be ready.  So it is handy to add a specific feature toggle and default it to ‘off’ until it is needed. 

Also, there are feature toggle management tools that allow adding feature toggles to improve the code. When the development team opens the code and changes it, it’s not Java flags at work, it’s a release deployment. Sometimes, release deployment is chosen over feature switches whose main drawback is a higher level of complexity. 

There are two ways to prevent feature switches from becoming unmanageable:

1. Prevent feature flag coupling. This means all values of feature toggles should be put into a particular class. That class will work as a single source of truth. It gives greater freedom and flexibility since it is possible to replace feature toggles storage with a database. It is also possible to implement switching flags in runtime.

2. Extracting feature toggles in Spring Boot. When there is a separate bean for all feature toggles, it is possible to insert Spring flags from the application.properties file through the @ConfigurationProperties annotation. 

You may also like: The 6 Best Data Modeling Tools

Как правильно внедрить и использовать feature flags в проекте для андроида?

1. Определите цели и требования: Прежде всего, определите цели и требования вашего проекта. Какие функциональные возможности или изменения вам необходимы? Какие группы пользователей вы хотите адресовать? Определите, какие параметры нужно управлять при помощи feature flags.

2. Разработайте архитектуру: Создайте гибкую архитектуру, которая позволит вам быстро и удобно включать или выключать функциональности в зависимости от настроек feature flags. Используйте принципы инверсии зависимостей и single responsibility при разработке.

3. Выберите подходящее решение: Используйте готовые решения для работы с feature flags или разработайте собственное. Некоторые популярные библиотеки для работы с feature flags на андроиде включают Firebase Remote Config, Optimizely, LaunchDarkly и другие. Выберите подходящее решение в зависимости от ваших требований.

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

5. Реализуйте контроль флагов: Реализуйте механизм контроля и проверки флагов в вашем приложении. Повесьте обработчики событий на изменение статуса флагов и реагируйте на изменения в зависимости от текущей конфигурации флагов.

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

7. Поддерживайте и обновляйте: Feature flags — это инструмент, который требует постоянной поддержки и обновлений. Обновляйте флаги при необходимости, добавляйте новые функциональности или изменения, а также обновляйте их в зависимости от потребностей проекта и пользователей.

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

Build or Buy: Feature Flag Management

You may be thinking, “Feature flags seem pretty simple, can’t we just build this ourselves?” 

The real answer? It’s complicated. 

We’ve seen in most cases that an internally-built tool will end up causing a lot of overhead and putting a very low ceiling on the benefits you can receive from feature flags. It may be good for your first couple of flags, but it can be hard to make an internal system scalable, performant, and robust for all the things flags can do as your organization gets more and more comfortable using them — and more reliant on them.

For a deeper look at the build vs buy conversation, you can check out an article we wrote earlier this month, Feature Flags: Should I Build or Buy?