DEV Community: HuaweiDevsLATAM

Guía para registrarse en nuestras Actividades.

HuaweiDevsLATAM — Thu, 09 Dec 2021 22:08:50 +0000

Hola!

Es muy fácil registrarse en nuestras actividades y participar en la dinámicas que lanzamos en HUAWEI Developers Latinoamérica.

Actualemente estamos ejecutando múltiples dinámicas para hacer crecer nuestra comunidad. Estos son los enlaces.

HUAWEI Developers Latinoamérica WINTER CONTEST
https://bit.ly/32dYDHU

HDG GROUP MÉXICO
https://bit.ly/3m01qf3

HDG GROUP PERÚ
https://bit.ly/3rKyJ9x

HDG GROUP Panamá y Costa Rica
https://bit.ly/3Eiqll1

HDG GROUP CHILE
https://bit.ly/3dbNSYT

Para registrarte será necesario crear tu cuenta de HUAWEI Developer. Sigue los siguientes pasos.

Da click en el enlace al que desees registrarte, para ver una imagen con un botón de registro.

Para poder registrarte deberás contar con una cuenta de Developer Huawei. Podrás crear una cuenta gratuitamente.
Llena el formulario con tus datos, no olvides seleccionar tu país. Puedes seleccionar el registro con email ó con tu teléfono.
Al momento de tu registro deberás obtener el código de verificación en la bandeja de entrada de tu correo ó a través de SMS.
Una vez llenado el formulario acepta el aviso de privacidad.
Ahora debemos de agregar el numero telefónico par poder recuperar tu cuenta en caso de olvidar la contraseña.

Al terminar el proceso de agregar tu código de verificacion serás redirigido a la siguiente página en donde ya podrás inscribirte a la actividad.

Listo! ya estás registrado en la actividad.

Si estas participando en el programa de referidos tus colegas deberán realizar este proceso y compartirte la fotografia de su correo registrado en developer.huawei.com tal como esta imagen.

Para conseguirla solo deberas ir a la seccion de My Profile

(≧▽≦ﾉﾉﾞ☆

Guía de configuración de Android Studio

HuaweiDevsLATAM — Thu, 17 Jun 2021 20:12:48 +0000

Finalmente estamos listos para desarrollar aplicaciones, ya sea que te hayas especializado en Java o Kotlin, necesitarás instalar y configurar Android Studio para programar tus primeros ejercicios o desarrollar una aplicación completa y list para las tiendas de aplicaciones.

Instalando el IDE

Android Studio se encuentra disponible de forma gratuita desde su sitio oficial, por lo que podrás descargarlo de forma segura para Windows o Mac OS. En caso de que te encuentres usando una distribución LINUX, te recomendamos instalar Android Studio desde snapcraft para ahorrar algo de tiempo en la instalación, aunque también puedes descargar el paquete tarball directo desde el sitio oficial.

Configuración especial para LINUX

51-android.rules

En LUNIX no necesitamos instalar los drivers de nuestro teléfono para poder probar nuestras apps, sin embargo es necesario crear un archivo con el identificador del fabricante de nuestro dispositivo.

Ejecuta el siguiente comando:

sudo gedit /etc/udev/rules.d/51-android.rules

Puedes reemplazar Gedit por tu editor de texto preferido. Te recomendamos llenar este archivo con todos los identificadores de fabricante que la comunidad ha recolectado en GitHub, de este modo, Android Studio será capáz de detectar prácticamente cualquier dispositivo Android.

Android Device Bridge

Otro de los pre-requisitos es instalar ADB, los usuarios de distros basadas en Debian como Ubuntu, pueden instalarlo mediante este comando:

sudo apt-get install android-tools-adb

los usuarios de distros basados en Fedora/SUSE pueden usar el siguiente comando:

sudo yum install android-tools

Al concluir estos pasos tendremos todo lo necesario para instalar Android Studio en nuestro sistema LINUX.

Configuración del IDE

Al ejecutar Android Studio por primera vez nos pedirá definir una configuración básica para su funcionamiento, te recomendamos realizar la instalación standar.

Una vez instalado ve al menú de Configure -> SDK Manager para descargar el SDK.

Selecciona la version de android más reciente y presiona ok.

El SDK se descargará e instalará automáticamente, presiona finish para completar el proceso.

Eso es todo, ahora tienes odo lo necesario para comenzar a desarrollar.

Happy Coding!

Guía de configuración del entorno de desarrollo de Kotlin

HuaweiDevsLATAM — Wed, 02 Jun 2021 01:39:12 +0000

Para poder dar nuestros primeros pasos con Kotlin, debemos instalar las herramientas que necesitamos, así que aquí está la serie de pasos que debes de seguir:

1) Instalación de Visual Studio Code

Este editor de código esta disponible para Mac, Windows y Linux. Puedes descargarlo gratuitamente desde su sitio oficial ahí también encontrarás las instrucciones de instalación para cada sistema operativo.

2)Descargando la extensión: Kotlin Language.

Ya que tenemos instalado Visual Studio Code, vamos a proceder a instalar la extensión para Kotlin. Vamos a dirigirnos a la pestaña de extensiones, para después escribir el nombre de la extensión que deseamos en la barra de búsqueda, este caso “Kotlin Language”, para así ver la extensión en las opciones recomendadas.

Finalmente, daremos instalar y listo, la extensión de Kotlin Language estará exitosamente instalada en nuestro editor de código.

3) Descargando la extensión: Code Runner

De igual forma nos dirigiremos a la pestaña de extensiones y escribiremos el nombre de la extensión de nuestro interés, en este caso Code Runner.

Finalmente vamos presionar el botón de instalar y tendremos la extensión instalada en Visual Studio Code.

4) Instalando el compilador de Kotlin

Para comenzar a ejecutar nuestro programa de Kotlin, debemos de instalar el compilador, puedes descargarlo desde este enlace

Ya descargado el archivo .zip vamos a extraerlo y a colocar la carpeta kotlinc en alguna parte de nuestro sistema de archivos, que no olvidemos.

Procederemos a editar nuestra variable de entorno PATH y pondremos la dirección donde se encuentre la carpeta kotlinc > bin.

Reinicia tu computadora y ya tendrás todo lo necesario para comenzar a desarrollar con Kotlin.

Cómo un desarrollador programó una app de lectura de textos para su abuelo de 80 años

HuaweiDevsLATAM — Fri, 28 May 2021 01:21:58 +0000

John, ¿has visto mis lentes?

Nuestro viejo amigo John, programador de Huawei, tiene un abuelo que a pesar de su vejez, es un ávido lector. Se inclinaba hacia atrás, luchando para entender lo que estaba escrito en el periódico a través de sus gafas, pero incapaz de quitar sus ojos del texto - así era como mi abuelo solía leer, explicó John.

Leer de esta manera perjudicó la visión de su abuelo, y se le ocurrió a John que los oídos podían asumir el papel de "lectura" de los ojos. Pronto desarrolló una aplicación de lectura de texto que seguía esta lógica, reconociendo y luego leyendo texto de una imagen. Gracias a esta aplicación, el abuelo de John ahora puede "leer" desde la comodidad de su mecedora, sin tener que tensar sus ojos.

Cómo implementarlo

El usuario toma una foto de un pasaje de texto.La aplicación identifica automáticamente la ubicación del texto dentro de la imagen, y ajusta el ángulo de tiro a un ángulo que está frente directamente al texto.
La aplicación reconoce y extrae el texto de la imagen.
La aplicación convierte el texto reconocido en salida de audio aprovechando la tecnología de texto a voz.
Estas funciones son fáciles de implementar cuando se basa en tres servicios en el Kit ML de HUAWEI: corrección de desvío de documentos, reconocimiento de texto y texto a voz (TTS).

Preparativos

Configura el repositorio Maven de Huawei

buildscript {
    repositories {
        google()
        jcenter()
        maven {url 'https://developer.huawei.com/repo/'}
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.1.1"
        classpath 'com.huawei.agconnect:agcp:1.4.2.300'
        // NOTE: Do not place your app dependencies here; they belong
        // in the individual module build.gradle files.
    }
}
allprojects {
    repositories {
        google()
        jcenter()
        maven {url 'https://developer.huawei.com/repo/'}
    }
}

Agrega las dependencias de compilación del SDK de HMS Core

dependencies {

    // Import the base SDK.
    implementation 'com.huawei.hms:ml-computer-voice-tts:2.1.0.300'
    // Import the bee voice package.
    implementation 'com.huawei.hms:ml-computer-voice-tts-model-bee:2.1.0.300'
    // Import the eagle voice package.
    implementation 'com.huawei.hms:ml-computer-voice-tts-model-eagle:2.1.0.300'
    // Import a PDF file analyzer.
    implementation 'com.itextpdf:itextg:5.5.10'
}

Pulsa Anterior o SIguiente para pasar a la página anterior o siguiente. Pulsa hablar para empezar a leer; toca de nuevo para pausar la lectura.

Proceso de desarrollo

1) Crea un motor de TTS utilizando la clase de configuración personalizada MLTtsConfig. Aquí, el TTS en el dispositivo se utiliza como ejemplo.

private void initTts() {
    // Set authentication information for your app to download the model package from the server of Huawei.
    MLApplication.getInstance().setApiKey(AGConnectServicesConfig.
            fromContext(getApplicationContext()).getString("client/api_key"));
    // Create a TTS engine by using MLTtsConfig.
    mlTtsConfigs = new MLTtsConfig()
            // Set the text converted from speech to English.
            .setLanguage(MLTtsConstants.TTS_EN_US)
            // Set the speaker with the English male voice (eagle).
            .setPerson(MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_MALE_EAGLE)
            // Set the speech speed whose range is (0, 5.0]. 1.0 indicates a normal speed.
            .setSpeed(.8f)
            // Set the volume whose range is (0, 2). 1.0 indicates a normal volume.
            .setVolume(1.0f)
            // Set the TTS mode to on-device.
            .setSynthesizeMode(MLTtsConstants.TTS_OFFLINE_MODE);
    mlTtsEngine = new MLTtsEngine(mlTtsConfigs);
    // Update the configuration when the engine is running.
    mlTtsEngine.updateConfig(mlTtsConfigs);
    // Pass the TTS callback function to the TTS engine to perform TTS.
    mlTtsEngine.setTtsCallback(callback);
    // Create an on-device TTS model manager.
    manager = MLLocalModelManager.getInstance();
    isPlay = false;
}

