Crear conmutadores de características

Los conmutadores de características te permiten habilitar o deshabilitar a distancia la funcionalidad para una selección de usuarios. Crea un nuevo conmutador de características dentro del panel de Braze. Proporciona un nombre y un ID, una audiencia objetivo y un porcentaje de usuarios para los que habilitar esta característica. Luego, utilizando ese mismo ID en el código de tu aplicación o sitio web, puedes ejecutar condicionalmente determinadas partes de tu lógica empresarial. Para saber más sobre los conmutadores de características y cómo puedes utilizarlos en Braze, consulta Acerca de los conmutadores de características.

Requisitos previos

Versión del SDK

Para usar conmutadores de características, asegúrate de que tus SDK estén actualizados con al menos estas versiones mínimas:

Permisos de Braze

Para gestionar los conmutadores de características en el panel, necesitarás ser administrador o tener los siguientes permisos:

Crear un conmutador de características

Paso 1: Crear un nuevo conmutador de características

Ve a Mensajería > Conmutadores de características y selecciona Crear conmutador de características.

Paso 2: Completar los detalles

En Detalles del conmutador de características, introduce un nombre, un ID y una descripción para tu conmutador de características.

Paso 2a: Crear propiedades personalizadas

En Propiedades, opcionalmente puedes crear propiedades personalizadas a las que tu aplicación puede acceder a través de Braze SDK cuando tu característica está habilitada. Puedes asignar un valor de cadena, booleano, imagen, marca de tiempo, JSON o número a cada variable, así como establecer un valor predeterminado.

• ejemplo

En el siguiente ejemplo, el conmutador de características muestra un banner de producto agotado para una tienda de comercio electrónico usando las propiedades personalizadas listadas:

Nombre de la propiedad	Tipo	Valor
banner_height	number	75
banner_color	string	blue
banner_text	string	Widgets are out of stock until July 1.
dismissible	boolean	false
homepage_icon	image	http://s3.amazonaws.com/[bucket_name]/
account_start	timestamp	2011-01-01T12:00:00Z
footer_settings	JSON	{ "colors": [ "red", "blue", "green" ], "placement": 123 }

Consejo

No hay límite en la cantidad de propiedades que puedes añadir. Sin embargo, las propiedades de un conmutador de características están limitadas a un total de 10 000 caracteres.

Paso 4: Elegir los segmentos a los que dirigirse

Antes de lanzar un conmutador de características, necesitas elegir un Segment de usuarios al que dirigirte. Selecciona Añadir regla en tu conmutador recién creado y luego usa los menús desplegables de grupo de filtros y Segment para filtrar usuarios de tu audiencia objetivo. Añade múltiples filtros para delimitar aún más tu audiencia.

Paso 5: Configurar el tráfico de lanzamiento

De forma predeterminada, los conmutadores de características siempre están inactivos, lo que te permite separar la fecha de lanzamiento de tu característica de la activación total de usuarios. Para comenzar tu lanzamiento, usa la sección Tráfico de lanzamiento para introducir un porcentaje en el cuadro de texto. Esto elegirá el porcentaje de usuarios aleatorios en tu Segment seleccionado que recibirán esta nueva característica.

Importante

No establezcas tu tráfico de lanzamiento a más del 0 % hasta que estés listo para que tu nueva característica entre en funcionamiento. Cuando definas inicialmente tu conmutador de características en el panel, deja esta configuración al 0 %.

Importante

Para lanzar un conmutador con una sola regla o a una audiencia singular, añade tu primera regla con los criterios de segmentación y los porcentajes de lanzamiento seleccionados. Por último, confirma que la regla Todos los demás esté desactivada y guarda tu conmutador.

Implementaciones de conmutadores de características con múltiples reglas

Usa las implementaciones de conmutadores de características con múltiples reglas para definir una secuencia de reglas para evaluar a los usuarios, lo que permite una segmentación precisa y lanzamientos de características controlados. Este método es ideal para desplegar la misma característica a audiencias diversas.

Orden de evaluación

Las reglas del conmutador de características se evalúan de arriba a abajo, en el orden en que están listadas. Un usuario se cualifica para la primera regla que cumpla. Si un usuario no cumple ninguna regla, su elegibilidad la determina la regla predeterminada “Todos los demás”.

