title: google play geofence onHandleIntent
body: <p>I am developing android app with geofence which released in this year.</p>
  
  <p>My understanding is when the users get into (or out of) the fence it should trigger onHandleIntent method However, I have difficulty to trigger to onHandleIntent method </p>
  
  <p>I have checked for 3 days to figure it out  but I evetually could not.</p>
  
  <p>so I need anyone's help.</p>
  
  <p>there is my code  I really hope anyone could help me out.</p>
  
  <pre><code>    ///// MainActivity
  
      package com.example.geofence;
  
  
      import java.util.ArrayList;
      import java.util.List;
  
      import android.app.PendingIntent;
      import android.content.BroadcastReceiver;
      import android.content.Context;
      import android.content.Intent;
      import android.content.IntentFilter;
      import android.os.Bundle;
      import android.support.v4.app.FragmentActivity;
      import android.support.v4.content.LocalBroadcastManager;
      import android.text.TextUtils;
      import android.util.Log;
  
      import android.widget.Toast;
  
      import com.google.android.gms.common.ConnectionResult;
      import com.google.android.gms.common.GooglePlayServicesClient.ConnectionCallbacks;
      import com.google.android.gms.common.GooglePlayServicesClient.OnConnectionFailedListener;
      import com.google.android.gms.common.GooglePlayServicesUtil;
      import com.google.android.gms.location.Geofence;
      import com.google.android.gms.location.LocationClient;
      import com.google.android.gms.location.LocationClient.OnAddGeofencesResultListener;
  
      import com.google.android.gms.location.LocationRequest;
      import com.google.android.gms.location.LocationStatusCodes;
  
      public class MainActivity extends FragmentActivity implements 
                                          ConnectionCallbacks, 
                                          OnConnectionFailedListener, 
                                          OnAddGeofencesResultListener
                                           {
      private IntentFilter mIntentFilter;
      private LocationClient locationClient;
      private LocationRequest locatRequest;
  
      private PendingIntent intent;
      private List&lt;Geofence&gt; mGeoList;
      private Context mContext;
      private Geofence companyLocation;
      private  GeofenceSampleReceiver mBroadcastReceiver;
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          mContext = this;
  
          locatRequest = null;
          mGeoList = new ArrayList&lt;Geofence&gt;();
  
          intent = null;
          locationClient = new LocationClient(this,this,this);
  
          mIntentFilter = new IntentFilter();
          mIntentFilter.addAction("com.example.geofence.ACTION_GEOFENCES_ADDED");
          mIntentFilter.addCategory("com.example.geofence.CATEGORY_LOCATION_SERVICES");
          mBroadcastReceiver = new GeofenceSampleReceiver();
      }
  
  
  
  
      @Override
       protected void onStart() {
  
          companyLocation =  new Geofence.Builder()
          .setRequestId("1")
          .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT)
          .setCircularRegion(
                  49.220531, -122.986772, (float)50)
          .setExpirationDuration(Geofence.NEVER_EXPIRE)
          .build();
  
          mGeoList.add(companyLocation);
          locationClient.connect();
          super.onStart();    
  
       }
  
  
  
      @Override
      public void onConnected(Bundle arg0) {
          // TODO Auto-generated method stub
          intent = getTransitionPendingIntent();
  
          locatRequest = LocationRequest.create();
             locatRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
             locatRequest.setInterval(5000);
  
             try{
                 addGeofence();
             }catch(UnsupportedOperationException e){
              Toast.makeText(this, "add_geofences_already_requested_error",
                   Toast.LENGTH_LONG).show();
             }
         //    locationClient.requestLocationUpdates(locatRequest, intent);
  
  
      }
  
      public void addGeofence(){
          locationClient.addGeofences(mGeoList,intent , this);  
  
      }
  
       private PendingIntent getTransitionPendingIntent() {
              // Create an explicit Intent
              Intent localIntent = new Intent(this,
                      ReceiveTransitionsIntentService.class);
              /*
               * Return the PendingIntent
               */
              return PendingIntent.getService(
                      this,
                      0,
                      localIntent,
                      PendingIntent.FLAG_UPDATE_CURRENT);
      }
  
  
  
  
  
  
       @Override
       protected void onStop() {
  
              locationClient.disconnect();
              super.onStop();
  
       }
  
      @Override
      public void onAddGeofencesResult(int statusCode, String[] geofenceRequestIds) {
          // TODO Auto-generated method stub
          Intent broadcastIntent = new Intent();
  
          if(LocationStatusCodes.SUCCESS == statusCode){
              Toast.makeText(this, "Success", Toast.LENGTH_SHORT).show();
  
       broadcastIntent.setAction("com.example.android.geofence.ACTION_GEOFENCES_ADDED")
                              .addCategory("com.example.android.geofence.CATEGORY_LOCATION_SERVICES")
                                      .putExtra("com.example.android.geofence.EXTRA_GEOFENCE_STATUS","test");
          }
          else{
              Toast.makeText(this, "AddGeoError", Toast.LENGTH_SHORT).show();
          }
  
          LocalBroadcastManager.getInstance(mContext).sendBroadcast(broadcastIntent);
  
      }
  
  
  
      @Override
      public void onConnectionFailed(ConnectionResult arg0) {        // TODO Auto-generated method stub
           int code = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
           switch(code){
  
                  case  ConnectionResult.SERVICE_MISSING :{
                      Toast.makeText(this, "SERVICE_MISSING " + code + " ConnectionResult.SERVICE_MISSING " +ConnectionResult.SERVICE_MISSING, Toast.LENGTH_SHORT).show();
                      break;
  
                  }
                  case ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED:{
  
                      Toast.makeText(this, "SERVICE_VERSION_UPDATE_REQUIRED " + code + " ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED " + ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED, Toast.LENGTH_SHORT).show();
  
                      break;
                  }
                  default:{
                      Toast.makeText(this, "start " + code, Toast.LENGTH_SHORT).show();
                  }
  
              }
      }
  
  
  
       @Override
      protected void onDestroy() {
          // TODO Auto-generated method stub
          super.onDestroy();
      }
  
  
  
      @Override
      protected void onPause() {
          // TODO Auto-generated method stub
          super.onPause();
      }
  
  
  
      @Override
      protected void onResume() {
          // TODO Auto-generated method stub
           LocalBroadcastManager.getInstance(this).registerReceiver(mBroadcastReceiver, mIntentFilter);
          //locationClient.connect();
          super.onResume();
      }
  
  
      @Override
      public void onDisconnected() {
          // TODO Auto-generated method stub
          locationClient = null;
      }
  
      /*
       * Handle results returned to this Activity by other Activities started with
       * startActivityForResult(). In particular, the method onConnectionFailed() in
       * GeofenceRemover and GeofenceRequester may call startResolutionForResult() to
       * start an Activity that handles Google Play services problems. The result of this
       * call returns here, to onActivityResult.
       * calls
       */
  
      @Override
      protected void onActivityResult(
                  int requestCode, int resultCode, Intent data) {
      }
  
  
  
  
       /**
       * Define a Broadcast receiver that receives updates from connection listeners and
       * the geofence transition service.
       */
      public class GeofenceSampleReceiver extends BroadcastReceiver {
          /*
           * Define the required method for broadcast receivers
           * This method is invoked when a broadcast Intent triggers the receiver
           */
          @Override
          public void onReceive(Context context, Intent intent) {
  
              // Check the action code and determine what to do
              String action = intent.getAction();
  
              // Intent contains information about errors in adding or removing geofences
           if (TextUtils.equals(action, "com.example.geofence.ACTION_GEOFENCES_ADDED")) {
  
                  handleGeofenceStatus(context, intent);
  
              // Intent contains information about a geofence transition
              } else if (TextUtils.equals(action, "com.example.geofence.ACTION_GEOFENCE_TRANSITION")) {
  
                  handleGeofenceTransition(context, intent);
  
              // The Intent contained an invalid action
              } else {
  
                  Toast.makeText(context,"error", Toast.LENGTH_LONG).show();
              }
          }
  
          /**
           * If you want to display a UI message about adding or removing geofences, put it here.
           *
           * @param context A Context for this component
           * @param intent The received broadcast Intent
           */
          private void handleGeofenceStatus(Context context, Intent intent) {
  
          }
  
          /**
           * Report geofence transitions to the UI
           *
           * @param context A Context for this component
           * @param intent The Intent containing the transition
           */
          private void handleGeofenceTransition(Context context, Intent intent) {
              /*
               * If you want to change the UI when a transition occurs, put the code
               * here. The current design of the app uses a notification to inform the
               * user that a transition has occurred.
               */
          }
  
          /**
           * Report addition or removal errors to the UI, using a Toast
           *
           * @param intent A broadcast Intent sent by ReceiveTransitionsIntentService
           */
          private void handleGeofenceError(Context context, Intent intent) {
  
          }
      }
  
  
  }
  
  
  
  ///// ReceiveTransitionsIntentService
  
      package com.example.geofence;
  
      import java.util.List;
  
      import android.app.IntentService;
      import android.app.NotificationManager;
      import android.app.PendingIntent;
      import android.content.Context;
      import android.content.Intent;
      import android.support.v4.app.NotificationCompat;
      import android.support.v4.app.TaskStackBuilder;
      import android.util.Log;
      import android.widget.Toast;
  
      import com.google.android.gms.location.Geofence;
      import com.google.android.gms.location.LocationClient;
  
      public class ReceiveTransitionsIntentService extends IntentService {
  
      /**
       * Sets an identifier for the service
       */
      private Context mContext;
      public ReceiveTransitionsIntentService(Context c) {
  
          super("ReceiveTransitionsIntentService");
          mContext =c;
      }
  
      /**
       * Handles incoming intents
       *@param intent The Intent sent by Location Services. This
       * Intent is provided
       * to Location Services (inside a PendingIntent) when you call
       * addGeofences()
       */
      @Override
      protected void onHandleIntent(Intent intent) {
          // First check for errors
  
          //Toast.makeText(mContext, "onHandleIntent", Toast.LENGTH_LONG).show();
          if (LocationClient.hasError(intent)) {
              // Get the error code with a static method
              int errorCode = LocationClient.getErrorCode(intent);
              // Log the error
              Log.e("ReceiveTransitionsIntentService",
                      "Location Services error: " +
                      Integer.toString(errorCode));
              /*
               * You can also send the error code to an Activity or
               * Fragment with a broadcast Intent
               */
          /*
           * If there's no error, get the transition type and the IDs
           * of the geofence or geofences that triggered the transition
           */
          } else {
  
  
                int transitionType = LocationClient.getGeofenceTransition(intent);
              if(transitionType == Geofence.GEOFENCE_TRANSITION_ENTER || 
                      transitionType == Geofence.GEOFENCE_TRANSITION_EXIT){
                  List&lt;Geofence&gt; geofences = LocationClient.getTriggeringGeofences(intent);
                  String[] geofenceIds = new String [geofences.size()];
                  for(int i = 0; i &lt;geofences.size(); i++){
                       geofenceIds[i] = geofences.get(i).getRequestId();
                  }
                  String ids = "1";
                  String transition = ((transitionType == Geofence.GEOFENCE_TRANSITION_ENTER ) ?"you are in":"you are out");
                  Toast.makeText(mContext, transition, Toast.LENGTH_LONG).show();
  
                  sendNotification(transition,ids);
                  //FOR THE NOTIFICATION.
  
                  //NotificationManager mNotificationManager =
                    //      (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
  
              }
  
  
  
  
          } 
      }
  
  
  
  
      private void sendNotification(String transitionType, String ids) {
  
          // Create an explicit content Intent that starts the main Activity
          Intent notificationIntent =
                  new Intent(getApplicationContext(),MainActivity.class);
  
          // Construct a task stack
          TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
  
          // Adds the main Activity to the task stack as the parent
          stackBuilder.addParentStack(MainActivity.class);
  
          // Push the content Intent onto the stack
          stackBuilder.addNextIntent(notificationIntent);
  
          // Get a PendingIntent containing the entire back stack
          PendingIntent notificationPendingIntent =
                  stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
  
          // Get a notification builder that's compatible with platform versions &gt;= 4
          NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
  
          // Set the notification contents
          builder.setSmallIcon(R.drawable.ic_notification)
                 .setContentTitle(
                         transitionType+ " geofence_transition_notification_title " +ids)
                 .setContentIntent(notificationPendingIntent);
  
          // Get an instance of the Notification manager
          NotificationManager mNotificationManager =
              (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
  
          // Issue the notification
          mNotificationManager.notify(0, builder.build());
      }
  
  
  
  }
  </code></pre>