2) Crea un TTS Callback para procesar el resultado de TTS.

MLTtsCallback callback = new MLTtsCallback() {
    @Override
    public void onError(String taskId, MLTtsError err) {
        // Processing logic for TTS failure.
    }
    @Override
    public void onWarn(String taskId, MLTtsWarn warn) {
        // Alarm handling without affecting service logic.
    }
    @Override
    // Return the mapping between the currently played segment and text. start: start position of the audio segment in the input text; end (excluded): end position of the audio segment in the input text.
    public void onRangeStart(String taskId, int start, int end) {
        // Process the mapping between the currently played segment and text.
    }
    @Override
    // taskId: ID of a TTS task corresponding to the audio.
    // audioFragment: audio data.
    // offset: offset of the audio segment to be transmitted in the queue. One TTS task corresponds to a TTS queue.
    // range: text area where the audio segment to be transmitted is located; range.first (included): start position; range.second (excluded): end position.
    public void onAudioAvailable(String taskId, MLTtsAudioFragment audioFragment, int offset,
                                 Pair<Integer, Integer> range, Bundle bundle) {
        // Audio stream callback API, which is used to return the synthesized audio data to the app.
    }
    @Override
    public void onEvent(String taskId, int eventId, Bundle bundle) {
        // Callback method of a TTS event. eventId indicates the event name.
        boolean isInterrupted;
        switch (eventId) {
            case MLTtsConstants.EVENT_PLAY_START:
                // Called when playback starts.
                break;
            case MLTtsConstants.EVENT_PLAY_STOP:
                // Called when playback stops.
                isInterrupted = bundle.getBoolean(MLTtsConstants.EVENT_PLAY_STOP_INTERRUPTED);
                break;
            case MLTtsConstants.EVENT_PLAY_RESUME:
                // Called when playback resumes.
                break;
            case MLTtsConstants.EVENT_PLAY_PAUSE:
                // Called when playback pauses.
                break;
            // Pay attention to the following callback events when you focus on only the synthesized audio data but do not use the internal player for playback.
            case MLTtsConstants.EVENT_SYNTHESIS_START:
                // Called when TTS starts.
                break;
            case MLTtsConstants.EVENT_SYNTHESIS_END:
                // Called when TTS ends.
                break;
            case MLTtsConstants.EVENT_SYNTHESIS_COMPLETE:
                // TTS is complete. All synthesized audio streams are passed to the app.
                isInterrupted = bundle.getBoolean(MLTtsConstants.EVENT_SYNTHESIS_INTERRUPTED);
                break;
            default:
                break;
        }
    }
};

3) Extrae el texto de un PDF

private String loadText(String path) {
    String result = "";
    try {
        PdfReader reader = new PdfReader(path);
        result = result.concat(PdfTextExtractor.getTextFromPage(reader,
                mCurrentPage.getIndex() + 1).trim() + System.lineSeparator());
        reader.close();
    } catch (IOException e) {
        showToast(e.getMessage());
    }
    // Obtain the position of the header.
    int header = result.indexOf(System.lineSeparator());
    // Obtain the position of the footer.
    int footer = result.lastIndexOf(System.lineSeparator());
    if (footer != 0){
        // Do not display the text in the header and footer.
        return result.substring(header, footer - 5);
    }else {
        return result;
    }
}

4) Invoca TTS de lado del dispositivo

// Create an MLTtsLocalModel instance to set the speaker so that the language model corresponding to the speaker can be downloaded through the model manager.
MLTtsLocalModel model = new MLTtsLocalModel.Factory(MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_MALE_EAGLE).create();
manager.isModelExist(model).addOnSuccessListener(new OnSuccessListener<Boolean>() {
    @Override
    public void onSuccess(Boolean aBoolean) {
        // If the model is not downloaded, call the download API. Otherwise, call the TTS API of the on-device engine.
        if (aBoolean) {
            String source = loadText(mPdfPath);
            // Call the speak API to perform TTS. source indicates the text to be synthesized.
            mlTtsEngine.speak(source, MLTtsEngine.QUEUE_APPEND);
            if (isPlay){
                // Pause playback.
                mlTtsEngine.pause();
                tv_speak.setText("speak");
            }else {
                // Resume playback.
                mlTtsEngine.resume();
                tv_speak.setText("pause");
            }
            isPlay = !isPlay;
        } else {
            // Call the API for downloading the on-device TTS model.
            downloadModel(MLTtsConstants.TTS_SPEAKER_OFFLINE_EN_US_MALE_EAGLE);
            showToast("The offline model has not been downloaded!");
        }
    }
}).addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(Exception e) {
        showToast(e.getMessage());
    }
});

5) Libera los recursos al destruir la interfáz de usuario

