Ubicaciones y sensores

Puedes acceder a los datos de ubicación y de sensores con la versión estándar de Android. APIs de plataforma.

Ubicación

La ubicación en Glass implica el uso de la versión estándar de Android de la plataforma para obtener datos de ubicación proveedores de ubicación.

Usarás las siguientes clases del SDK de Android para obtener datos de ubicación:

• LocationManager: Proporciona acceso al servicio del sistema de ubicación de Android que maneja la comunicación con un LocationProvider

• LocationProvider: Proporciona datos de ubicación según algunos criterios. Glass ofrece un control remoto especial proveedores que te permiten obtener datos de ubicación de un dispositivo sincronizado que tiene el micrófono MyGlass app complementaria instalada.

• Criteria: Te permite crear un conjunto de criterios que selecciona el mejor LocationProvider según los criterios que establezcas.

Descripción general

Para obtener datos de ubicación, deberás usar el LocationManager para obtener datos de uno o más proveedores de ubicación.

Las aplicaciones de un teléfono o una tablet Android recuperan datos de ubicación de la ubicación Proveedores de ubicación de red y GPS en el dispositivo Sin embargo, en Glass, de proveedores de ubicación disponibles es dinámico y puede incluir datos remotos. proveedores de ubicación que suministran datos de ubicación desde otra fuente, como un Dispositivo sincronizado con Bluetooth con la aplicación complementaria MyGlass instalada Para gestionar estos proveedores adicionales, detectará las actualizaciones de ubicación de varios proveedores en lugar de un solo proveedor.

Advertencia: No uses el LocationManager.getBestProvider() o las constantes GPS_PROVIDER o NETWORK_PROVIDER para detectar actualizaciones de ubicación. Glass usa un conjunto dinámico de proveedores y escuchar a un solo proveedor puede hacer que tu aplicación pase por alto las actualizaciones de ubicación.

Para solicitar datos de todos los proveedores de ubicación disponibles, sigue estos pasos:

1. Crea un Criteria. con tus requisitos de ubicación.
2. Llama a getProviders() para recuperar la lista de proveedores habilitados que cumplan con tus criterios.
3. Itera la lista de proveedores y solicita actualizaciones a todos ellos. Esto garantiza que recibas actualizaciones de los proveedores remotos si se pero también de los proveedores locales en Glass (como un servicio proveedor de red).

4. Usa la información de exactitud y tiempo proporcionada con cada para determinar si es lo suficientemente buena o si deberías y esperar otro.

   LocationManager locationManager; // initialized elsewhere
   
   // This example requests fine accuracy and requires altitude, but
   // these criteria could be whatever you want.
   Criteria criteria = new Criteria();
   criteria.setAccuracy(Criteria.ACCURACY_FINE);
   criteria.setAltitudeRequired(true);
   
   List<String> providers = locationManager.getProviders(
           criteria, true /* enabledOnly */);
   
   for (String provider : providers) {
       locationManager.requestLocationUpdates(provider, minTime,
               minDistance, listener);
   }
   

Sensores

Vidrio

Glass tiene un sensor especializado para detectar si el dispositivo se encuentra en la de los usuarios cabeza. Si se habilita, este parámetro de configuración ayuda a ahorrar batería cuando el dispositivo no está en uso. Puedes utilizar esta función en tu Glassware para inhabilitar o y limitar los servicios en segundo plano. Comienza por implementar un BroadcastReceiver para detectar ACTION_ON_HEAD_STATE_CHANGE eventos.

Nota: Tu app no puede detectar eventos de detección en la cabeza si el usuario inhabilita la en la configuración.

En el siguiente ejemplo, se retrasan e inhabilitan las actualizaciones de la puntuación del juego en función de si el usuario quitó Glass de su cabeza:

1. Implementa un BroadcastReceiver para manejar el cambio de estado.
2. En tu servicio, implementa el onCreate() y registra un receptor que escuche ACTION_ON_HEAD_STATE_CHANGE.