Cualificación de usuarios

• Si un usuario cumple los criterios de la primera regla, es inmediatamente elegible para recibir el conmutador de características.
• Si un usuario no cualifica para la primera regla, se evalúa contra la segunda regla, y así sucesivamente.

La evaluación secuencial continúa hasta que un usuario cualifica para una regla o llega a la regla “Todos los demás” en la parte inferior de la lista.

Regla “Todos los demás”

La regla “Todos los demás” actúa como predeterminada. Si un usuario no cualifica para ninguna de las reglas anteriores, su elegibilidad para el conmutador de características la determinará la configuración de alternancia de la regla “Todos los demás”. Por ejemplo, si la regla “Todos los demás” está desactivada, en el estado predeterminado, un usuario que no cumpla los criterios de ninguna otra regla no recibirá el conmutador de características al inicio de su sesión.

Reordenar reglas

De forma predeterminada, las reglas están ordenadas en la secuencia en que se crearon, pero puedes reordenarlas arrastrándolas y soltándolas en el panel.

Ejemplos de conmutadores de características con múltiples reglas

Lanzar gradualmente una página de pago

Supongamos que trabajas para una marca de comercio electrónico y tienes una nueva página de pago que quieres implementar en distintas geografías para garantizar la estabilidad. Usando conmutadores de características con múltiples reglas, puedes configurar lo siguiente:

• Regla 1: Tu Segment de usuarios en EE. UU. se establece al 100%.
• Regla 2: Tu Segment se establece al 50% de tus usuarios brasileños, para que no todos reciban el flujo al mismo tiempo.
• Regla 3 (Todos los demás): Para todos los demás usuarios, activa tu regla “Todos los demás” y establécela al 15%, para que una parte de todos los usuarios pueda completar el pago con el nuevo flujo.

Llegar primero a los testers internos

Supongamos que eres un gestor de producto y quieres asegurarte de que tus testers internos siempre reciban el conmutador de características cuando lances un nuevo producto. Puedes añadir tu Segment de testers internos a tu primera regla y establecerlo al 100%, para que tus testers internos sean elegibles durante cada lanzamiento de características.

Utilizar el campo «habilitado» para tus conmutadores de características

Una vez definido tu conmutador de características, configura tu aplicación o sitio web para comprobar si está habilitado para un usuario concreto. Cuando esté habilitado, establecerás alguna acción o harás referencia a las propiedades variables del conmutador de características en función de tu caso de uso. El SDK de Braze proporciona métodos getter para obtener el estado de tu conmutador de características y sus propiedades en tu aplicación.

Los conmutadores de características se actualizan automáticamente al inicio de la sesión, para que puedas mostrar la versión más actualizada de tu característica en el momento del lanzamiento. El SDK almacena en caché estos valores para poder utilizarlos sin conexión.

Nota

Asegúrate de registrar las impresiones del conmutador de características.

Supongamos que vas a lanzar un nuevo tipo de perfil de usuario para tu aplicación. Puedes configurar el ID como expanded_user_profile. A continuación, harías que tu aplicación comprobara si debe mostrar este nuevo perfil de usuario a un usuario concreto. Por ejemplo:

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
6

const featureFlag = braze.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6

let featureFlag = braze.featureFlags.featureFlag(id: "expanded_user_profile")
if featureFlag?.enabled == true {
  print("expanded_user_profile is enabled")
} else {
  print("expanded_user_profile is not enabled")
}

1
2
3
4
5
6

FeatureFlag featureFlag = braze.getFeatureFlag("expanded_user_profile");
if (featureFlag != null && featureFlag.getEnabled()) {
  Log.i(TAG, "expanded_user_profile is enabled");
} else {
  Log.i(TAG, "expanded_user_profile is not enabled");
}

1
2
3
4
5
6

val featureFlag = braze.getFeatureFlag("expanded_user_profile")
if (featureFlag?.enabled == true) {
  Log.i(TAG, "expanded_user_profile is enabled.")
} else {
  Log.i(TAG, "expanded_user_profile is not enabled.")
}

1
2
3
4
5
6

const featureFlag = await Braze.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6