@Override
protected void onDestroy() {
    super.onDestroy();
    try {
        if (mParcelFileDescriptor != null) {
            mParcelFileDescriptor.close();
        }
        if (mCurrentPage != null) {
            mCurrentPage.close();
        }
        if (mPdfRenderer != null) {
            mPdfRenderer.close();
        }
        if (mlTtsEngine != null){
            mlTtsEngine.shutdown();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Otros Escenarios de aplicación

TTS puede utilizarse en una amplia gama de escenarios.Por ejemplo, podrías integrarlo en una aplicación de educación para leer cuentos para dormir a los niños, o integrarlo en una aplicación de navegación, que podría leer instrucciones en voz alta.

Detección de estado de salud con AR Engine

HuaweiDevsLATAM — Fri, 07 May 2021 16:18:53 +0000

Introducción

AR Engine tiene soporte para detectar tu rostro y obtener datos saludables como la frecuencia cardíaca o tu edad.

¿Qué es el motor HUAWEI AR?

HUAWEI AR Engine es una plataforma para crear aplicaciones de realidad aumentada (AR) en teléfonos inteligentes Android. Se basa en el conjunto de chips HiSilicon e integra algoritmos centrales de AR para proporcionar capacidades AR básicas como seguimiento de movimiento, seguimiento del entorno, seguimiento del cuerpo y seguimiento de rostros, lo que permite que su aplicación conecte el mundo virtual con el mundo real, para una visión completamente nueva. experiencia de usuario interactiva.
Actualmente, HUAWEI AR Engine ofrece tres tipos de capacidades, que incluyen seguimiento de movimiento, seguimiento de entorno y seguimiento de rostro y cuerpo humano.

Ejemplo de aplicación de Android

Para este ejemplo, trabajaremos en el seguimiento del entorno para que podamos detectar una mano e interactuar con ella.

Proceso de desarrollo

Crear una aplicación
Cree una aplicación siguiendo las instrucciones de Creating an AppGallery Connect Project y Adding an App to the Project.
Platforma: Android
Dispositivo: Mobile phone
Categoria de la App: App or Game

Integración de HUAWEI AR Engine SDK
Antes del desarrollo, integre HUAWEI AR Engine SDK a través del repositorio de Maven en su entorno de desarrollo.
Abra el archivo build.gradle en el directorio raíz de su proyecto de Android Studio.

apply plugin: 'com.android.application'
android {
compileSdkVersion 30
buildToolsVersion "30.0.1"
defaultConfig {
applicationId "com.vsm.myarapplication"
minSdkVersion 27
targetSdkVersion 30
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
implementation 'androidx.appcompat:appcompat:1.2.0'
implementation 'androidx.constraintlayout:constraintlayout:2.0.1'
testImplementation 'junit:junit:4.12'
//
implementation 'com.huawei.agconnect:agconnect-core:1.4.1.300'
//
implementation 'com.huawei.hms:arenginesdk:2.15.0.1'
//
implementation 'de.javagl:obj:0.3.0'
androidTestImplementation 'androidx.test.ext:junit:1.1.2'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}
apply plugin: 'com.huawei.agconnect'

Creas tu actividad en la que trabajarás (activity_health.xml):

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".healt.HealtActivity">
<android.opengl.GLSurfaceView
        android:id="@+id/healthSurfaceView"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        tools:ignore="MissingConstraints" />
<LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal">
<ImageView
            android:layout_width="1dp"
            android:layout_height="match_parent"
            android:layout_gravity="start"
            android:layout_weight="1"
            android:scaleType="fitXY"
            android:src="@drawable/face_bg_fill" />
<ImageView
            android:id="@+id/health_fresh_face"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="center_horizontal"
            android:adjustViewBounds="true"
            android:scaleType="fitCenter"
            android:src="@drawable/face_img_mask" />
<ImageView
            android:layout_width="1dp"
            android:layout_height="match_parent"
            android:layout_gravity="end"
            android:layout_weight="1"
            android:scaleType="fitXY"
            android:src="@drawable/face_bg_fill" />
    </LinearLayout>
<TextView
        android:id="@+id/health_check_status"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text=""
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        tools:ignore="MissingConstraints" />
<ProgressBar
        android:id="@+id/health_progress_bar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="200dp"
        android:layout_height="20dp"
        android:layout_centerInParent="true"
        android:max="100"
        android:progress="0"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.6" />
<TextView
        android:id="@+id/process_tips"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text=""
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/health_progress_bar"
        tools:ignore="MissingConstraints" />
<TableLayout
        android:id="@+id/health_param_table"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="50dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"></TableLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

AR Engine no es para todos los dispositivos, por lo que primero debemos validar si el dispositivo es compatible con AR Engine y está disponible, aquí está la lista de dispositivos compatibles

Utilizará estos métodos para comprobar si un dispositivo es compatible:

private boolean arEngineAbilityCheck() {
boolean isInstallArEngineApk = AREnginesApk.isAREngineApkReady(this);
if (!isInstallArEngineApk && isRemindInstall) {
Toast.makeText(this, "Please agree to install.", Toast.LENGTH_LONG).show();
finish();
}
Log.d(TAG, "Is Install AR Engine Apk: " + isInstallArEngineApk);
if (!isInstallArEngineApk) {
startActivity(new Intent(this, ConnectAppMarketActivity.class));
isRemindInstall = true;
}
return AREnginesApk.isAREngineApkReady(this);
}

MessageWhenError

private void setMessageWhenError(Exception catchException) {
if (catchException instanceof ARUnavailableServiceNotInstalledException) {
startActivity(new Intent(getApplicationContext(), ConnectAppMarketActivity.class));
} else if (catchException instanceof ARUnavailableServiceApkTooOldException) {
message = "Please update HuaweiARService.apk";
} else if (catchException instanceof ARUnavailableClientSdkTooOldException) {
message = "Please update this app";
} else if (catchException instanceof ARUnSupportedConfigurationException) {
message = "The configuration is not supported by the device!";
} else {
message = "exception throw";
}
}

En nuestro HealthActivity.java llamará a la detección de superficie:

public class HealtActivity extends AppCompatActivity {
private static final String TAG = HealtActivity.class.getSimpleName();
private static final int MAX_PROGRESS = 100;
private GLSurfaceView mGlSurfaceView;
private ARSession mArSession;
private ARFaceTrackingConfig mArFaceTrackingConfig;
private String mMessage;
private boolean isRemindInstall = false;
private HealthRenderManager mHealthRenderManager;
private DisplayRotationManager mDisplayRotationManager;
private ProgressBar mHealthProgressBar;
private TextView mProgressTips;
private TextView mHealthCheckStatusTextView;
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_healt);
        AppCompatDelegate.setCompatVectorFromResourcesEnabled(true);
        mHealthProgressBar = findViewById(R.id.health_progress_bar);
        mGlSurfaceView = findViewById(R.id.healthSurfaceView);
        mProgressTips = findViewById(R.id.process_tips);
        mHealthCheckStatusTextView = findViewById(R.id.health_check_status);
        mDisplayRotationManager = new DisplayRotationManager(this);
mGlSurfaceView.setPreserveEGLContextOnPause(true);
// Set the OpenGLES version.
        mGlSurfaceView.setEGLContextClientVersion(2);
// Set the EGL configuration chooser, including for the
        // number of bits of the color buffer and the number of depth bits.
        mGlSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
        mHealthRenderManager = new HealthRenderManager(this, this);
        mHealthRenderManager.setDisplayRotationManage(mDisplayRotationManager);
        TableLayout mHealthParamTable = findViewById(R.id.health_param_table);
        mHealthRenderManager.setHealthParamTable(mHealthParamTable);
        mGlSurfaceView.setRenderer(mHealthRenderManager);
        mGlSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
    }
@Override
    protected void onResume() {
        super.onResume();
        mMessage = null;
        if (mArSession == null) {
            try {
                if (!arEngineAbilityCheck()) {
                    finish();
                    return;
                }
                mArSession = new ARSession(this);
                mArFaceTrackingConfig = new ARFaceTrackingConfig(mArSession);
                mArFaceTrackingConfig.setEnableItem(ARConfigBase.ENABLE_HEALTH_DEVICE);
                mArSession.configure(mArFaceTrackingConfig);
                setHealthServiceListener();
            } catch (ARUnavailableServiceNotInstalledException capturedException) {
                startActivity(new Intent(this, ConnectAppMarketActivity.class));
            } catch (ARUnavailableServiceApkTooOldException capturedException) {
                mMessage = "Please update HuaweiARService.apk";
            } catch (ARUnavailableClientSdkTooOldException capturedException) {
                mMessage = "Please update this app";
            } catch (ARUnSupportedConfigurationException capturedException) {
                mMessage = "The configuration is not supported by the device!";
            } catch (Exception capturedException) {
                mMessage = "unknown exception throws!";
            }
            if (mMessage != null) {
                stopArSession();
                return;
            }
        }
        try {
            mArSession.resume();
        } catch (ARCameraNotAvailableException e) {
            Toast.makeText(this, "Camera open failed, please restart the app", Toast.LENGTH_LONG).show();
            mArSession = null;
            return;
        }
        mDisplayRotationManager.registerDisplayListener();
        mHealthRenderManager.setArSession(mArSession);
        mGlSurfaceView.onResume();
    }
private void stopArSession() {
        Log.i(TAG, "Stop session start.");
        Toast.makeText(this, mMessage, Toast.LENGTH_LONG).show();
        if (mArSession != null) {
            mArSession.stop();
            mArSession = null;
        }
        Log.i(TAG, "Stop session end.");
    }
/**
     * Check whether HUAWEI AR Engine server (com.huawei.arengine.service) is installed on the current device.
     * If not, redirect the user to HUAWEI AppGallery for installation.
     *
     * @return true:AR Engine ready
     */
    private boolean arEngineAbilityCheck() {
        boolean isInstallArEngineApk = AREnginesApk.isAREngineApkReady(this);
        if (!isInstallArEngineApk && isRemindInstall) {
            Toast.makeText(this, "Please agree to install.", Toast.LENGTH_LONG).show();
            finish();
        }
        Log.d(TAG, "Is Install AR Engine Apk: " + isInstallArEngineApk);
        if (!isInstallArEngineApk) {
            startActivity(new Intent(this, ConnectAppMarketActivity.class));
            isRemindInstall = true;
        }
        return AREnginesApk.isAREngineApkReady(this);
    }
@Override
    protected void onPause() {
        Log.i(TAG, "onPause start.");
        super.onPause();
        if (mArSession != null) {
            mDisplayRotationManager.unregisterDisplayListener();
            mGlSurfaceView.onPause();
            mArSession.pause();
            Log.i(TAG, "Session paused!");
        }
        Log.i(TAG, "onPause end.");
    }
@Override
    protected void onDestroy() {
        Log.i(TAG, "onDestroy start.");
        super.onDestroy();
        if (mArSession != null) {
            mArSession.stop();
            mArSession = null;
        }
        Log.i(TAG, "onDestroy end.");
    }
@Override
    public void onWindowFocusChanged(boolean isHasFocus) {
        Log.d(TAG, "onWindowFocusChanged");
        super.onWindowFocusChanged(isHasFocus);
        if (isHasFocus) {
            getWindow().getDecorView()
                    .setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                            | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
        }
    }
private void setHealthServiceListener() {
        mArSession.addServiceListener(new FaceHealthServiceListener() {
            @Override
            public void handleEvent(EventObject eventObject) {
                if (!(eventObject instanceof FaceHealthCheckStateEvent)) {
                    return;
                }
                final FaceHealthCheckState faceHealthCheckState =
                        ((FaceHealthCheckStateEvent) eventObject).getFaceHealthCheckState();
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        mHealthCheckStatusTextView.setText(faceHealthCheckState.toString());
                    }
                });
            }
@Override
            public void handleProcessProgressEvent(final int progress) {
                mHealthRenderManager.setHealthCheckProgress(progress);
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        setProgressTips(progress);
                    }
                });
            }
        });
    }
private void setProgressTips(int progress) {
        String progressTips = "processing";
        if (progress >= MAX_PROGRESS) {
            progressTips = "finish";
        }
        mProgressTips.setText(progressTips);
        mHealthProgressBar.setProgress(progress);
    }
}

Conclusión

Puede detectar la frecuencia cardíaca, conocer la edad de su rostro y obtener más datos sobre la salud para múltiples propósitos de una manera sencilla.
Documentation
Codelab
Code Sample

Explora más artículos en el Huawei Developer Forum.
Conviértete en Huawei Developer, es gratis.
Conviértete en Huawei Developer, es gratis.

Seguimiento del cuerpo humano con AR Engine

HuaweiDevsLATAM — Fri, 07 May 2021 15:59:35 +0000

Introducción

HUAWEI AR Engine tiene soporte para detectar objetos en el mundo real que se llama “Seguimiento del entorno” y con él puede registrar iluminación, plano, imagen, objeto, superficie y otra información ambiental para ayudar a sus aplicaciones a fusionar objetos virtuales en escenarios físicos. mundo.

Body tracking

Esta función identifica y rastrea ubicaciones 2D para 23 puntos del esqueleto corporal (o ubicaciones 3D de 15 puntos del esqueleto corporal) y admite el seguimiento de una o dos personas a la vez.
AR Engine reconoce cuerpos humanos y genera coordenadas 2D y 3D (basadas en SLAM) de puntos del esqueleto, y es capaz de cambiar entre las cámaras delantera y trasera.
La capacidad de seguimiento del cuerpo le permite superponer objetos virtuales en el cuerpo con un alto grado de precisión, como en el hombro izquierdo o el tobillo derecho. También puede realizar una mayor cantidad de acciones precisas en el avatar, dotando a sus aplicaciones de AR con una funcionalidad divertida.

Ejemplo de aplicación de Android

Para este ejemplo, trabajaremos en el seguimiento del entorno para que podamos detectar una mano e interactuar con ella.

Proceso de desarrollo

Crear una aplicación

Cree una aplicación siguiendo las instrucciones de Creating an AppGallery Connect Project y Adding an App to the Project.
Platforma: Android
Dispositivo: Mobile phone
App category: App or Game

Integración de HUAWEI AR Engine SDK