3. En la onDestroy() método, cancela el registro del receptor.

   import com.google.android.glass.content.Intents;
   ...
   
   public class LiveCardService extends Service {
   
       ...
       private boolean mIsStopped = false;
   
       private final BroadcastReceiver broadCastReceiver = new BroadcastReceiver() {
           @Override
           public void onReceive(Context context, Intent intent) {
   
               if (Intents.ACTION_ON_HEAD_STATE_CHANGED.equals(intent.getAction())) {
                   boolean onHead = intent.getBooleanExtra(Intents.EXTRA_IS_ON_HEAD,
                           false);
                   if (onHead) {
                       mDelay = LiveCardService.DELAY_MILLIS;
                       if (isStopped()) {
                           // Resume updating scores
                           setStop(false);
   
                           // Restart immediately to get a refreshed score
                           mHandler.postDelayed(mUpdateLiveCardRunnable, 0);
                       }
                   } else {
                       // Increase the delay when the device is off head
                       mDelay = LiveCardService.DELAY_MILLIS_EXT;
                   }
               }
           }
       };
   
       private final Runnable mUpdateLiveCardRunnable = new Runnable() {
   
           @Override
           public void run() {
   
               if (mDelay == DELAY_MILLIS_EXT) {
                   // Count the increased delay as a retry attempt
                   mRetryCount++;
               } else if (mDelay == DELAY_MILLIS) {
                   mRetryCount = 0;
               }
   
               if (mRetryCount > MAX_RETRIES) {
                   // Stop updating scores
                   mIsStopped = true;
               }
   
               if (!isStopped()) {
                   // Generate fake points.
                   homeScore += mPointsGenerator.nextInt(3);
                   awayScore += mPointsGenerator.nextInt(3);
   
                   // Update the remote view with the new scores.
                   mLiveCardView = getRemoteViews(homeScore, awayScore);
   
                   // Always call setViews() to update the live card's RemoteViews.
                   mLiveCard.setViews(mLiveCardView);
   
                   // Queue another score update in 30 seconds.
                   mHandler.postDelayed(mUpdateLiveCardRunnable, mDelay);
               }
           }
       };
   
       @Override
       public void onCreate() {
           super.onCreate();
           mPointsGenerator = new Random();
           mDelay = DELAY_MILLIS;
   
           registerReceiver(broadCastReceiver, new IntentFilter(
                   Intents.ACTION_ON_HEAD_STATE_CHANGED));
       }
   
       @Override
       public int onStartCommand(Intent intent, int flags, int startId) {
           if (mLiveCard == null) {
   
               // Get an instance of a live card
               mLiveCard = new LiveCard(this, LIVE_CARD_TAG);
   
               // Inflate a layout into a remote view
               mLiveCardView = new RemoteViews(getPackageName(),
                       R.layout.live_card);
   
               // Set up initial RemoteViews values
               homeScore = 0;
               awayScore = 0;
               mLiveCardView = getRemoteViews(homeScore, awayScore);
   
               // Set up the live card's action with a pending intent
               // to show a menu when tapped
               Intent menuIntent = new Intent(this, LiveCardMenuActivity.class);
               menuIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                       Intent.FLAG_ACTIVITY_CLEAR_TASK);
               mLiveCard.setAction(PendingIntent.getActivity(
                       this, 0, menuIntent, 0));
   
               // Publish the live card
               mLiveCard.publish(PublishMode.REVEAL);
   
               // Queue the update text runnable
               mHandler.post(mUpdateLiveCardRunnable);
           }
   
           return START_STICKY;
       }
   
       @Override
       public void onDestroy() {
           if (mLiveCard != null && mLiveCard.isPublished()) {
               //Stop the handler from queuing more Runnable jobs
               setStop(true);
   
               mLiveCard.unpublish();
               mLiveCard = null;
           }
   
           unregisterReceiver(broadCastReceiver);
   
           super.onDestroy();
       }
   
       @Override
       public IBinder onBind(Intent intent) {
           return null;
       }
   
       private RemoteViews getRemoteViews(int homeScore, int awayScore) {
           RemoteViews remoteViews = new RemoteViews(getPackageName(),
                   R.layout.live_card);
   
           remoteViews.setTextViewText(R.id.home_team_name_text_view,
                   getString(R.string.home_team));
           remoteViews.setTextViewText(R.id.away_team_name_text_view,
                   getString(R.string.away_team));
           remoteViews.setTextViewText(R.id.footer_text,
                   getString(R.string.game_quarter));
   
           remoteViews.setTextViewText(R.id.home_score_text_view,
                   String.valueOf(homeScore));
           remoteViews.setTextViewText(R.id.away_score_text_view,
                   String.valueOf(awayScore));
           return remoteViews;
       }
   
       public boolean isStopped() {
           return mIsStopped;
       }
   
       public void setStop(boolean isStopped) {
           mIsStopped = isStopped;
       }
   }
   

Android

Los siguientes sensores de Android son compatibles con Glass:

• TYPE_ACCELEROMETER
• TYPE_GRAVITY
• TYPE_GYROSCOPE
• TYPE_LIGHT
• TYPE_LINEAR_ACCELERATION
• TYPE_MAGNETIC_FIELD
• TYPE_ORIENTATION (obsoleto)
• TYPE_ROTATION_VECTOR

Los siguientes sensores de Android no son compatibles:

• TYPE_AMBIENT_TEMPERATURE
• TYPE_PRESSURE
• TYPE_PROXIMITY
• TYPE_RELATIVE_HUMIDITY
• TYPE_TEMPERATURE

Nota: La plataforma de Glass se basa en Android 4.4 (nivel de API 19), pero no es compatible con el sensor. o Android 4.3 (nivel de API 18). Las funciones de API para sensores están bloqueadas en Android 4.2 (nivel de API 17) para los sensores mencionados anteriormente. compatibles.

A continuación, se ofrecen algunas sugerencias para usar sensores en Glass:

• El sistema de coordenadas del sensor Glass se muestra a continuación en relación con la pantalla Glass. Para obtener más información, consulta sistema de coordenadas del sensor.

• El acelerómetro, el giroscopio y el magnetómetro se encuentran en la cápsula de óptica del dispositivo Glass. que los usuarios roten para alinear el dispositivo con su vista. No se puede medir de la cápsula óptica directamente, así que ten esto en cuenta cuando usando los ángulos de estos sensores para aplicaciones como la orientación de la brújula.

• Para preservar la duración de batería, solo escucha los sensores cuando los necesites. Por ejemplo, si tu dispositivo Glassware usa un Service para renderizar un LiveCard y solo necesitas los sensores cuando la tarjeta activa esté visible, usa el LiveCard muestra métodos de devolución de llamada para comenzar a escuchar los sensores y dejar de hacerlo.

• Las devoluciones de llamada de eventos de sensor se ejecutan en el subproceso de IU, por lo que debes procesar los eventos y devolver como lo más rápido posible. Enviar los eventos del sensor a una cola y usar un subproceso en segundo plano para manejarlos si el procesamiento demora demasiado.

• A menudo, 50 Hz es suficiente tasa de muestreo para monitorear el movimiento de la cabeza.

Para obtener más información sobre cómo usar los sensores, consulta la Guía para desarrolladores de Android