Live Update

Visión general

La segmentación de usuarios es la práctica de dividir los usuarios en grupos que reflejen su parecido respecto a otros usuarios en cada grupo. Un ejemplo habitual sería una segmentación geográfica, esto es, la división de los usuarios en base a ubicación geográfica. El objetivo de la segmentación de usuarios es relacionarlos entre sí en cada segmento con el propósito de maximizar valores.

La característica Live Update en Mobile Foundation proporciona una forma simple de definir y ofrecer distintas configuraciones para cada segmento de usuarios de una aplicación. Incluye un componente en MobileFirst Operations Console para definir la estructura de la configuración así como los valores de la configuración para cada segmento. También se proporciona un SDK de cliente (disponible para Android e iOS nativas y Cordova) para consumir la configuración.

Casos de uso comunes

Live Update da soporte a la definición y utilización de configuraciones basadas en segmentos, haciendo más fácil realizar personalizaciones basadas en segmentos para la aplicación. Los casos de uso comunes pueden ser:

• Trenes de releases y cambios de características
• Realización de pruebas A/B
• Personalización basada en el contexto de la aplicación (por ejemplo, segmentación geográfica)

Demostración

En el siguiente vídeo se proporciona una demostración de la característica Live Update.

Ir a:

• Arquitectura de Live Update
• Adición de Live Update a MobileFirst Server
• Configuración de la seguridad de las aplicaciones
• Esquema y segmentos
• Adición de Live Update SDK a aplicaciones
• Utilización de Live Update SDK
• Temas avanzados
• Aplicación de ejemplo

Arquitectura de Live Update

Los siguientes componentes de sistema funcionan de forma conjunta con el propósito de proporcionar la funcionalidad de Live Update.

• Adaptador de Live Update: adaptador que proporciona:
• Gestión de segmentos y esquema de aplicación
• Aprovisionamiento de configuraciones a las aplicaciones
• *Adaptador resolvedor de segmentos: ** *Opcional. Se trata de un adaptador que implementan los desarrolladores. El adaptador recibe un contexto de aplicación (como por ejemplo, un contexto de usuario y dispositivo, así como parámetros personalizados) y devuelve el ID de un segmento que corresponde al contexto.
• SDK del lado de cliente: Live Update SDK sirve para recuperar y acceder a elementos de configuración como, por ejemplo, las propiedades y características desde MobileFirst Server.
• MobileFirst Operations Console: Se utiliza para configurar los valores y el adaptador de Live Update.
• Servicio de configuración: Interno. Proporciona servicios de gestión de configuración para el adaptador de Live Update.

Adición de Live Update a MobileFirst Server

De forma predeterminada, los valores de Live Update en MobileFirst Operations Console no se visualizan. Para ello, es necesario desplegar el adaptador de Live Update.

1. Abra MobileFirst Operations Console. Desde la navegación lateral, pulse el separador Centro de descargas → Herramientas.
2. Descargue y despliegue el adaptador Live Update.

Una vez desplegado, aparecerá la pantalla Valores de Live Update para cada aplicación registrada.

Configuración de la seguridad de las aplicaciones

Con el propósito de permitir la integración con Live Update, se necesita un elemento de ámbito. Sin este elemento, el adaptador rechazará las solicitudes de las aplicaciones de cliente.

Cargue MobileFirst Operations Console y pulse [su aplicación] → separador Seguridad → Correlaciones de elementos de ámbito. Pulse Nuevo y especifique el elemento de ámbito configuration-user-login. A continuación, pulse Añadir.

También puede correlacionar el elemento de ámbito con una comprobación de seguridad en el caso de que utilice una en su aplicación.

Aprenda más sobre la infraestructura de seguridad de MobileFirst

Esquema y segmentos

En la pantalla de Valores de Live Update hay disponibles dos separadores:

Qué es un esquema

Un esquema es el elemento donde se definen sus propiedades y características.

• Mediante las “características” se definen características de aplicación configurables y se establecen sus valores predeterminados.
• Mediante las “propiedades” se definen propiedades de aplicación configurables y se establecen sus valores predeterminados.

Segmentos

Los segmentos definen comportamientos de aplicación únicos al personalizar las características y las propiedades predeterminadas que el esquema define.

Adición de esquema y segmentos

Antes de añadir un esquema y segmentos para una aplicación, el equipo de gestión del producto o los desarrolladores necesitan decidir sobre los distintos aspectos:

• El conjunto de características que utilizar con Live Update así como su estado predeterminado.
• El conjunto de series properties configurables y sus valores predeterminados
• Los segmentos de mercado para la aplicación

Para cada segmento de mercado se debería decidir:

• El estado de cada característica, y de cómo este estado puede cambiar durante el tiempo de vida de la aplicación.
• El estado de cada propiedad, y de cómo esta propiedad puede cambiar durante el tiempo de vida de la aplicación.

Una vez los parámetros estén decididos, se podrán añadir características y propiedades de esquema.
Para añadir, pulse Nuevo y proporcione los valores solicitados.

Definición de propiedades y características de esquema con los valores predeterminados

Definición de segmentos que corresponden a segmentos de mercado

Modificación de los valores predeterminados de características y propiedades

Habilite una característica y cambie su estado predeterminado.

Modifique el valor predeterminado de una propiedad.

Adición de Live Update SDK a las aplicaciones

Live Update SDK proporciona a los desarrolladores una API para consultar propiedades y características de configuración de tiempo de ejecución de consulta que con anterioridad estaban definidas en la pantalla de Valores de Live Update de la aplicación registrada en MobileFirst Operations Console.

Para Cordova, utilice la versión del SDK 8.0.2019100111 o anterior.

• Documentación del plugin de Cordova

Para Android, utilice la versión del SDK 8.0.0.

• Documentación de Android SDK

Para iOS, utilice la versión del SDK 8.0.2017092018 o anterior.

• Documentación de iOS Swift SDK

Adición del plugin de Cordova

En la carpeta de la aplicación de Cordova ejecute:

cordova plugin add cordova-plugin-mfp-liveupdate

Adición de iOS SDK

1. Edite el podfile de la aplicación añadiendo el pod IBMMobileFirstPlatformFoundationLiveUpdate.
   Por ejemplo:

   use_frameworks!
   
   target 'your-Xcode-project-target' do
      pod 'IBMMobileFirstPlatformFoundation'
      pod 'IBMMobileFirstPlatformFoundationLiveUpdate'
   end
   

2. Desde una ventana de línea de mandatos, vaya a la carpeta raíz del proyecto Xcode y ejecute el mandato: pod install.

Adición de Android SDK

1. En Android Studio, seleccione Android → Scripts de Gradle y, a continuación, seleccione el archivo build.gradle (Módulo: app).

2. Añada ibmmobilefirstplatformfoundationliveupdate dentro de dependencies:

   dependencies {
        compile group: 'com.ibm.mobile.foundation',
        name: 'ibmmobilefirstplatformfoundation',
        version: '8.0.+',
        ext: 'aar',
        transitive: true
   
        compile group: 'com.ibm.mobile.foundation',
        name: 'ibmmobilefirstplatformfoundationliveupdate',
        version: '8.0.0',
        ext: 'aar',
        transitive: true
   }   
   

Utilización de Live Update SDK

Existen varias maneras de utilizar Live Update SDK.

Segmentos predeterminados

Lógica de implementación para recuperar una configuración de un segmento concreto.
Sustituya “segment-name”, “property-name” y “feature-name” con sus propios valores.

Cordova

    var input = { segmentId :'segment-name' };
    LiveUpdateManager.obtainConfiguration(input,function(configuration) {
        // do something with configration (JSON) object, for example,
        // if you defined in the server a feature named 'feature-name':
        // if (configuration.features.feature-name) {
        //   console.log(configuration.properties.property-name);
	// }
    } ,
    function(err) {
        if (err) {
           alert('liveupdate error:'+err);
        }
  });

iOS

LiveUpdateManager.sharedInstance.obtainConfiguration("segment-name", completionHandler: { (configuration, error) in
  if error == nil {
    print (configuration?.getProperty("property-name"))
    print (configuration?.isFeatureEnabled("feature-name"))
  } else {
    print (error)
  }
})

Android

LiveUpdateManager.getInstance().obtainConfiguration("segment-name", new ConfigurationListener() {

    @Override
    public void onSuccess(final Configuration configuration) {
        Log.i("LiveUpdateDemo", configuration.getProperty("property-name"));
        Log.i("LiveUpdateDemo", configuration.isFeatureEnabled("feature-name").toString());
    }

    @Override
    public void onFailure(WLFailResponse wlFailResponse) {
        Log.e("LiveUpdateDemo", wlFailResponse.getErrorMsg());
    }
});

Con la configuración de Live Update recuperada, la lógica de la aplicación y el flujo de la aplicación se basará en el estado de las características y propiedades. Por ejemplo, si hoy es una fiesta nacional, se presentará una nueva promoción de marketing en la aplicación.

Adaptador resolvedor de segmentos

En el tema Arquitectura de Live Update, se mencionó un adaptador “resolvedor de segmentos”.
El propósito de este adaptador es proporcionar una lógica empresarial personalizada para recuperar un segmento base al contexto de usuario/aplicación/dispositivo y los parámetros personalizados del aplicativo.

Para utilizar un adaptador resolvedor de segmentos:

1. Cree un nuevo adaptador Java.
2. Defina el adaptador como un adaptador resolvedor de segmentos en Adaptadores → Adaptador de Live Update → segmentResolverAdapterName.
3. Cuando se haya completado el desarrollo, recuerde también compilarlo y desplegarlo.

El adaptador resolvedor de segmentos define una interfaz REST. La solicitud a este adaptador contiene en su cuerpo toda la información necesaria para decidir el segmento al que pertenece el usuario final y lo envía de vuelta a la aplicación.

Si desea obtener la configuración mediante parámetros, utilice la API Live Update para enviar la solicitud:

Resolvedor de Cordova

var input = { params : { 'paramKey': 'paramValue'} ,useClientCache : true };                                                                                                    
LiveUpdateManager.obtainConfiguration(input,function(configuration) {
        // do something with configration (JSON) object, for example:
        // console.log(configuration.properties.property-name);                                                                                                             // console.log(configuration.data.features.feature-name);                                                                                                        
    } ,
    function(err) {
        if (err) {
           alert('liveupdate error:'+err);
        }
  });

iOS

LiveUpdateManager.sharedInstance.obtainConfiguration(["paramKey":"paramValue"], completionHandler: { (configuration, error) in
  if error == nil {
    print (configuration?.getProperty("property-name"))
    print (configuration?.isFeatureEnabled("feature-name"))
  } else {
    print (error)
  }
})

Android

Map <String,String> params = new HashMap<>();
params.put("paramKey", "paramValue");

LiveUpdateManager.getInstance().obtainConfiguration(params , new ConfigurationListener() {

    @Override
    public void onSuccess(final Configuration configuration) {
        Log.i("LiveUpdateDemo", configuration.getProperty("property-name"));
        Log.i("LiveUpdateDemo", configuration.isFeatureEnabled("feature-name").toString());
    }

    @Override
    public void onFailure(WLFailResponse wlFailResponse) {
        Log.e("LiveUpdateDemo", wlFailResponse.getErrorMsg());
    }
});

Implementación de adaptador

Los argumentos que la aplicación proporciona mediante el SDK de cliente de Live Update se pasan entonces al adaptador de Live Update y desde allí al adaptador resolvedor de segmentos. Esto lo realiza de forma automática el adaptador de Live Update sin que se necesite acción alguna por parte del desarrollador.

Actualice la implementación del adaptador resolvedor de segmentos recién creado para manejar estos argumentos para devolver el segmento relevante.
A continuación se muestra el código de ejemplo que puede utilizar.

Nota: Asegúrese de añadir la dependencia Gson en su pom.xml del adaptador:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.7</version>
</dependency>

SampleSegmentResolverAdapterApplication.java

@Api(value = "Sample segment resolver adapter")
@Path("/")
public class SampleSegmentResolverAdapter {

    private static final Gson gson = new Gson();
    private static final Logger logger = Logger.getLogger(SampleSegmentResolverAdapter.class.getName());

    @POST
    @Path("segment")
    @Produces("text/plain;charset=UTF-8")
    @OAuthSecurity(enabled = true, scope = "configuration-user-login")
    public String getSegment(String body) throws Exception {
        ResolverAdapterData data = gson.fromJson(body, ResolverAdapterData.class);
        String segmentName = "";

        // Get the custom arguments
        Map<String, List<String>> arguments = data.getQueryArguments();

        // Get the authenticatedUser object
        AuthenticatedUser authenticatedUser = data.getAuthenticatedUser();
        String name = authenticatedUser.getDisplayName();

        // Get registration data such as device and application
        RegistrationData registrationData = data.getRegistrationData();
        ApplicationKey application = registrationData.getApplication();
        DeviceData deviceData = registrationData.getDevice();

        // Based on the above context (arguments, authenticatedUser and registrationData) resolve the segment name.
        // Write your custom logic to resolve the segment name.

        return segmentName;
    }
}

SampleSegmentResolverAdapter.java

public class ResolverAdapterData {
    public ResolverAdapterData() {
    }

    public ResolverAdapterData(AdapterSecurityContext asc, Map<String, List<String>> queryArguments)
    {
        ClientData cd = asc.getClientRegistrationData();

        this.authenticatedUser = asc.getAuthenticatedUser();
        this.registrationData = cd == null ? null : cd.getRegistration();
        this.queryArguments = queryArguments;
    }

    public AuthenticatedUser getAuthenticatedUser() {
        return authenticatedUser;
    }

    public RegistrationData getRegistrationData() {
        return registrationData;
    }

    public Map<String, List<String>> getQueryArguments() {
        return queryArguments;
    }

    private AuthenticatedUser authenticatedUser;
    private RegistrationData registrationData;
    private Map<String, List<String>> queryArguments;
}