var featureFlag = Appboy.AppboyBinding.GetFeatureFlag("expanded_user_profile");
if (featureFlag != null && featureFlag.Enabled) {
  Console.WriteLine("expanded_user_profile is enabled");
} else {
  Console.WriteLine("expanded_user_profile is not enabled");
}

1
2
3
4
5
6

const featureFlag = await BrazePlugin.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6

BrazeFeatureFlag? featureFlag = await braze.getFeatureFlagByID("expanded_user_profile");
if (featureFlag?.enabled == true) {
  print("expanded_user_profile is enabled");
} else {
  print("expanded_user_profile is not enabled");
}

1
2
3
4
5
6

featureFlag = m.braze.getFeatureFlag("expanded_user_profile")
if featureFlag <> invalid and featureFlag.enabled
  print "expanded_user_profile is enabled"
else
  print "expanded_user_profile is not enabled"
end if

Registro de la impresión de un conmutador de características

Realiza un seguimiento de la impresión de un conmutador de características siempre que un usuario haya tenido la oportunidad de interactuar con tu nueva característica, o cuando podría haber interactuado si la característica está desactivada (en el caso de un grupo de control en una prueba A/B). Las impresiones del conmutador de características solo se registran una vez por sesión.

Normalmente, puedes poner esta línea de código directamente debajo de donde haces referencia a tu conmutador de características en tu aplicación:

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1

braze.logFeatureFlagImpression("expanded_user_profile");

1

braze.featureFlags.logFeatureFlagImpression(id: "expanded_user_profile")

1

braze.logFeatureFlagImpression("expanded_user_profile");

1

braze.logFeatureFlagImpression("expanded_user_profile")

1

Braze.logFeatureFlagImpression("expanded_user_profile");

1

Appboy.AppboyBinding.LogFeatureFlagImpression("expanded_user_profile");

1

BrazePlugin.logFeatureFlagImpression("expanded_user_profile");

1

braze.logFeatureFlagImpression("expanded_user_profile");

1

m.Braze.logFeatureFlagImpression("expanded_user_profile");

Acceder a las propiedades

Para acceder a las propiedades de un conmutador de características, utiliza uno de los métodos siguientes, según el tipo que hayas definido en el panel.

Si no existe ninguna propiedad del tipo correspondiente para la clave que proporcionaste, estos métodos devolverán null.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Returns the Feature Flag instance
const featureFlag = braze.getFeatureFlag("expanded_user_profile");

// Returns the String property
const stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
const booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
const numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
const imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a FeatureFlagJsonPropertyValue
const jsonProperty = featureFlag.getJsonProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Returns the Feature Flag instance
let featureFlag: FeatureFlag = braze.featureFlags.featureFlag(id: "expanded_user_profile")

// Returns the string property
let stringProperty: String? = featureFlag.stringProperty(key: "color")

// Returns the boolean property
let booleanProperty: Bool? = featureFlag.boolProperty(key: "expanded")

// Returns the number property as a double
let numberProperty: Double? = featureFlag.numberProperty(key: "height")

// Returns the Unix UTC millisecond timestamp property as an integer
let timestampProperty: Int? = featureFlag.timestampProperty(key: "account_start")

// Returns the image property as a String of the image URL
let imageProperty: String? = featureFlag.imageProperty(key: "homepage_icon")

// Returns the JSON object property as a [String: Any] dictionary
let jsonObjectProperty: [String: Any]? = featureFlag.jsonObjectProperty(key: "footer_settings")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Returns the Feature Flag instance
FeatureFlag featureFlag = braze.getFeatureFlag("expanded_user_profile");

// Returns the String property
String stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
Boolean booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
Number numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as a long
Long timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
String imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a JSONObject
JSONObject jsonObjectProperty = featureFlag.getJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Returns the Feature Flag instance
val featureFlag = braze.getFeatureFlag("expanded_user_profile")

// Returns the String property
val stringProperty: String? = featureFlag.getStringProperty("color")

// Returns the boolean property
val booleanProperty: Boolean? = featureFlag.getBooleanProperty("expanded")

// Returns the number property
val numberProperty: Number? = featureFlag.getNumberProperty("height")

// Returns the Unix UTC millisecond timestamp property as a long
val timestampProperty: Long? = featureFlag.getTimestampProperty("account_start")