Antes del desarrollo, integre HUAWEI AR Engine SDK a través del repositorio de Maven en su entorno de desarrollo.
Abra el archivo build.gradle en el directorio raíz de su proyecto de Android Studio.

// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
    repositories {
        google()
        jcenter()
        maven {url 'https://developer.huawei.com/repo/'}
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.0.1"
        classpath 'com.huawei.agconnect:agcp:1.3.2.301'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        maven {url 'https://developer.huawei.com/repo/'}
        google()
        jcenter()
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

Abra el archivo build.gradle en el directorio de la aplicación de su proyecto

apply plugin: 'com.android.application'
android {
    compileSdkVersion 30
    buildToolsVersion "30.0.1"
defaultConfig {
        applicationId "com.vsm.myarapplication"
        minSdkVersion 27
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar"])
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    testImplementation 'junit:junit:4.12'
    //
    implementation 'com.huawei.agconnect:agconnect-core:1.4.2.301'
    //
    implementation 'com.huawei.hms:arenginesdk:2.15.0.1'
    //
    implementation 'de.javagl:obj:0.3.0'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}
apply plugin: 'com.huawei.agconnect'

Creas tu actividad en la que trabajarás (activity_body.xml):

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".body.BodyActivity">
<android.opengl.GLSurfaceView
        android:id="@+id/bodySurfaceview"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_gravity="top"
        tools:ignore="MissingConstraints" />
<TextView
        android:id="@+id/bodyTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="TextView"
        android:textColor="@color/red"
        tools:layout_editor_absoluteX="315dp"
        tools:layout_editor_absoluteY="4dp"
        tools:ignore="MissingConstraints" />
</androidx.constraintlayout.widget.ConstraintLayout>

AR Engine no es para todos los dispositivos, por lo que primero debemos validar si el dispositivo es compatible con AR Engine y está disponible, aquí está la lista de dispositivos compatibles

Utilizará estos métodos para comprobar si un dispositivo es compatible:

Métodos

private void setMessageWhenError(Exception catchException) {
    if (catchException instanceof ARUnavailableServiceNotInstalledException) {
        startActivity(new Intent(getApplicationContext(), ConnectAppMarketActivity.class));
    } else if (catchException instanceof ARUnavailableServiceApkTooOldException) {
        message = "Please update HuaweiARService.apk";
    } else if (catchException instanceof ARUnavailableClientSdkTooOldException) {
        message = "Please update this app";
    } else if (catchException instanceof ARUnSupportedConfigurationException) {
        message = "The configuration is not supported by the device!";
    } else {
        message = "exception throw";
    }
}

En nuestro BodyActivity.java llamarás a la detección de superficie:

package com.vsm.myarapplication.body;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.opengl.GLSurfaceView;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
import com.huawei.hiar.ARBodyTrackingConfig;
import com.huawei.hiar.ARConfigBase;
import com.huawei.hiar.AREnginesApk;
import com.huawei.hiar.ARSession;
import com.huawei.hiar.exceptions.ARCameraNotAvailableException;
import com.huawei.hiar.exceptions.ARUnSupportedConfigurationException;
import com.huawei.hiar.exceptions.ARUnavailableClientSdkTooOldException;
import com.huawei.hiar.exceptions.ARUnavailableServiceApkTooOldException;
import com.huawei.hiar.exceptions.ARUnavailableServiceNotInstalledException;
import com.vsm.myarapplication.R;
import com.vsm.myarapplication.body.rendering.BodyRenderManager;
import com.vsm.myarapplication.common.ConnectAppMarketActivity;
import com.vsm.myarapplication.common.DisplayRotationManager;
public class BodyActivity extends AppCompatActivity {
    private static final String TAG = BodyActivity.class.getSimpleName();
private ARSession mArSession;
private GLSurfaceView mSurfaceView;
private BodyRenderManager mBodyRenderManager;
private DisplayRotationManager mDisplayRotationManager;
// Used for the display of recognition data.
    private TextView mTextView;
private String message = null;
private boolean isRemindInstall = false;
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_body);
        mTextView = findViewById(R.id.bodyTextView);
        mSurfaceView = findViewById(R.id.bodySurfaceview);
        mDisplayRotationManager = new DisplayRotationManager(this);
// Keep the OpenGL ES running context.
        mSurfaceView.setPreserveEGLContextOnPause(true);
// Set the OpenGLES version.
        mSurfaceView.setEGLContextClientVersion(2);
// Set the EGL configuration chooser, including for the
        // number of bits of the color buffer and the number of depth bits.
        mSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
mBodyRenderManager = new BodyRenderManager(this);
        mBodyRenderManager.setDisplayRotationManage(mDisplayRotationManager);
        mBodyRenderManager.setTextView(mTextView);
mSurfaceView.setRenderer(mBodyRenderManager);
        mSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
    }
@Override
    protected void onResume() {
        Log.d(TAG, "onResume");
        super.onResume();
        Exception exception = null;
        message = null;
        if (mArSession == null) {
            try {
                if (!arEngineAbilityCheck()) {
                    finish();
                    return;
                }
                mArSession = new ARSession(this);
                ARBodyTrackingConfig config = new ARBodyTrackingConfig(mArSession);
                config.setEnableItem(ARConfigBase.ENABLE_DEPTH | ARConfigBase.ENABLE_MASK);
                mArSession.configure(config);
                mBodyRenderManager.setArSession(mArSession);
            } catch (Exception capturedException) {
                exception = capturedException;
                setMessageWhenError(capturedException);
            }
            if (message != null) {
                Toast.makeText(this, message, Toast.LENGTH_LONG).show();
                Log.e(TAG, "Creating session", exception);
                if (mArSession != null) {
                    mArSession.stop();
                    mArSession = null;
                }
                return;
            }
        }
        try {
            mArSession.resume();
        } catch (ARCameraNotAvailableException e) {
            Toast.makeText(this, "Camera open failed, please restart the app", Toast.LENGTH_LONG).show();
            mArSession = null;
            return;
        }
        mSurfaceView.onResume();
        mDisplayRotationManager.registerDisplayListener();
    }
/**
     * Check whether HUAWEI AR Engine server (com.huawei.arengine.service) is installed on the current device.
     * If not, redirect the user to HUAWEI AppGallery for installation.
     */
    private boolean arEngineAbilityCheck() {
        boolean isInstallArEngineApk = AREnginesApk.isAREngineApkReady(this);
        if (!isInstallArEngineApk && isRemindInstall) {
            Toast.makeText(this, "Please agree to install.", Toast.LENGTH_LONG).show();
            finish();
        }
        Log.d(TAG, "Is Install AR Engine Apk: " + isInstallArEngineApk);
        if (!isInstallArEngineApk) {
            startActivity(new Intent(this, ConnectAppMarketActivity.class));
            isRemindInstall = true;
        }
        return AREnginesApk.isAREngineApkReady(this);
    }
private void setMessageWhenError(Exception catchException) {
        if (catchException instanceof ARUnavailableServiceNotInstalledException) {
            startActivity(new Intent(this, ConnectAppMarketActivity.class));
        } else if (catchException instanceof ARUnavailableServiceApkTooOldException) {
            message = "Please update HuaweiARService.apk";
        } else if (catchException instanceof ARUnavailableClientSdkTooOldException) {
            message = "Please update this app";
        } else if (catchException instanceof ARUnSupportedConfigurationException) {
            message = "The configuration is not supported by the device!";
        } else {
            message = "exception throw";
        }
    }
@Override
    protected void onPause() {
        Log.i(TAG, "onPause start.");
        super.onPause();
        if (mArSession != null) {
            mDisplayRotationManager.unregisterDisplayListener();
            mSurfaceView.onPause();
            mArSession.pause();
        }
        Log.i(TAG, "onPause end.");
    }
@Override
    protected void onDestroy() {
        Log.i(TAG, "onDestroy start.");
        super.onDestroy();
        if (mArSession != null) {
            mArSession.stop();
            mArSession = null;
        }
        Log.i(TAG, "onDestroy end.");
    }
@Override
    public void onWindowFocusChanged(boolean isHasFocus) {
        Log.d(TAG, "onWindowFocusChanged");
        super.onWindowFocusChanged(isHasFocus);
        if (isHasFocus) {
            getWindow().getDecorView()
                    .setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                            | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
        }
    }
}

Conclusión

Con HUAWEI AR Engine puedes identificar puntos del esqueleto del cuerpo y características del cuerpo humano de salida, como puntos finales de las extremidades, postura corporal y esqueleto.
Documentación
Codelab
Code Sample
Explora más artículos
Conviértete en Huawei Developer es gratis.

Como realizar una validación HMS

HuaweiDevsLATAM — Tue, 04 May 2021 14:38:57 +0000

Introducción
Los teléfonos Huawei no tienen servicios GMS, por lo que en la mayoría de los casos necesitamos usar flavors para mantener un proyecto para GMS y HMS, por lo que hay una manera fácil de validar el HMS disponible que explicaré a continuación:
Necesitamos integrar HMS como otro proyecto para que pueda crear un nuevo proyecto:
Crear una aplicación Cree una aplicación siguiendo las instrucciones de Creación de un proyecto de AppGallery Connect y Adición de una aplicación al proyecto.
Plataforma: Android
Dispositivo: teléfono móvil
Categoría de la App: aplicación o juego
Integración de HUAWEI AR Engine SDK
Antes del desarrollo, integre HUAWEI AR Engine SDK a través del repositorio de Maven en su entorno de desarrollo. Abra el archivo build.gradle en el directorio raíz de su proyecto de Android Studio.