Interfaz REST del adaptador resolvedor de segmentos

Solicitud

Respuesta

Temas avanzados

Importación/Exportación

Una vez se hayan definido esquemas y segmentos, el administrador del sistema puede exportarlos e importarlos a otras instancias de servidor.

Exportación de esquema

curl --user admin:admin http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/schema > schema.txt

Importación de esquema

curl -X PUT -d @schema.txt --user admin:admin -H "Content-Type:application/json" http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/schema

• Sustituya “admin:admin” con su propio valor (el valor predeterminado es “admin”)
• Sustituya “localhost” y el número de puerto con el suyo propio si es necesario
• Sustituya el identificador de aplicación “com.sample.HelloLiveUpdate” con el de su propia aplicación.

Exportación de segmentos

curl --user admin:admin http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/segment?embedObjects=true > segments.txt

Importación de segmentos

#!/bin/bash
segments_number=$(python -c 'import json,sys;obj=json.load(sys.stdin);print len(obj["items"]);' < segments.txt)
counter=0
while [ $segments_number -gt $counter ]
do
    segment=$(cat segments.txt | python -c 'import json,sys;obj=json.load(sys.stdin);data_str=json.dumps(obj["items"]['$counter']);print data_str;')
    echo $segment | curl -X POST -d @- --user admin:admin --header "Content-Type:application/json" http://localhost:9080/mfpadmin/management-apis/2.0/runtimes/mfp/admin-plugins/liveUpdateAdapter/com.sample.HelloLiveUpdate/segment
    ((counter++))
done

• Sustituya “admin:admin” con su propio valor (el valor predeterminado es “admin”)
• Sustituya “localhost” y el número de puerto con el suyo propio si es necesario
• Sustituya el identificador de aplicación “com.sample.HelloLiveUpdate” con el de su propia aplicación.

Colocación en caché

De forma predeterminada está habilitada la colocación en caché para evitar la latencia de red. Esto significa que es posible que las actualizaciones no se realicen de forma inmediata.
La colocación en caché se puede inhabilitar si se necesitan actualizaciones más frecuentes.

Cordova

Controle la caché del lado del cliente mediante la utilización del distintivo booleano useClientCache opcional:

	var input = { segmentId :'18' ,useClientCache : false };
        LiveUpdateManager.getConfiguration(input,function(configuration) {
                // do something with resulting configuration, for example:
                // console.log(configuration.data.properties.property-name);  
                // console.log(configuration.data.features.feature-name);
        } ,
        function(err) {
                if (err) {
                   alert('liveupdate error:'+err);
                }
  });

iOS

LiveUpdateManager.sharedInstance.obtainConfiguration("segment-name", useCache: false, completionHandler: { (configuration, error) in
  if error == nil {
    print (configuration?.getProperty("property-name"))
    print (configuration?.isFeatureEnabled("feature-name"))
  } else {
    print (error)
  }
})

Android

LiveUpdateManager.getInstance().obtainConfiguration("segment-name", false, new ConfigurationListener() {

    @Override
    public void onSuccess(final Configuration configuration) {
      Log.i("LiveUpdateSample", configuration.getProperty("property-name"));
      Log.i("LiveUpdateSample", configuration.isFeatureEnabled("feature-name").toString());
    }

    @Override
    public void onFailure(WLFailResponse wlFailResponse) {
        Log.e("LiveUpdateSample", wlFailResponse.getErrorMsg());
    }
});

Caducidad de caché

El valor expirationPeriod que se define en Adaptadores → Adaptador de Live Update determina la longitud hasta que la colocación en caché caduca.

Aplicación de ejemplo

En la aplicación de ejemplo seleccione una bandera de un país y, a continuación, con la ayuda de Live Update la aplicación a continuación genera texto de salida en el idioma que corresponde al país seleccionado. Si se habilita la característica de mapa y se proporciona un mapa, se visualizará el correspondiente país.

Pulse para descargar el proyecto de Xcode.
Pulse para descargar el proyecto de Android Studio.

Uso de ejemplo

Siga el archivo README.md de ejemplo para obtener instrucciones.

Cómo cambiar los valores de Live Update

Cada segmento obtiene el valor predeterminado del esquema. Cambie cada uno de ellos según el idioma. Por ejemplo, para el francés, añada: helloText - Bonjour le monde.

En MobileFirst Operations Console → [su aplicación] → Valores de Live Update → separador Segmentos, pulse en el enlace Propiedades que le corresponde, por ejemplo para FR.

• Pulse el icono Editar y proporcione un enlace a una imagen que se representa por ejemplo para el mapa geográfico de Francia.
• Para ver el mapa mientras se utiliza la aplicación, necesita habilitar la característica includeMap.