// Returns the image property as a String of the image URL
val imageProperty: String?  = featureFlag.getImageProperty("homepage_icon")

// Returns the JSON object property as a JSONObject
val jsonObjectProperty: JSONObject? = featureFlag.getJSONProperty("footer_settings")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Returns the String property
const stringProperty = await Braze.getFeatureFlagStringProperty("expanded_user_profile", "color");

// Returns the boolean property
const booleanProperty = await Braze.getFeatureFlagBooleanProperty("expanded_user_profile", "expanded");

// Returns the number property
const numberProperty = await Braze.getFeatureFlagNumberProperty("expanded_user_profile", "height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = await Braze.getFeatureFlagTimestampProperty("expanded_user_profile", "account_start");

// Returns the image property as a String of the image URL
const imageProperty = await Braze.getFeatureFlagImageProperty("expanded_user_profile", "homepage_icon");

// Returns the JSON object property as an object
const jsonObjectProperty = await Braze.getFeatureFlagJSONProperty("expanded_user_profile", "footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Returns the Feature Flag instance
var featureFlag = Appboy.AppboyBinding.GetFeatureFlag("expanded_user_profile");

// Returns the String property
var stringProperty = featureFlag.GetStringProperty("color");

// Returns the boolean property
var booleanProperty = featureFlag.GetBooleanProperty("expanded");

// Returns the number property as an integer
var integerProperty = featureFlag.GetIntegerProperty("height");

// Returns the number property as a double
var doubleProperty = featureFlag.GetDoubleProperty("height");

// Returns the Unix UTC millisecond timestamp property as a long
var timestampProperty = featureFlag.GetTimestampProperty("account_start");

// Returns the image property as a String of the image URL
var imageProperty = featureFlag.GetImageProperty("homepage_icon");

// Returns the JSON object property as a JSONObject
var jsonObjectProperty = featureFlag.GetJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Returns the String property
const stringProperty = await BrazePlugin.getFeatureFlagStringProperty("expanded_user_profile", "color");

// Returns the boolean property
const booleanProperty = await BrazePlugin.getFeatureFlagBooleanProperty("expanded_user_profile", "expanded");

// Returns the number property
const numberProperty = await BrazePlugin.getFeatureFlagNumberProperty("expanded_user_profile", "height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = await BrazePlugin.getFeatureFlagTimestampProperty("expanded_user_profile", "account_start");

// Returns the image property as a String of the image URL
const imageProperty = await BrazePlugin.getFeatureFlagImageProperty("expanded_user_profile", "homepage_icon");

// Returns the JSON object property as an object
const jsonObjectProperty = await BrazePlugin.getFeatureFlagJSONProperty("expanded_user_profile", "footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Returns the Feature Flag instance
BrazeFeatureFlag featureFlag = await braze.getFeatureFlagByID("expanded_user_profile");

// Returns the String property
var stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
var booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
var numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as an integer
var timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
var imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a Map<String, dynamic> collection
var jsonObjectProperty = featureFlag.getJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

' Returns the String property
color = featureFlag.getStringProperty("color")

' Returns the boolean property
expanded = featureFlag.getBooleanProperty("expanded")

' Returns the number property
height = featureFlag.getNumberProperty("height")

' Returns the Unix UTC millisecond timestamp property
account_start = featureFlag.getTimestampProperty("account_start")

' Returns the image property as a String of the image URL
homepage_icon = featureFlag.getImageProperty("homepage_icon")

' Returns the JSON object property
footer_settings = featureFlag.getJSONProperty("footer_settings")

Obtener una lista de todos los conmutadores de características

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4

const features = getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4

let features = braze.featureFlags.featureFlags
for let feature in features {
  print("Feature: \(feature.id)", feature.enabled)
}

1
2
3
4

List<FeatureFlag> features = braze.getAllFeatureFlags();
for (FeatureFlag feature: features) {
  Log.i(TAG, "Feature: ", feature.getId(), feature.getEnabled());
}

1
2
3
4

val featureFlags = braze.getAllFeatureFlags()
featureFlags.forEach { feature ->
  Log.i(TAG, "Feature: ${feature.id} ${feature.enabled}")
}

1
2
3
4

const features = await Braze.getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4

List<FeatureFlag> features = Appboy.AppboyBinding.GetAllFeatureFlags();
foreach (FeatureFlag feature in features) {
  Console.WriteLine("Feature: {0} - enabled: {1}", feature.ID, feature.Enabled);
}

1
2
3
4

const features = await BrazePlugin.getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4

List<BrazeFeatureFlag> featureFlags = await braze.getAllFeatureFlags();
featureFlags.forEach((feature) {
  print("Feature: ${feature.id} ${feature.enabled}");
});

1
2
3
4

features = m.braze.getAllFeatureFlags()
for each feature in features
      print "Feature: " + feature.id + " enabled: " + feature.enabled.toStr()
end for

Actualizar los conmutadores de características

Puedes actualizar los conmutadores de características del usuario actual en mitad de la sesión para obtener los últimos valores de Braze.

Consejo

La actualización se produce automáticamente al iniciar la sesión. Solo es necesario actualizar antes de acciones importantes del usuario, como antes de cargar una página de pago, o si sabes que se hará referencia a un conmutador de características.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5

braze.refreshFeatureFlags(() => {
  console.log(`Feature flags have been refreshed.`);
}, () => {
  console.log(`Failed to refresh feature flags.`);
});

1
2
3
4
5
6
7
8

braze.featureFlags.requestRefresh { result in
  switch result {
  case .success(let features):
    print("Feature flags have been refreshed:", features)
  case .failure(let error):
    print("Failed to refresh feature flags:", error)
  }
}

1

braze.refreshFeatureFlags();

1

braze.refreshFeatureFlags()

1

Braze.refreshFeatureFlags();

1

Appboy.AppboyBinding.RefreshFeatureFlags();

1

BrazePlugin.refreshFeatureFlags();

1

braze.refreshFeatureFlags();

1

m.Braze.refreshFeatureFlags()

Escuchar los cambios

Puedes configurar el SDK de Braze para que escuche y actualice tu aplicación cuando el SDK actualice cualquier conmutador de características.

Esto es útil si quieres actualizar tu aplicación cuando un usuario ya no es elegible para una característica. Por ejemplo, establecer algún estado en tu aplicación en función de si una característica está habilitada o no, o de uno de sus valores de propiedad.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku
• react hook

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

import * as braze from "@braze/web-sdk";

// - Available in version 7.0.0+
// Register an event listener
const subscriptionId = braze.subscribeToFeatureFlagsEvents((event) => {
  switch (event.type) {
    case braze.ChannelEventType.CACHE_REPLAY:
      // Sent once, right away, with the feature flags that are already cached.
      // Evaluate your flags now instead of waiting for the network.
      console.log("Cached feature flags:", event.cacheSnapshot.featureFlags);
      break;

    case braze.ChannelEventType.CACHE_LOAD:
      // The cache changed without a refresh, such as after changeUser().
      // The snapshot can be empty, so reset any state from the previous user.
      console.log("Feature flags reloaded:", event.cacheSnapshot.featureFlags);
      break;

    case braze.ChannelEventType.DATA_UPDATED:
      // A refresh finished, even if no feature flags changed.
      console.log("Feature flags were updated:", event.cacheSnapshot.featureFlags);
      break;

    case braze.ChannelEventType.ERROR:
      switch (event.retryState) {
        case braze.RetryState.SDK_WILL_RETRY:
          // The SDK is retrying. Keep the current values and wait.
          break;
        case braze.RetryState.INTEGRATOR_MAY_RETRY: {
          // The SDK stopped retrying. Try again later, and limit how often you retry.
          const delayMs = event.rateLimitedUntil
            ? Math.max(event.rateLimitedUntil.getTime() - Date.now(), 0)
            : 30000;
          setTimeout(() => braze.refreshFeatureFlags(), delayMs);
          break;
        }
        case braze.RetryState.DO_NOT_RETRY:
          // The failure is final. For example, feature flags are disabled for this workspace.
          if (event.reason === braze.ChannelErrorReason.FEATURE_DISABLED) {
            // Fall back to the default behavior in your app.
          }
          break;
      }
      break;
  }
});

// Register an event listener
const deprecatedSubscriptionId = braze.subscribeToFeatureFlagsUpdates((features) => {
  console.log(`Features were updated`, features);
});

// Unregister this event listener
braze.removeSubscription(subscriptionId);
braze.removeSubscription(deprecatedSubscriptionId);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Create the feature flags subscription
// - You must keep a strong reference to the subscription to keep it active

// - Available in version 19.0.0+
let subscription = braze.featureFlags.subscribeToEvents { event in
  switch event {
  case .cacheReplay(let cacheSnapshot), .cacheLoad(let cacheSnapshot):
    print("Feature flags were updated:", cacheSnapshot.featureFlags)
  case .dataUpdated(let cacheSnapshot, _):
    print("Feature flags were updated:", cacheSnapshot.featureFlags)
  default:
    break
  }
}

// Cancel the subscription
subscription.cancel()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// - Available in version 44.0.0+
braze.subscribeToFeatureFlagsEvents(event -> {
  if (event instanceof FeatureFlagsEvent.CacheReplay) {
    logFeatureFlags(((FeatureFlagsEvent.CacheReplay) event).getCacheSnapshot());
  } else if (event instanceof FeatureFlagsEvent.CacheLoad) {
    logFeatureFlags(((FeatureFlagsEvent.CacheLoad) event).getCacheSnapshot());
  } else if (event instanceof FeatureFlagsEvent.DataUpdated) {
    logFeatureFlags(((FeatureFlagsEvent.DataUpdated) event).getCacheSnapshot());
  }
});

braze.subscribeToFeatureFlagsUpdates(event -> {
  for (FeatureFlag feature : event.getFeatureFlags()) {
    Log.i(TAG, "Feature: " + feature.getId() + " " + feature.getEnabled());
  }
});

private void logFeatureFlags(FeatureFlagsCacheSnapshot cacheSnapshot) {
  for (FeatureFlag feature : cacheSnapshot.getFeatureFlags()) {
    Log.i(TAG, "Feature: " + feature.getId() + " " + feature.getEnabled());
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// - Available in version 44.0.0+
braze.subscribeToFeatureFlagsEvents { event ->
  when (event) {
    is FeatureFlagsEvent.CacheReplay -> logFeatureFlags(event.cacheSnapshot)
    is FeatureFlagsEvent.CacheLoad -> logFeatureFlags(event.cacheSnapshot)
    is FeatureFlagsEvent.DataUpdated -> logFeatureFlags(event.cacheSnapshot)
    else -> {}
  }
}

braze.subscribeToFeatureFlagsUpdates { event ->
  event.featureFlags.forEach { feature ->
    Log.i(TAG, "Feature: ${feature.id} ${feature.enabled}")
  }
}

private fun logFeatureFlags(cacheSnapshot: FeatureFlagsCacheSnapshot) {
  cacheSnapshot.featureFlags.forEach { feature ->
    Log.i(TAG, "Feature: ${feature.id} ${feature.enabled}")
  }
}

1
2
3
4

// Register an event listener
Braze.addListener(braze.Events.FEATURE_FLAGS_UPDATED, (featureFlags) => {
  console.log(`featureFlagUpdates`, JSON.stringify(featureFlags));
});

1
2
3
4

// Register an event listener
BrazePlugin.subscribeToFeatureFlagUpdates((featureFlags) => {
    console.log(`featureFlagUpdates`, JSON.stringify(featureFlags));
});

1
2
3
4
5
6
7
8
9

// Create stream subscription
StreamSubscription featureFlagsStreamSubscription;

featureFlagsStreamSubscription = braze.subscribeToFeatureFlags((featureFlags) {
  print("Feature flags were updated");
});

// Cancel stream subscription
featureFlagsStreamSubscription.cancel();

1
2

' Define a function called `onFeatureFlagChanges` to be called when feature flags are refreshed
m.BrazeTask.ObserveField("BrazeFeatureFlags", "onFeatureFlagChanges")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import { useEffect, useState } from "react";
import {
  ChannelEventType,
  FeatureFlag,
  getFeatureFlag,
  removeSubscription,
  subscribeToFeatureFlagsEvents,
  subscribeToFeatureFlagsUpdates,
} from "@braze/web-sdk";

export const useFeatureFlag = (id: string): FeatureFlag => {
  const [featureFlag, setFeatureFlag] = useState<FeatureFlag>(
    getFeatureFlag(id)
  );

  useEffect(() => {
    // - Available in version 7.0.0+
    const listener = subscribeToFeatureFlagsEvents((event) => {
      switch (event.type) {
        case ChannelEventType.CACHE_REPLAY:
        case ChannelEventType.CACHE_LOAD:
        case ChannelEventType.DATA_UPDATED:
          setFeatureFlag(getFeatureFlag(id));
          break;
      }
    });

    const deprecatedListener = subscribeToFeatureFlagsUpdates(() => {
      setFeatureFlag(getFeatureFlag(id));
    });

    return () => {
      removeSubscription(listener);
      removeSubscription(deprecatedListener);
    };
  }, [id]);

  return featureFlag;
};

Para una descripción de cada evento que subscribeToFeatureFlagsEvents (Android) y subscribeToEvents (Swift) pueden entregar, consulta la tabla de eventos en Conmutadores de características. Para Web, consulta la tabla de eventos en Escuchar los cambios.

Comprobar la elegibilidad de los usuarios

Para comprobar para qué conmutadores de características es elegible un usuario en Braze, ve a Audiencia > Buscar usuarios y busca y selecciona un usuario.

En la pestaña Elegibilidad de conmutadores de características, puedes filtrar la lista de conmutadores de características elegibles por plataforma, aplicación o dispositivo. También puedes obtener una vista previa de la carga útil que se devolverá al usuario seleccionando junto a un conmutador de características.

Visualización del registro de cambios

Para ver el registro de cambios de un conmutador de características, abre un conmutador de características y selecciona Registro de cambios.

Aquí puedes revisar cuándo se realizó un cambio, quién lo hizo, a qué categoría pertenece y más.

Segmentación con conmutadores de características

Braze hace un seguimiento automático de los usuarios que tienen habilitado un conmutador de características. Puedes crear un segmento o dirigir mensajería utilizando el filtro Feature Flag. Para más información sobre cómo filtrar por segmentos, consulta Crear un segmento.

Nota

Para evitar segmentos recursivos, no es posible crear un segmento que haga referencia a otros conmutadores de características.

Prácticas recomendadas

No combines despliegues con Canvas ni con experimentos

Para evitar que los usuarios sean habilitados y deshabilitados por diferentes puntos de entrada, debes establecer el control deslizante de despliegues en un valor superior a cero O habilitar el conmutador de características en un Canvas o experimento. Como práctica recomendada, si planeas usar un conmutador de características en un Canvas o experimento, mantén el porcentaje de despliegue en cero.

Convenciones de nomenclatura

Para mantener tu código claro y consistente, considera usar el siguiente formato al nombrar el ID de tu conmutador de características:

1

BEHAVIOR_PRODUCT_FEATURE

Sustituye lo siguiente:

A continuación se muestra un ejemplo de conmutador de características donde show es el comportamiento, animation_profile es el producto y driver es la característica:

1

show_animation_profile_driver

Planificar con anticipación

Siempre ve a lo seguro. Al considerar nuevas características que puedan requerir una forma de desactivación, es mejor lanzar código nuevo con un conmutador de características y no necesitarlo, que darse cuenta de que se necesita una nueva actualización de la aplicación.

Sé descriptivo

Añade una descripción a tu conmutador de características. Aunque se trata de un campo opcional en Braze, puede ayudar a responder preguntas que otros puedan tener al explorar los conmutadores de características disponibles.

• Datos de contacto de la persona responsable de la habilitación y el comportamiento de este conmutador
• Cuándo se debe deshabilitar este conmutador
• Enlaces a documentación o notas sobre la nueva característica que controla este conmutador
• Cualquier dependencia o nota sobre cómo utilizar la característica

Limpia los conmutadores de características antiguos

Todos somos culpables de dejar características habilitadas al 100 % de despliegue más tiempo del necesario.

Para ayudar a mantener tu código (y el panel de Braze) limpio, elimina los conmutadores de características permanentes de tu base de código una vez que todos los usuarios se hayan actualizado y ya no necesites la opción de deshabilitar la característica. Esto ayuda a reducir la complejidad de tu entorno de desarrollo, y además mantiene ordenada tu lista de conmutadores de características.