Android Geofencing con Google Play Services 6.5.87

No tengo ningún problema con Google Play Services 6.1.71 (porque todo funciona bien) pero no es lo mismo con la versión más nueva (6.5.87).

Ya sé que la clase LocationClient está obsoleta en la clase de Servicios de Google Play de 6.5.87 y tengo poco problema con la conversión de la antigua muestra de GeofenceDetection ( http://developer.android.com/shareables/training/GeofenceDetection.zip ).

Primer problema que tengo, con los nuevos servicios de juego no he encontrado OnAddGeofencesResultListener y OnRemoveGeofencesResultListener que he utilizado para manejar los errores en la consola;
La segunda edición (problema principal) está agregando el punto del geofence. Cuando intento agregar uno para solicitarlo recibo una pendiente indefinida …

El código que he modificado es:

ReceiveTransitionsIntentService.java

  Public class ReceiveTransitionsIntentService extends IntentService {

     Todos los derechos reservados
      * Establece un identificador para esta clase 'subproceso de fondo
      * /
     Public ReceiveTransitionsIntentService () {
         Super ("ReceiveTransitionsIntentService");
     }

     Todos los derechos reservados
      * Maneja las intenciones entrantes
      * @param intención La intención enviada por Servicios de ubicación.  Esta Propuesta es proporcionada
      * A Servicios de ubicación (dentro de un PendingIntent) cuando llama a addGeofences ()
      * /
     @Anular
     Protected void onHandleIntent (intención de intención) {

         // Crear una Intención de difusión local
         Propósito broadcastIntent = new Intent ();

         // Darle la categoría para todas las intenciones enviadas por el servicio de intención
         BroadcastIntent.addCategory (GeofenceUtils.CATEGORY_LOCATION_SERVICES);

         GeofencingEvent geoFenceEvent = GeofencingEvent.fromIntent (intención);

         // Primero comprueba si hay errores
         If (geoFenceEvent.hasError ()) {

             // Obtener el código de error
             Int errorCode = geoFenceEvent.getErrorCode ();

             // Obtener el mensaje de error
             String errorMessage = LocationServiceErrorMessages.getErrorString (esto, errorCode);

             // Registrar el error
             Log.e (GeofenceUtils.APPTAG,
                     GetString (R.string.geofence_transition_error_detail, errorMessage)
             );

             // Establece la acción y el mensaje de error para la intención de difusión
             BroadcastIntent.setAction (GeofenceUtils.ACTION_GEOFENCE_ERROR)
                            .putExtra (GeofenceUtils.EXTRA_GEOFENCE_STATUS, errorMessage);

             // Difunde el error * localmente * a otros componentes de esta aplicación
             LocalBroadcastManager.getInstance (this) .sendBroadcast (broadcastIntent);

         // Si no hay error, obtenga el tipo de transición y cree una notificación
         } Else {

             // Obtener el tipo de transición (entrada o salida)
             Int transition = geoFenceEvent.getGeofenceTransition ();

             // Prueba de que se informó de una transición válida
             Si (
                     (Transición == Geofence.GEOFENCE_TRANSITION_ENTER)
                     ||
                     (Transición == Geofence.GEOFENCE_TRANSITION_EXIT)
                ) {

                 // Publicar una notificación
                 Lista geofences = geoFenceEvent.getTriggeringGeofences ();
                 Cadena [] geofenceIds = nueva Cadena [geofences.size ()];
                 Para (int index = 0; index = 4
         NotificationCompat.Builder builder = new NotificationCompat.Builder (this);

         // Establecer el contenido de la notificación
         Builder.setSmallIcon (R.drawable.ic_notification)
                .setContentTitle (
                        GetString (R.string.geofence_transition_notification_title,
                                TransitionType, ids))
                .setContentText (getString (R.string.geofence_transition_notification_text))
                .setContentIntent (notificationPendingIntent);

         // Obtener una instancia del gestor de notificaciones
         NotificationManager mNotificationManager =
             (NotificationManager) getSystemService (Context.NOTIFICATION_SERVICE);

         // Emitir la notificación
         MNotificationManager.notify (0, builder.build ());
     }

     Todos los derechos reservados
      * Muestra los tipos de transición de geofence a sus equivalentes legibles por humanos.
      * @param transitionType Una constante de tipo de transición definida en Geofence
      * @return Una cadena que indica el tipo de transición
      * /
     Private String getTransitionString (int transitionType) {
         Switch (transitionType) {

             Caso Geofence.GEOFENCE_TRANSITION_ENTER:
                 Return getString (R.string.geofence_transition_entered);

             Caso Geofence.GEOFENCE_TRANSITION_EXIT:
                 Return getString (R.string.geofence_transition_exited);

             defecto:
                 Return getString (R.string.geofence_transition_unknown);
         }
     }
 }

GeofenceRequester.java

  Public class GeofenceRequester
                 implementos
                     ConnectionCallbacks,
                     OnConnectionFailedListener,
                     GoogleApiClient.ConnectionCallbacks,
                     GoogleApiClient.OnConnectionFailedListener {

     // Almacenamiento para una referencia al cliente llamante
     Actividad actividad privada final;

     // Almacena la PendingIntent utilizada para enviar las transiciones de geofence a la aplicación
     Privado PendingIntent mGeofencePendingIntent;

     // Almacena la lista actual de geofences
     Private ArrayList mCurrentGeofences;

     // Almacena la instancia actual del cliente de ubicación
     Privado GoogleApiClient mGoogleApiClient;

     Todos los derechos reservados
      * Indicador que indica si se está realizando una solicitud de adición o eliminación.  Mira esto
      * Flag antes de intentar iniciar una nueva solicitud.
      * /
     MInProgress booleano privado;

     Public GeofenceRequester (Actividad activityContext) {
         // Guardar el contexto
         MActivity = activityContext;

         // Inicializar globales a null
         MGeofencePendingIntent = nulo;
         MGoogleApiClient = null;
         MInProgress = false;
     }

     Todos los derechos reservados
      * Establezca el indicador "en curso" de una persona que llama.  Esto permite a los llamantes
      * Solicitud que falló, pero se fijó más tarde.
      *
      * @param flag Activar o desactivar el indicador de progreso.
      * /
     Public void setInProgressFlag (bandera booleana) {
         // Establece el indicador "En progreso".
         MInProgress = indicador;
     }

     Todos los derechos reservados
      * Obtener el estado actual en curso.
      *
      * @return El valor actual del indicador en progreso.
      * /
     Public boolean getInProgressFlag () {
         Return mInProgress;
     }

     Todos los derechos reservados
      * Devuelve el PendingIntent actual al llamador.
      *
      * @return El PendingIntent utilizado para crear el conjunto actual de geofences
      * /
     Public PendingIntent getRequestPendingIntent () {
         Return createRequestPendingIntent ();
     }

     Todos los derechos reservados
      * Comience a agregar geofences.  Guarda las geofencias y comienza a agregarlas solicitando una
      Conexión
      *
      * @param geofences Una lista de una o más geofences que se agregarán
      * /
     Public void addGeofences (Geofences de lista) throws UnsupportedOperationException {

         Todos los derechos reservados
          * Guardar las geofencias para que puedan ser enviadas a Servicios de Ubicación una vez
          * La conexión está disponible.
          * /
         MCurrentGeofences = (ArrayList) geofences;

         // Si una solicitud ya no está en curso
         If (! MInProgress) {

             // Alternar el indicador y continuar
             MInProgress = true;

             // Solicitar una conexión a Servicios de ubicación
             RequestConnection ();

         // Si una solicitud está en curso
         } Else {

             // Lanzar una excepción y detener la solicitud
             Throw nuevo UnsupportedOperationException ();
         }
     }

     Todos los derechos reservados
      * Solicite una conexión a Servicios de ubicación.  Esta llamada vuelve inmediatamente,
      * Pero la solicitud no está completa hasta que onConnected () o onConnectionFailure () se llame.
      * /
     Private void requestConnection () {
         GetLocationClient (). Connect ();
     }

     Todos los derechos reservados
      * Obtener el cliente de ubicación actual, o crear uno nuevo si es necesario.
      *
      * @return Un objeto LocationClient
      * /
     Privado GoogleApiClient getLocationClient () {
         If (mGoogleApiClient == null) {

             MGoogleApiClient = nuevo GoogleApiClient.Builder (mActivity)
                     .addApi (LocationServices.API)
                     .addConnectionCallbacks (este)
                     .addOnConnectionFailedListener (este)
                     .construir();
         }
         Return mGoogleApiClient;

     }

     Todos los derechos reservados
      * Una vez que la conexión esté disponible, envíe una solicitud para agregar las Geofences
      * /
     Private void continueAddGeofences () {

         // Obtenga un PendingIntent que los servicios de ubicación emiten cuando se produce una transición de geocoins
         MGeofencePendingIntent = createRequestPendingIntent ();

         // Enviar una solicitud para agregar las geofencias actuales
         LocationServices.GeofencingApi.addGeofences (mGoogleApiClient, mCurrentGeofences, mGeofencePendingIntent);
     }

     Todos los derechos reservados
      * Obtener un cliente de ubicación y desconectarse de Servicios de ubicación
      * /
     Private void requestDisconnection () {

         // Una solicitud ya no está en curso
         MInProgress = false;

         GetLocationClient (). Disconnect ();
     }

     Todos los derechos reservados
      * Llamado por Servicios de ubicación una vez que el cliente de ubicación está conectado.
      *
      * Continúe agregando las geofencias solicitadas.
      * /
     @Anular
     Public void onConnected (Paquete arg0) {
         // Si está depurando, registre la conexión

         Log.d (GeofenceUtils.APPTAG, mActivity.getString (R.string.connected));

         // Continuar añadiendo las geofencias
         ContinueAddGeofences ();
     }

     @Anular
     Public void onConnectionSuspended (int i) {

     }

     Todos los derechos reservados
      * Llamado por Servicios de ubicación una vez que el cliente de ubicación está desconectado.
      * /
     @Anular
     Public void onDisconnected () {
         // Desactivar el indicador de solicitud
         MInProgress = false;

         // En modo de depuración, registre la desconexión
         Log.d (GeofenceUtils.APPTAG, mActivity.getString (R.string.disconnected));

         // Destruye el cliente de ubicación actual
         MGoogleApiClient = null;
     }

     Todos los derechos reservados
      * Obtenga un PendingIntent para enviar con la solicitud para agregar Geofences.  Problemas con los servicios de ubicación
      * El intento dentro de este PendingIntent siempre que se produzca una transición de geofence para el actual
      * Lista de geofences.
      *
      * @return A PendingIntent para el IntentService que maneja las transiciones de geofence.
      * /
     Private PendingIntent createRequestPendingIntent () {

         // Si el PendingIntent ya existe
         If (null! = MGeofencePendingIntent) {

             // Devolver la intención existente
             Return mGeofencePendingIntent;

         // Si no existe PendingIntent
         } Else {

             // Crear un intento apuntando a IntentService
             Intención intention = new Intent (mActivity, ReceiveTransitionsIntentService.class);
             Todos los derechos reservados
              * Devuelve un PendingIntent para iniciar IntentService.
              * Siempre crear un PendingIntent enviado a Servicios de ubicación
              * Con FLAG_UPDATE_CURRENT, para que el envío de PendingIntent
              * Actualiza de nuevo el original.  De lo contrario, Servicios de ubicación
              * No puede igualar el PendingIntent a las solicitudes hechas con él.
              * /
             Return PendingIntent.getService (
                     MActivity,
                     0,
                     intención,
                     PendingIntent.FLAG_UPDATE_CURRENT);
         }
     }

     Todos los derechos reservados
      * Implementación de OnConnectionFailedListener.onConnectionFailed
      * Si falla una solicitud de conexión o desconexión, informe el error
      * ConnectionResult se transmite desde Servicios de ubicación
      * /
     @Anular
     Public void onConnectionFailed (ConnectionResult connectionResult) {

         // Desactivar el indicador de solicitud
         MInProgress = false;

         Todos los derechos reservados
          * Los servicios de Google Play pueden resolver algunos errores que detecta.
          * Si el error tiene una resolución, intente enviar un intento de
          * Iniciar una actividad de servicios de Google Play que pueda resolver
          * Error.
          * /
         If (connectionResult.hasResolution ()) {

             tratar {
                 // Iniciar una actividad que intenta resolver el error
                 ConnectionResult.startResolutionForResult (mActivity,
                     GeofenceUtils.CONNECTION_FAILURE_RESOLUTION_REQUEST);

             Todos los derechos reservados
              * Lanzado si los servicios de Google Play cancelaron el original.
              * PendingIntent
              * /
             } Catch (SendIntentException e) {
                 // Registrar el error
                 E.printStackTrace ();
             }

         Todos los derechos reservados
          * Si no hay resolución disponible, ponga el código de error en
          * Una intención de error y la retransmitida a la actividad principal.
          * La actividad entonces muestra un cuadro de diálogo de error.
          * esta fuera de fecha.
          * /
         } Else {

             Intención errorBroadcastIntent = new Intent (GeofenceUtils.ACTION_CONNECTION_ERROR);
             ErrorBroadcastIntent.addCategory (GeofenceUtils.CATEGORY_LOCATION_SERVICES)
                                 .putExtra (GeofenceUtils.EXTRA_CONNECTION_ERROR_CODE,
                                         ConnectionResult.getErrorCode ());
             LocalBroadcastManager.getInstance (mActivity) .sendBroadcast (errorBroadcastIntent);
         }
     }
 }

Consulta las muestras de los nuevos servicios de Google Play sdk en https://github.com/googlesamples/android-play-location

Para reemplazar OnAddGeofencesResultListener use ResultCallback

 LocationServices.GeofencingApi .addGeofences(mGoogleApiClient, mCurrentGeofences, mGeofencePendingIntent) .setResultCallback(new ResultCallback<Status>() { @Override public void onResult(Status status) { if (status.isSuccess()) { // Success } } });