buildscript {
    repositories {
        google()
        jcenter()
        // Configure the Maven repository address for the HMS Core SDK.
        maven {url 'https://developer.huawei.com/repo/'}
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.1.2"
// Add AppGallery Connect plug-in configurations.
        classpath 'com.huawei.agconnect:agcp:1.4.2.300'
        classpath 'com.google.gms:google-services:4.3.4'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}
allprojects {
    repositories {
        google()
        jcenter()
        maven {url 'https://developer.huawei.com/repo/'}
    }
}
task clean(type: Delete) {
    delete rootProject.buildDir
}

Abra el archivo build.gradle en el directorio de la aplicación de su proyecto

plugins {
    id 'com.android.application'
}
android {
    compileSdkVersion 30
    buildToolsVersion "30.0.2"
defaultConfig {
        applicationId "com.spartdark.validatehmsservices"
        minSdkVersion 29
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
dependencies {
implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'com.google.android.material:material:1.3.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    testImplementation 'junit:junit:4.+'
    //hms
    implementation 'com.huawei.hms:hwid:5.1.0.301'
    //gms
    implementation platform('com.google.firebase:firebase-bom:26.3.0')
    implementation 'com.google.firebase:firebase-analytics'
    implementation 'com.google.firebase:firebase-auth'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}
apply plugin: 'com.huawei.agconnect'
apply plugin: 'com.google.gms.google-services'

Los métodos que utilizará para validar sus servicios son

public static boolean isHmsAvailable(Context context) {
    boolean isAvailable = false;
    if (null != context) {
        int result = HuaweiApiAvailability.getInstance().isHuaweiMobileServicesAvailable(context);
        isAvailable = (com.huawei.hms.api.ConnectionResult.SUCCESS == result);
    }
    Log.i(TAG, "isHmsAvailable: " + isAvailable);
    return isAvailable;
}
public static boolean isGmsAvailable(Context context) {
    boolean isAvailable = false;
    if (null != context) {
        int result = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context);
        isAvailable = (com.google.android.gms.common.ConnectionResult.SUCCESS == result);
    }
    Log.i(TAG, "isGmsAvailable: " + isAvailable);
    return isAvailable;
}

Conclusión
Es muy sencillo validar si un servicio está disponible en un teléfono.
Github Repo

Explora más artículos en el Huawei Developer Forum.
Conviértete en Huawei Developer, es gratis.

Checklist para migrar una app de GMS a HMS

HuaweiDevsLATAM — Thu, 22 Apr 2021 01:50:37 +0000

¡Por fin! Tomó mucho tiempo, horas sin dormir, muchas tazas de café y más tiempo de depuración del que quieres admitir pero finalmente, tu app ya es completamente funcional. De pronto, de la nada aparece una nueva tienda de aplicaciones, conserva la calma, adaptar una app para AppGallery es más fácil de lo que crees. A continuación te cuento qué es lo que debes hacer y tener en cuenta para migrar y publicar tu aplicación.

Nota: Este artículo es una traducción del artículo Checklist to migrate your app from GMS to HMS publicado originalmente en el Huawei Developer Forum por el usuario k4t*@il.com

Objetivo

En este artículo conocerás la lista de verificación y algunos trucos útiles para usar en el momento en que desees publicar tu aplicación en la Huawei AppGallery.

Revisión de dependencias de Google

A no ser que vivas bajo una roca, seguramente sabes que los servicios móviles de Google y los servicios de Google Play ya no están disponibles en los nuevos dispositivos Huawei, por lo que si tu aplicación usa alguno de estos, debes encargarte de eso.

La cuestión es ¿no puedo usar ningún servicio de Google? y esa es una pregunta válida, la respuesta rápida es: Sí, aún puedes usar algunos de los servicios de Google en tu aplicación. Como la mayoría de los servicios de Google están relacionados con Firebase, al menos aquellos con los que nosotros como desarrolladores estamos más familiarizados, puedes verificar rápidamente en la lista de dependencias de Firebase si el servicio que estás utilizando requiere Google Play Services para seguir funcionando. Si no es así, ¡enhorabuena! No hay nada más que hacer para que funcione en dispositivos Huawei, sólo asegurarse de usar la última versión del servicio. Si es así, sigamos adelante.

Hay una alerta molesta que aparece cada vez que se ejecuta una aplicación con Google Play Services, en un dispositivo Huawei sin Google Play Services. Se parece a esto:

Si en algún momento tu aplicación está llamando a uno de estos métodos isGooglePlayServicesAvailable () o showErrorDialogFragment () de la clase GoogleApiAvailability, desde aquí puedes optar por eliminarlos o filtrarlos para que no se muestren en dispositivos Huawei, pero hay una forma inteligente de hacerlo y es usando flavors.

Creando un Flavor para tu app

Una poderosa característica en Android Studio son los flavors (sabores), en caso de que no los estuvieras usando, estoy a punto de sorprenderte con esta nueva información.

En pocas palabras, los flavors permiten crear diferentes versiones de tu aplicación utilizando la misma base de código, pero al cambiar algunos archivos puedes crear diferentes compilaciones (apks) de tu aplicación, el ejemplo común es tener una versión gratuita y otra de pago. En este caso, crearás una versión HMS (Huawei Mobile Services) de tu aplicación y una versión GMS(Google Mobile Services), por lo que puede cambiar las partes donde se invocan los servicios de Google.

Puedes averiguar cómo hacerlo en la guía de Android para configurar variantes de compilación, pero un pequeño aviso, deberás modularizar totalmente tu código para esto, en caso de que aún no lo estuviera.

Entonces, ya estás a medio camino, el siguiente paso es hacer gala de tus habilidades de programación.

Determinando el equivalente de HMS

En este punto, te has dado cuenta de que hay algunos servicios que debes reemplazar por sus contrapartes de Huawei, afortunadamente, hay mucha información que puedes usar en el sitio de Huawei Developers, aquí puedes elegir el kit adecuado para reemplazar tu servicio de Google.

La mayoría de los nombres de los kits se explican por sí mismos, pero puedes utilizar el Huawei Developer Forum para pedir ayuda en caso de que no puedas encontrar el kit adecuado. No te preocupes, porque cada kit tiene una guía precisa sobre cómo implementarlo, codelabs y códigos de ejemplo para poner tu aplicación en funcionamiento lo antes posible.

Ahora, tienes una versión de tu aplicación para Google Play, con Google Play Services, y otra versión para AppGallery, con Huawei Mobile Services, es hora de probarla.

Probando tu app

hay tres maneras de hacer esto. A continuación te las describo:

Dispositivo Huawei real

Esta primera forma requiere un dispositivo móvil real para probar tu aplicación, puedes ejecutar y depurar tu aplicación en tu dispositivo Huawei. Puedes verificar el logcat, usar el depurador y aprovechar cualquier otra característica que ya conozcas como desarrollador de aplicaciones móviles.
Fácil, ¿verdad?, pero ¿Y si no tienes un dispositivo Huawei?

Cualquier dispositivo Android con HMS

Los servicios móviles de Huawei se pueden instalar en cualquier dispositivo Android, puedes instalar HMS Core desde AppGallery (el sitio web te indicará que primero instales AppGallery) y luego probar tu aplicación llamando a las clases y métodos de los paquetes de Huawei. Es así de fácil y funciona en la mayoría de los escenarios (Aunque este método es muy confiable, ha mostrado algunos problemas en ciertos dispositivos).
¿Eso significa que no puedes probar tu aplicación completamente sin un dispositivo Huawei?, respuesta rápida, sí, hay una manera tan confiable como tener un dispositivo real.

Cloud Debugging

Huawei tiene un servicio gratuito que puedes usar con solo iniciar sesión en AppGallery Connect, debes crear una cuenta de desarrollador para esto. Con Cloud Debugging puedes usar un dispositivo Huawei remoto, cargar tu apk, verificar el logcat y depurar tu aplicación como si lo estuvieras haciendo bien en tu dispositivo.

Consejo rápido, puedes hacerlo desde Android Studio si instalas el plugin HMS Toolkit. Vale la pena intentarlo.

Conclusión

Esta guía se elaboró para ayudarte a crear una versión HMS de tu aplicación, a partir de esta pequeña guía puedes ver que aún puedes usar muchos servicios de Google en tu aplicación y usar el mismo apk, que creaste para Google Play, en AppGallery, en ciertos casos ‘Sólo tendremos que reemplazar los servicios que requieran los Servicios de Google Play. Espero que te sea útil.
¡Happy Codding!.

Switch de características con AGC Remote Configuration

HuaweiDevsLATAM — Tue, 20 Apr 2021 23:22:39 +0000

El lanzamiento de nuevas características dentro de una aplicación es siempre un proceso desafiante en la vida de un desarrollador. Aunque nos gustaría que la app con sus nuevas características funcione a la perfeción, sabemos que no siempre es así. Aquí es dónde el Switch de características entra en acción, usando esta técnica, usando esta técnica, serás capaz de mostrar u ocultar una característica de tu app, sin necesidad de publicar una actualización.

Nota: Este artículo es una traducción del artículo Feature Toggling with Remote Config publicado originalmente en el Huawei Developer Forum por el usuario k4t*@il.com

El objetivo

En este artículo vamos a lanzar una nueva característica en una app que podrá ser habilitada o deshabilitada al cambiar un valor remotamente.

Pasos

Configurar un proyecto para funcionar con las APIs de Huawei
Habilitar el servicio de Remote Configuration
Agregar el SDK al proyecto Android
Usar los valores remotos para cambiar la disponibilidad de la nueva característica

Configurando el proyecto para funcionar con las APIs de Huawei

Este paso es obligatorio para usar la mayoría de los SDKs de Huawei, en caso de que nunca hayas realizado esta configuración, puedes seguir esta guía que te ayudará a configurar tu proyecto paso a paso.

Habilitando el servicio de Remote Configuration

Antes de usar Remote Config, es necesario que habilites el servicio en AppGallery Connect. Para hacerlo, ve a la pestaña “Manage APIs” y activa el switch de Remote Configuration.

Ahora usa el panel izquierdo para navegar hacia la consola de Remote Configuration (Growing>Remote Configuration) está ubicada un par de opciones debajo de “Project Settings”. La consola estará deshabilitada por defecta ya que recién habilitamos el servicio. Para habilitarla, solo haz clic en “Enable now”.

Agregando las dependencias

Agrega el SDK de Remote Config al archivo build.gradle de tu proyecto.

dependencies {
// Configure the following address.
implementation 'com.huawei.agconnect:agconnect-remoteconfig:1.5.1.300'
}

Ahora sincroniza el proyecto con gradle para descargar el SDK. Puedes hacerlo presionando el botón “Sync project with gradle files”

Cambiando la funcionalidad de la app basado en el valor remoto

Fundamentos

En el fondo, el switch de características es una simple condición if/else que determinará si el disparador de una acción (como un botón, una imagen, un diálogo, etc) debe ser desplegado o no. Algo similar a esto:

if( veryCoolFeatureIsEnabled ){
showFeature()
}
else{
hideFeature()
}

Parece simple ¿no? Realmente lo es. Puedes implementar esta técnica de múltiples formas, almacenando el valor de esta bandera en una base de datos, programar la aparición de esa característica (si eres un temerario) o en este caso, usar una herramienta que permita administrar esta condición a distancia.

Configurando parámetros remotos

El primer paso es crear los parámetros remotos en la consola de Remote configuration. Para hacerlo, presiona el botón “Add parameter”.

Una vez ahí, crea un parámetro para administrar la disponibilidad de nuestra nueva característica. En este caso, crearemos el parámetro ENABLE_COOL_FEATURE y ajustaremos su valor en true.

Una vez configurados todos los parámetros necesarios, debemos presionar el botón “Release” para aplicar la configuración.

so es todo lo que necesitamos hacer en la consola de Remote Configuration. Es momento de pasar al código.

Estableciendo valores por defecto para los parámetros remotos

Antes de cargar los parámetros configurados en la consola, la aplicación debe cargar sus valores por defecto para garantizar una ejecición correcta. Para esto, crearemos un archivo llamado remote_config.xml dentro del directorio de recursos res/xml/. Si este directorio no existe en tu proyecto, deberás crearlo.

<?xml version="1.0" encoding="utf-8"?>
<remoteconfig>
<value key="ENABLE_COOL_FEATURE">false</value>
</remoteconfig>

Leyendo los parámetros remotos en la app

Primero, debemos crear una constante que contenga exáctamene el mismo nombre que le asignamos a nuestro parámetro remoto en la consola.

const val ENABLE_COOL_FEATURE = "ENABLE_COOL_FEATURE";

Luego, debemos obtener una instancia de AGConnectConfig.

val config= AGConnectConfig.getInstance()

Carga los valores por defecto.

config.applyDefault(R.xml.remote_config);

Ahora sólo debemos actualizar los valores leyendo los parámetros remotos.

config.fetch(0)
    .addOnSuccessListener { configValues -> 
        config.apply(configValues)
    }.addOnFailureListener { e -> 
        Log.e("REMOTE CONFIGURATION", "fetch setting failed: " + e.message) 
    }

Y eso es todo, una vez que se dispara el onSuccessListener tendrás el valor más reciente de los parámetros remotos. Ahora podrás acceder a ellos de la siguiente forma.

config.getValueAsBoolean(ENABLE_COOL_FEATURE);

Ahora puedes usar estos valores para habilitar o deshabilitar características de forma remota sin necesidad de actualizar la app.

Conclusión

¿Por qué esta simple característica es tan poderosa? Es porque te permite experimentar, ahora puedes liberar una nueva característica en tu aplicación a un porcentaje de sus usuarios, analizar lo que salió bien y lo que salió mal, arreglarla, intentarlo de nuevo y liberarla con una menor probabilidad de fallar y una mayor estabilidad a toda la base de usuarios. Permite gestionar su crecimiento y conocer el impacto de la característica gradualmente, si tu nueva característica permite al usuario subir fotos, será más fácil manejar los datos almacenados por 100 usuarios que por 100000. Puedes comprobar cosas como el tráfico de datos o el tiempo de servidor usado y adaptar todo para manejar el nuevo grupo de usuarios que viene. También aumenta la productividad y la seguridad, ya que muchos desarrolladores pueden trabajar en diferentes características y todavía mantienen la aplicación estable porque el código detrás de la función no se ejecutará hasta que se habilite.

[Guía de Integración] Un vistazo a Huawei Account Kit

HuaweiDevsLATAM — Fri, 16 Apr 2021 18:02:40 +0000

Acerca de Huawei Account Kit

HUAWEI ID es la credencial que proporciona a los usuarios el acceso a la gama de servicios de Huawei. Como servicio de desarrollo fundamental ofrecido por HMS Core, Account Kit provee funciones de autenticación y autorización simples, seguras y rápidas. En lugar de ingresar el nombre de usuario y password en cada intento de autenticación, los usuarios pueden simplemente tocar el botón de Inicio de Sesión con HUAWEI ID, para acceder directamente a tu app mediante sus HUAWEI ID.

Ventajas

Inicio de sesión autorizado para todos los escenarios

Account Kit le permite al usuario autorizar el inicio de sesión en tu app mediante su HUAWEI ID, evitandole la necesidad de ingresar sus datos personales, configurar contraseñas y esperar códigos de verificación por SMS o correo electrónico. Una vez que la autorización se completa, la página de autorización no volverá a mostrarse en tu app, reduciendo así la tasa de abandono durante el proceso de registro e inicio de sesión.

Adicionalmente, Account Kit permite al usuario iniciar sesión simultáneamente desde diferentes dispositivos, incluyendo teléfonos móviles, tabletas, Huawei Vision y relojes. Esto te ayudará a presentar mejor tu producto y servicios en los dispositivos de Huawei en todos los escenarios.

Base de usuarios global de Huawei

Account Kit disfruta de un alcance verdaderamente global, prestando servicios en más de 190 países y regiones, y está disponible en más de 70 idiomas. Al integrar el servicio en tu aplicación, contarás con el acceso a una gran cantidad de nuevos usuarios potenciales y estarás equipado para expandir tu presencia en nuevos mercados.

Servicios seguros y confiables

Account Kit cumple con prestigiosos protocolos internacionales, incluidos OAuth 2.0 y OpenID Connect, y permite a los usuarios completar el inicio de sesión a través de una contraseña y un código de verificación, con cifrado de datos, además de ofrecer una función de protección de cuentas cruzadas basada en RISC. Este marco riguroso ayuda a garantizar que el kit de cuentas cumpla con las regulaciones de privacidad del usuario aplicables en todo el mundo, y cuando se combina con el inicio de sesión con HUAWEI ID, te libera de la carga de administrar los datos de las cuenta de usuario.

Una solución conveniente y coherente

La guía de desarrollo, códigos de ejemplo y la herramienta de integración de Account Kit son optimizados continuamente para reducir los costos de integración.
Integración rápida en el cliente: Puedes usar el HMS Tool Kit para descargar el Demo, revisar la configuración del entorno de desarrollo, así como arrastrar y soltar los bloques de código necesarios para realizar la integración de Account Kit en menos de medio día.
Integración rápida en el servidor: Puedes apoyarte en el código de ejemplo de Java y PHP.
Account kit te permite conectarte al ecosistema Huawei usando HUAWEI ID desde una gran variedad de dispositivos, incluyendo smatphones, tabletas y pantallas Vision.
Continuaremos optimizando Account Kit para ayudarte a alcanzar tus objetivos de negocio y esperamos que disfrutes del acceso a toda la gama de servicios Huawei.

Escanea este QR para descargar el Demo

Nota: La app puede recolectar datos de los usuarios con fines estadísticos.

Para obtener más información acerca de Huawei Account Kit, puedes visitar los siguientes sitios:

¿Ya has usado Account Kit? Compártenos tu experiencia u opinión en los comentarios.

Cómo un programador desarrolló una útil aplicación de viajes para su novia

HuaweiDevsLATAM — Fri, 16 Apr 2021 17:53:14 +0000

“Se dice que son cinco centímetros por segundo. La velocidad con la que caen los pétalos de la flor del cerezo, son cinco centímetros por segundo”

Al escuchar estas líneas de diálogo de un bien conocido anime japonés, John, un desarrollador de Huawei, se dio cuenta de que los cerezos estaban floreciendo en ese momento.
La novia de John, Jenny adora las flores de cerezo, y planeaba visitar el parque de cerezos más famoso de París el fin de semana, el Parc de Sceaux. Desafortunadamente, John se encontraba en un viaje de trabajo ese fin de semana y no le fue posible acompañar a Jenny.

Así que John se dijo a sí mismo, “¿Qué tal si desarrollo una aplicación de viajes inteligente para Jenny? Después de todo, soy desarrollador. Así ella podría disfrutar de las flores de cerezos de la mejor forma posible”. Entonces John se puso manos a la obra y enlistó los siguientes requerimientos para la app que estaba a punto de desarrollar.

Recordatorios del viaje: Recordarle los eventos importantes con anticipación en su horario, como cuándo partir.
Pronóstico del tiempo: Proporcionar sugerencias sobre qué traer y vestir en función de las condiciones meteorológicas en su destino.
Envío de notificaciones: Enviar consejos útiles e información de descuentos a ella una vez que llegue al destino.

Afortunadamente para John, las capacidades previamente enlistadas podían ser fácilmente implementadas utilizando las funcionalidades de consulta del Tiempo y Clima de HUAWEI Awareness Kit, las geo-cercas de Location Kit y la capacidad de envío de notificaciones de Push Kit.

Descripción general

Awareness Kit proporciona a tu aplicación la capacidad de obtener información contextual incluyendo hora actual, ubicación, comportamiento, conexión de los audífonos, clima, luz ambiental, estado de conexión del auto estéreo y estado de conexión de balizas, que pueden combinarse para crear varias barreras que corren en segundo plano y se activan una vez que se detecta un cambio en las condiciones.

Location Kit combina capacidades de geolocalización de GNSS, Wi-Fi y estación base en tu aplicación, lo que permite proporcionar servicios flexibles basados en la ubicación para usuarios de todo el mundo.

Push Kit es un servicio de mensajería diseñado para desarrolladores, que ayuda a crear un canal de mensajería de nube a dispositivo. Con Push Kit integrado, tu aplicación puede enviar mensajes a los dispositivos de los usuarios en tiempo real.

Desarrollo

Integración de Awareness Kit

Los siguientes tres pasos clave son necesarios para integrar Awareness kit. Para obtener más detalles, consulta la guía de desarrollo en el sitio web de HUAWEI Developers.

Configurar la información de la aplicación en AppGallery Connect.
Integrar el SDK de Awareness de HMS Core.
Configurar los scripts de ofuscación.

Proceso de desarrollo

Declara los permisos necesarios en el archivo AndroidManifest.xml

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
 <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

Obtén información del clima basado en el nombre de la ciudad.

String city = edCity.getText().toString();

if (city != null && !city.equals("")) {

    WeatherPosition weatherPosition = new WeatherPosition();

    weatherPosition.setCity(city);

    // Pass the language type of the passed address. The value format is "Language_country", such as "zh_CN", "en_US".

    weatherPosition.setLocale("en_US");
// Obtain the Capture Client of Awareness Kit, and call the weather query capability.

    Awareness.getCaptureClient(getApplicationContext()).getWeatherByPosition(weatherPosition)

            .addOnSuccessListener(new OnSuccessListener<WeatherStatusResponse>() {

                @Override

                public void onSuccess(WeatherStatusResponse weatherStatusResponse) {

                    // Process the returned weather data.

                    WeatherStatus weatherStatus = weatherStatusResponse.getWeatherStatus();

                    WeatherSituation weatherSituation = weatherStatus.getWeatherSituation();

                    Situation situation = weatherSituation.getSituation();

                    String weather;

                    // Match the weather ID with the weather.

                    weather = getApplicationContext().getResources().getStringArray(R.array.cnWeather)[situation.getCnWeatherId()];

                    // Update UI.

                    ((TextView) findViewById(R.id.tv_weather)).setText(weather);

                    ((TextView) findViewById(R.id.tv_windDir)).setText(situation.getWindDir());

                    ((TextView) findViewById(R.id.tv_windSpeed)).setText(situation.getWindSpeed() + " km/h");

                    ((TextView) findViewById(R.id.tv_temperature)).setText(situation.getTemperatureC() + "℃");

                }

            }).addOnFailureListener(new OnFailureListener() {

        @Override

        public void onFailure(Exception e) {

        }

    });

}

Implementa recordatorios programados y envío de notificaciones una vez que el usuario llegue a su destino.

Registra un Broadcast Receiver para saber cuando la app se cierre.

Código en el AndroidManifest.xml

<receiver android:name=".BarrierReceiver">

<intent-filter>

    <action android:name="com.test.awarenessdemo.TimeBarrierReceiver.BARRIER_RECEIVER_ACTION"/>

</intent-filter>

</receiver>

Código Java

Intent intent = new Intent();

intent.setComponent(new ComponentName(MainActivity.this, BarrierReceiver.class));

mPendingIntent = PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);

Define la barrera del tiempo y su Tag correspondiente, luego agrega la barrera.

// Obtain the entered time.

String timeHour = edTimeHour.getText().toString();

String timeMinute = edTimeMinute.getText().toString();

int hour = 0;

int minute = 0;

if (!timeHour.equals("")) {

    hour = Integer.parseInt(timeHour);

    if (!timeMinute.equals("")) {

        minute = Integer.parseInt(timeMinute);

    }

}

long oneHourMilliSecond = 60 * 60 * 1000L;

long oneMinuteMilliSecond = 60 * 1000L;

// Define the duringPeriodOfDay barrier to send notifications within a specified time period in a specified time zone.

AwarenessBarrier periodOfDayBarrier = TimeBarrier.duringPeriodOfDay(TimeZone.getDefault(),

        // Set the notification time to two hours in advance.

        (hour - 2) * oneHourMilliSecond + minute * oneMinuteMilliSecond,

        hour * oneHourMilliSecond + minute * oneMinuteMilliSecond);

String timeBarrierLabel = "period of day barrier label";

// Define a request for updating a barrier.

BarrierUpdateRequest.Builder builder = new BarrierUpdateRequest.Builder();

BarrierUpdateRequest request = builder.addBarrier(timeBarrierLabel, periodOfDayBarrier, mPendingIntent).build();

Awareness.getBarrierClient(getApplicationContext()).updateBarriers(request)

        .addOnSuccessListener(new OnSuccessListener<Void>() {

            @Override

            public void onSuccess(Void aVoid) {

            }

        })

        .addOnFailureListener(new OnFailureListener() {

            @Override

            public void onFailure(Exception e) {

            }

        });

Define la barrera de ubicación

if (city != null && !city.equals("")) {

    // Obtain the longitude and latitude of the city based on the city name from the assets folder.

    String data = cityMap.get(city);

    if (data != null){

        int flag = data.indexOf(",");

        double latitude = Double.parseDouble(data.substring(flag+1));

        double longitude = Double.parseDouble(data.substring(0,flag));

        double radius = 50;

        long timeOfDuration = 5000;

        // Define the stay barrier. If a user enters a specified area and stays for a specified time period, a barrier event is triggered and reported.

        AwarenessBarrier stayBarrier = LocationBarrier.stay(latitude, longitude, radius, timeOfDuration);

        String stayBarrierLabel = "stay barrier label";

        // Define a request for updating a barrier.

        BarrierUpdateRequest.Builder builder = new BarrierUpdateRequest.Builder();

        BarrierUpdateRequest request = builder.addBarrier(stayBarrierLabel, stayBarrier, mPendingIntent).build();

        Awareness.getBarrierClient(getApplicationContext()).updateBarriers(request)

                .addOnSuccessListener(new OnSuccessListener<Void>() {

                    @Override

                    public void onSuccess(Void aVoid) {

                    }

                })

                .addOnFailureListener(new OnFailureListener() {

                    @Override

                    public void onFailure(Exception e) {

                    }

                });

    }

}

Define un BroadcastReceiver para escuchar cuando se disparen las barreras y realizar las operaciones correspondientes.

class BarrierReceiver extends BroadcastReceiver {

    @Override

    public void onReceive(Context context, Intent intent) {

        BarrierStatus barrierStatus = BarrierStatus.extract(intent);

        String label = barrierStatus.getBarrierLabel();

        int barrierPresentStatus = barrierStatus.getPresentStatus();

        String city = intent.getStringExtra("city");

        switch (label) {

            case DURING_PERIOD_OF_DAT_BARRIER_LABEL:

                if (barrierPresentStatus == BarrierStatus.TRUE) {



                    initNotification(context,"1","time_channel","Travel reminder","Two hours before departure");

                } else if (barrierPresentStatus == BarrierStatus.FALSE) {

                    showToast(context, "It's not between ");

                } else {

                    showToast(context, "The time status is unknown.");

                }

                break;



            case STAY_BARRIER_LABEL:

                if (barrierPresentStatus == BarrierStatus.TRUE) {



                    initNotification(context,"2","area_channel","Welcome to"+city,"View travel plans");

                } else if (barrierPresentStatus == BarrierStatus.FALSE) {

                    showToast(context,"You are not staying in the area set by locationBarrier" +

                            " or the time of duration is not enough.");

                } else {

                    showToast(context, "The location status is unknown.");

                }

                break;

        }

    }
}

Envío de notificaciones basado en la ubicación

Agrega la dirección del repositorio Maven al archivo build.gradle a nivel de proyecto.

buildscript {
repositories {
maven { url 'http://developer.huawei.com/repo/'}
}
dependencies {
...
// Add AppGallery Connect plugin configuration.
classpath 'com.huawei.agconnect:agcp:1.4.2.300'
}
}allprojects {
repositories {
maven { url 'http://developer.huawei.com/repo/'}
}
}

Agrega las dependencias de Location y Push al archivo build.gradle a nivel de app.

dependencies {
implementation 'com.huawei.hms:location:5.0.2.300'
implementation 'com.huawei.hms:push: 5.0.2.301'
}

Pasos Clave

Declara los permisos necesarios en el archivo AndroidManifest.xml

Location Kit incorpora capacidades de posicionamiento GNSS, Wi-Fi y estación base en tu aplicación. Para ello, requiere acceso a la red, y permisos de ubicación. Si deseas que la aplicación obtenga continuamente ubicaciones de usuario cuando se ejecuta en segundo plano, también es necesario declarar el permiso ACCESS_BACKGROUND_LOCATION en el AndroidManifest.

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />

<uses-permission android:name="android.permission.WAKE_LOCK" />

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

<uses-permission android:name="com.huawei.hms.permission.ACTIVITY_RECOGNITION" />

<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />

Nota: los permisos ACCESS_FINE_LOCATION, WRITE_EXTERNAL_STORAGE, y READ_EXTERNAL_STORAGE están catalogados como permisos riesgozos, de modo que tendrás que solicitar estos permisos en tiempo de ejecución. Si tu app no obtiene la autorización de estos permisos, Location Kit no podrá funcionar.

Crea una Geocerca y activala

LocationSettingsRequest.Builder builders = new LocationSettingsRequest.Builder();
 builders.addLocationRequest(mLocationRequest);
 LocationSettingsRequest locationSettingsRequest = builders.build();
 // Before requesting location update, call checkLocationSettings to check device settings.
 Task<LocationSettingsResponse> locationSettingsResponseTasks = mSettingsClient.checkLocationSettings(locationSettingsRequest);
 locationSettingsResponseTasks.addOnSuccessListener(new OnSuccessListener<LocationSettingsResponse>() {
     @Override
     public void onSuccess(LocationSettingsResponse locationSettingsResponse) {
         Log.i(TAG, "check location settings success");
  mFusedLocationProviderClient
                 .requestLocationUpdates(mLocationRequest, mLocationCallbacks, Looper.getMainLooper())
                 .addOnSuccessListener(new OnSuccessListener<Void>() {
                     @Override
                     public void onSuccess(Void aVoid) {
                         LocationLog.i(TAG, "geoFence onSuccess");
                     }
                 })
                 .addOnFailureListener(new OnFailureListener() {
                     @Override
                     public void onFailure(Exception e) {
                         LocationLog.e(TAG,
                                 "geoFence onFailure:" + e.getMessage());
                     }
                 });
     }
 })

Dispara el envío de la notificación

Envía una notificación cuando el callback onReceive del GeoFenceBroadcastReceiver detecte que la geocerca se ha disparado. El mensaje será desplegado en el panel de notificaciones del dispositivo.

if (geofenceData != null) {
     int errorCode = geofenceData.getErrorCode();
     int conversion = geofenceData.getConversion();
     ArrayList<Geofence> list = (ArrayList<Geofence>) geofenceData.getConvertingGeofenceList();
     Location myLocation = geofenceData.getConvertingLocation();
     boolean status = geofenceData.isSuccess();
     sb.append("errorcode: " + errorCode + next);
     sb.append("conversion: " + conversion + next);
     if (list != null) {
         for (int i = 0; i < list.size(); i++) {
             sb.append("geoFence id :" + list.get(i).getUniqueId() + next);
         }
     }
     if (myLocation != null) {
         sb.append("location is :" + myLocation.getLongitude() + " " + myLocation.getLatitude() + next);
     }
     sb.append("is successful :" + status);
     LocationLog.i(TAG, sb.toString());
     Toast.makeText(context, "" + sb.toString(), Toast.LENGTH_LONG).show();

     new PushSendUtils().netSendMsg(sb.toString());
 }

Nota: La geocerca creada usando el código de ejemplo activará dos callbacks para los tipos de conversión 1 y 4. Una se activa cuando un usuario ingresa a la geocerca y la otra se activa cuando el usuario permanece en ella. Si Trigger está configurado en 7 en el código, se configuran los callbacks para todos los escenarios, incluyendo entrar, permanecer y salir de la geocerca.

ATRESplayer PREMIUM obtiene una audiencia sin precedentes al mejorar la experiencia de usuario

HuaweiDevsLATAM — Fri, 09 Apr 2021 23:28:51 +0000

El año pasado se registró un aumento considerable en la demanda de entretenimiento en línea de los consumidores, una tendencia que continúa aumentando en los primeros meses de 2021. Alineada con este desarrollo del mercado, está la creciente popularidad de las descargas de aplicaciones de entretenimiento, siendo la aplicación de medios española ATRESplayer PREMIUM una de las más populares, que experimentó un crecimiento récord gracias a ello. Sin embargo, junto a su creciente popularidad, el gigante de los medios de comunicación líder en España y la única empresa audiovisual con posiciones clave en todos los sectores en los que opera (televisión, radio, internet, cine, producción para terceros y formación), enfrentó desafíos igual de grandes, debido a la repentina afluencia de opiniones y miembros diarios.

ATRESplayer PREMIUM registró un incremento tanto en número de nuevos usuarion mensuales como en número de usuarios activos desde septiembre de 2020. Los problemas comenzaron cuando los usuarios de Huawei Mobile Services notaron que sólo podían acceder a las funciones básicas del reproductor multimedia Español. Además, dado que el número de usuarios en línea de ATRESplayer PREMIUM continuaba creciendo abruptamente, la capacidad online del sitio comenzó a disminuir, dejando a los espectadores con pantallas congeladas y conexiones colpsadas.

Para mantener su reputación y compromiso con sus nuevos usuarios, ATRESplayer PREMIUM necesitaba una solución para mejorar su experiencia de usuario. Hacerlo seguramente aumentaría la tasa de retención de usuarios de la plataforma y las tasas de conversión generales.

Al identificar estos problemas, ATRESplayer PREMIUM se ha comprometió a brindar la mejor experiencia de usuario con noticias y contenido diversificado de calidad premium para sus usuarios. ¿Cómo? La plataforma eligió colaborar con Huawei. Al integrarse con las capacidades abiertas proporcionadas por HMS Core, ATRESplayer PREMIUM pudo mejorar y suavizar con éxito la experiencia de visualización basada en tecnologías innovadoras, aumentando su tasa de retención de usuarios.

Inicio de sesión seguro y eficiente con un toque

Antes de la asociación, los usuarios debían proporcionar una dirección de correo electrónico, número de teléfono, nickname y más para registrarse en ATRESplayer PREMIUM. Además de pasar por un engorroso proceso de registro, a los usuarios les preocupaba la posibilidad de una fuga de información. ATRESplayer PREMIUM eligió priorizar la experiencia del usuario al agregar HUAWEI Account Kit, que permite registrarse e iniciar sesión con un solo toque.

Esta función también admite la sinergia de varios dispositivos, lo que significa que los usuarios pueden iniciar sesión en varios dispositivos al mismo tiempo. No solo ha mejorado toda la experiencia de inicio de sesión, lo que ha aumentado la tasa de conversión de ATRESplayer PREMIUM, sino que los desarrolladores de la aplicaciones también han ahorrado dinero en SMS, ya que los códigos de verificación ya no son necesarios. La asociación también integró ATRESplayer PREMIUM con HUAWEI ID, que fue galardonado con la certificación European Privacy Seal (EuroPriSe). Esta certificación garantiza que HUAWEI ID protege la privacidad y los datos de los usuarios con avanzadas tecnologías y medidas de protección estándar de la industria, lo que brinda a los usuarios tranquilidad al usar ATRESplayer PREMIUM con AppGallery.

Notificaciones al momento, para más usuarios activos

A medida que más usuarios recurren a ATRESplayer PREMIUM para disfrutar de películas, programas de televisión y transmisiones en vivo, han exigido más acerca de actualizaciones de series, alertas de transmisión en vivo, transmisión de noticias y titulares de actualidad. Teniendo esto en cuenta, ATRESplayer PREMIUM decidió integrarse con el HUAWEI Push Kit para ofrecer actualizaciones y alertas relevantes que se mostrarán en los dispositivos de los usuarios sin que la aplicación se ejecute en segundo plano. El desarrollador puede enviar las últimas actualizaciones de contenido y los mensajes relevantes con prontitud, entregándolos al 99% de los usuarios en diez minutos. Esto ha ayudado efectivamente a ATRESplayer PREMIUM a establecer una buena conexión con los usuarios, así como a mejorar la percepción y la actividad de los usuarios.

Análisis completo para una optimización oportuna

Es inevitable un aumento de nuevos usuarios y la afluencia llevó a algunos usuarios a experimentar problemas de crasheo y congelamiento en la reproducción de videos al usar la plataforma ATRESplayer PREMIUM. Para comprender las causas y resolver rápidamente los problemas, ATRESplayer PREMIUM ha integrado el kit de HUAWEI Analytics para recopilar eventos de fallas, analizarlos e identificar los problemas en diferentes escenarios para abordarlos de forma pertinente.

Generando éxito a través de una colaboración íntima

La colaboración entre ATRESplayer PREMIUM y Huawei se extiende más allá de una asociación técnica, habiendo unido fuerzas para dos importantes campañas de marketing conjuntas desde el año pasado. La primera colaboración fue una campaña de Navidad entre el 18 y el 31 de diciembre que resultó un éxito rotundo para el desarrollador, y las dos empresas están trabajando juntas en una campaña del Día Internacional del Gato que se extiende hasta el 5 de marzo.

AppGallery - Una de las 3 tiendas de aplicaciones más grandes del mundo

AppGallery es un ecosistema inteligente e innovador que permite a los desarrolladores crear experiencias únicas para los consumidores. La tecnología de HMS Core permite que las aplicaciones se integren en diferentes dispositivos, brindando una experiencia más fluida y agradable. - Esto es parte de nuestra estrategia "1+8+N" en Huawei.

Nuestra visión es convertir a AppGallery en una plataforma de distribución abierta e innovadora accesible para los consumidores, que proteja la privacidad y seguridad de los usuarios a la par que les ofrece una experiencia única e inteligente. Siendo una de las 3 tiendas de aplicaciones más grandes del mundo, AppGallery ofrece una amplia variedad de apps globales y locales a través de 18 categorías que incluyen navegación y transporte, noticias y redes sociales entre otras. AppGallery es accesible en más de 170 países y regiones con una cuota de 530 millones de usuarios activos mensualmente. Huawei se ha aliado con más de 230 millones de desarrolladores alrededor del mundo mientras que se alcanzaron 384.4 mil millones de descargas desde AppGallery durante 2020.

HMS Core - Bloques de construcción de ecosistemas integrales que potencian el desarrollo de aplicaciones

HMS Core ofrece una amplia variedad de capacidades en el dispositivo y en la nube que facilitan el desarrollo eficiente, crecimiento rápido y monetización flexible. Permite a los desarrolladores de todo el mundo desarrollar innovaciones revolucionarias, ofrecer una experiencia de usuario de nivel superior y hacer que el contenido y los servicios premium sean ampliamente accesibles.

Cuéntanos ¿Tus apps ya usan HMS Core? y si es así, ¿Cómo te han ayudado a mejorar la experiencia de tus usuarios?