@Override
public void onCreate() {

    PreferenceManager.getDefaultSharedPreferences(this).registerOnSharedPreferencechangelistener(this);
    mActivityRecognitionClient =
            new ActivityRecognitionClient(this,this,this);
    /*
     * Create the PendingIntent that Location Services uses
     * to send activity recognition updates back to this app.
     */
    Intent intent = new Intent(
            this,ActivityRecognitionIntentService.class);
    /*
     * Return a PendingIntent that starts the IntentService.
     */
    mActivityRecognitionPendingIntent =
            PendingIntent.getService(this,intent,PendingIntent.FLAG_UPDATE_CURRENT);
}

@SuppressWarnings("unchecked")
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_activity);

    mContext = this;

    // Get the UI widgets.
    mRequestActivityUpdatesButton = (Button) findViewById(R.id.request_activity_updates_button);
    mRemoveActivityUpdatesButton = (Button) findViewById(R.id.remove_activity_updates_button);
    ListView detectedActivitiesListView = (ListView) findViewById(
        R.id.detected_activities_listview);

    // Enable either the Request Updates button or the Remove Updates button depending on
    // whether activity updates have been requested.
    setButtonsEnabledState();

    ArrayList<DetectedActivity> detectedActivities = Utils.detectedActivitiesFromJson(
        PreferenceManager.getDefaultSharedPreferences(this).getString(
            Constants.KEY_DETECTED_ACTIVITIES,""));

    // Bind the adapter to the ListView responsible for display data for detected activities.
    mAdapter = new DetectedActivitiesAdapter(this,detectedActivities);
    detectedActivitiesListView.setAdapter(mAdapter);

    mActivityRecognitionClient = new ActivityRecognitionClient(this);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    btn = (Button) findViewById(R.id.button);
    btn.setonClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            //do something...
            if (!gettingupdates) {
                startActivityUpdates();
            } else {
                stopActivityUpdates();
            }
        }
    });
    mContext = this;
    logger = (TextView) findViewById(R.id.logger);
    // Check to be sure that TTS exists and is okay to use
    Intent checkIntent = new Intent();
    checkIntent.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
    //The result will come back in onActivityResult with our REQ_TTS_STATUS_CHECK number
    startActivityForResult(checkIntent,REQ_TTS_STATUS_CHECK);

    //setup the client activity piece.
    mActivityRecognitionClient = new ActivityRecognitionClient(this);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);

    //setup fragments
    listfrag = new myListFragment();
    mapfrag = new myMapFragment();

    FragmentManager fragmentManager = getSupportFragmentManager();

    viewPager = (ViewPager) findViewById(R.id.pager);
    myFragmentPagerAdapter adapter = new myFragmentPagerAdapter(fragmentManager);
    viewPager.setAdapter(adapter);
    //viewPager.setCurrentItem(1);
    //new Tablayout from the support design library
    TabLayout mTabLayout = (TabLayout) findViewById(R.id.tablayout1);
    mTabLayout.setupWithViewPager(viewPager);

    //setup the client activity piece.
    mActivityRecognitionClient = new ActivityRecognitionClient(this);
    //setup the location pieces.
    mFusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
    mSettingsClient = LocationServices.getSettingsClient(this);
    createLocationRequest();
    createLocationCallback();
    buildLocationSettingsRequest();
    initialsetup();  //get last location and call it current spot.
}

public void startActivityUpdates(Googleapiclient googleapiclient) {
    this.googleapiclient = googleapiclient;
    Intent intent = new Intent(context,DetectedActivitiesIntentService.class );
    pendingIntent = PendingIntent.getService( context,PendingIntent.FLAG_UPDATE_CURRENT );

    ActivityRecognitionClient activityRecognitionClient = ActivityRecognition.getClient(context);
    activityRecognitionClient.requestActivityUpdates(3000,pendingIntent);

    LocalbroadcastManager.getInstance(context).registerReceiver(broadcastReceiver,new IntentFilter(Constants.ACTIVITY_broADCAST_ACTION));
}

public ActivityRecognitionManager(Context context){
    this.context = context;
    connecting = false;
       recognitionClient = new ActivityRecognitionClient(context,this);  

       Intent intent = new Intent(context,ActivityRecognitionIntentService.class);
       recognitionIntent = PendingIntent.getService(context,PendingIntent.FLAG_UPDATE_CURRENT);
}

@SuppressWarnings("unchecked")
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_activity);

    mContext = this;

    // Get the UI widgets.
    mRequestActivityUpdatesButton = (Button) findViewById(R.id.request_activity_updates_button);
    mRemoveActivityUpdatesButton = (Button) findViewById(R.id.remove_activity_updates_button);
    ListView detectedActivitiesListView = (ListView) findViewById(
            R.id.detected_activities_listview);

    // Enable either the Request Updates button or the Remove Updates button depending on
    // whether activity updates have been requested.
    setButtonsEnabledState();

    ArrayList<DetectedActivity> detectedActivities = Utils.detectedActivitiesFromJson(
            PreferenceManager.getDefaultSharedPreferences(this).getString(
                    Constants.KEY_DETECTED_ACTIVITIES,detectedActivities);
    detectedActivitiesListView.setAdapter(mAdapter);

    mActivityRecognitionClient = new ActivityRecognitionClient(this);
}

public ActivitySensor(AbstractMode parentMode,int delay,int confidenceCutoff) {
    super(parentMode);
    Log.i("AS","activity sensor constructor");
    mContext = parentMode.getContext();
    mInProgress = false;
    this.delay = delay;
    this.confidenceCutoff = confidenceCutoff;

    if(servicesConnected()) {

        /*
         * Instantiate a new activity recognition client. Since the
         * parent Activity implements the connection listener and
         * connection failure listener,the constructor uses "this"
         * to specify the values of those parameters.
         */
        mActivityRecognitionClient = new ActivityRecognitionClient(mContext,this);


        // Register the receiver of the intents sent from the IntentService.
        LocalbroadcastManager.getInstance(mContext).registerReceiver(mMessageReceiver,new IntentFilter("ACTIVITY_RECOGNITION_DATA"));

        startUpdates();

        /*
         * Create the PendingIntent that Location Services uses
         * to send activity recognition updates back to this app.
         */
        Intent intent = new Intent(mContext,ActivitySensorIntentService.class);

        /*
         * Return a PendingIntent that starts the IntentService.
         */ 
        mActivityRecognitionPendingIntent = PendingIntent.getService(mContext,PendingIntent.FLAG_UPDATE_CURRENT);
    }
}

@Override
public void onInit() {
    checkNewState(Input.State.INITED);

    int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(getContext());

    if (ConnectionResult.SUCCESS == resultCode) {
        _isLibraryAvailable = true;

        _activityRecognitionClient = new ActivityRecognitionClient(getContext(),this);

        _intervall = getContext().getSharedPreferences(MoSTApplication.PREF_INPUT,Context.MODE_PRIVATE).getLong(PREF_KEY_GOOGLE_ACTIVITY_RECOGNITION_PERIOD,DEFAULT_GOOGLE_ACTIVITY_RECOGNITION_PERIOD);

        _intent = new Intent();
        _intent.setAction(GOOGLE_ACTIVITY_RECOGNITION_ACTION);

        _filter = new IntentFilter();
        _filter.addAction(GOOGLE_ACTIVITY_RECOGNITION_ACTION);

        _receiver = new GoogleActivityRecognitionbroadcastReceiver();

        _pendingIntent = PendingIntent.getbroadcast(getContext(),_intent,PendingIntent.FLAG_UPDATE_CURRENT);

    } else {
        Log.e(TAG,"Google Play Service Library not available.");
    }

    super.onInit();
}

@Override
public void onInit() {
    checkNewState(Input.State.INITED);

    int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(getContext());

    if (ConnectionResult.SUCCESS == resultCode) {
        _isLibraryAvailable = true;

        _activityRecognitionClient = new ActivityRecognitionClient(getContext(),Context.MODE_PRIVATE).getLong(PREF_KEY_GOOGLE_ACTIVITY_RECOGNITION_INTERVALL,DEFAULT_GOOGLE_ACTIVITY_RECOGNITION_INTERVALL);

        _intent = new Intent();
        _intent.setAction(GOOGLE_ACTIVITY_RECOGNITION_ACTION);

        _filter = new IntentFilter();
        _filter.addAction(GOOGLE_ACTIVITY_RECOGNITION_ACTION);  

        _receiver = new GoogleActivityRecognitionbroadcastReceiver();

        _pendingIntent = PendingIntent.getbroadcast(getContext(),"Google Play Service Library not available.");
    }

    super.onInit();
}

/**
 * Call this to start a scan - don't forget to stop the scan once it's done.
 * Note the scan will not start immediately,because it needs to establish a connection with Google's servers - you'll be notified of this at onConnected
 */
public void startActivityRecognitionScan(){

    mActivityRecognitionClient  = new ActivityRecognitionClient(mContext,this);
    mActivityRecognitionClient.connect();
    Log.i(TAG,"startActivityRecognitionScan");
}

/**
 * Constructor
 * 
 * @param context
 *            the application context.
 */
public ActivityRequester(Context context) {
    /* The application context. */
    this.context = context;

    /*
     * Create a new activity client,using this class to handle the
     * callbacks.
     */
    activityClient = new ActivityRecognitionClient(this.context,this);

    activityClient.connect();

    locbroadcastManager = LocalbroadcastManager.getInstance(context);
}

@Override
public void onCreate() {
  super.onCreate();
  executorService = Executors.newSingleThreadExecutor();
  context = this;
  myTracksProviderUtils = MyTracksProviderUtils.Factory.get(this);
  handler = new Handler();
  myTracksLocationManager = new MyTracksLocationManager(this,handler.getLooper(),true);
  activityRecognitionPendingIntent = PendingIntent.getService(context,new Intent(context,ActivityRecognitionIntentService.class),PendingIntent.FLAG_UPDATE_CURRENT);
  activityRecognitionClient = new ActivityRecognitionClient(
      context,activityRecognitionCallbacks,activityRecognitionFailedListener);
  activityRecognitionClient.connect();    
  voiceExecutor = new PeriodicTaskExecutor(this,new AnnouncementPeriodicTaskFactory());
  splitExecutor = new PeriodicTaskExecutor(this,new SplitPeriodicTaskFactory());
  sharedPreferences = getSharedPreferences(Constants.SETTINGS_NAME,Context.MODE_PRIVATE);
  sharedPreferences.registerOnSharedPreferencechangelistener(sharedPreferencechangelistener);

  // onSharedPreferenceChanged might not set recordingTrackId.
  recordingTrackId = PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;

  // Require voiceExecutor and splitExecutor to be created.
  sharedPreferencechangelistener.onSharedPreferenceChanged(sharedPreferences,null);

  handler.post(registerLocationRunnable);

  /*
   * Try to restart the prevIoUs recording track in case the service has been
   * restarted by the system,which can sometimes happen.
   */
  Track track = myTracksProviderUtils.getTrack(recordingTrackId);
  if (track != null) {
    restartTrack(track);
  } else {
    if (isRecording()) {
      Log.w(TAG,"track is null,but recordingTrackId not -1L. " + recordingTrackId);
      updateRecordingState(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT,true);
    }
    showNotification(false);
  }
}

public void stopActivityUpdates() {
    ActivityRecognitionClient activityRecognitionClient = ActivityRecognition.getClient(context);
    activityRecognitionClient.removeActivityUpdates(pendingIntent);
    this.googleapiclient.disconnect();
    LocalbroadcastManager.getInstance(context).unregisterReceiver(broadcastReceiver);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // Activity Recog
    mActivityRecognitionClient = new ActivityRecognitionClient(
            getApplicationContext(),(com.google.android.gms.common.GooglePlayServicesClient.ConnectionCallbacks) this,this);
    Intent intent = new Intent(getApplicationContext(),ActivityRecognitionIntentService.class);
    mActivityRecognitionClient.connect();
    mActivityRecognitionPendingIntent = PendingIntent.getService(
            getApplicationContext(),PendingIntent.FLAG_UPDATE_CURRENT);
    mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);
    mDrawerList = (ListView) findViewById(R.id.left_drawer);
    mDrawerList.setAdapter(new ArrayAdapter<String>(this,R.layout.drawer_list_item,drawerNames));
    mDrawerList.setonItemClickListener(new DrawerItemClickListener());
    mDrawerToggle = new ActionBarDrawerToggle(this,/* host Activity */
    mDrawerLayout,/* DrawerLayout object */
    R.drawable.ic_drawer,/* nav drawer icon to replace 'Up' caret */
    R.string.drawer_open,/* "open drawer" description */
    R.string.drawer_close /* "close drawer" description */
    ) {

        /** Called when a drawer has settled in a completely closed state. */
        public void onDrawerClosed(View view) {
            super.onDrawerClosed(view);
        }

        /** Called when a drawer has settled in a completely open state. */
        public void onDrawerOpened(View drawerView) {
            super.onDrawerOpened(drawerView);
        }
    };

    // Set the drawer toggle as the DrawerListener
    mDrawerLayout.setDrawerListener(mDrawerToggle);

    getSupportActionBar().setdisplayHomeAsUpEnabled(true);
    getSupportActionBar().setHomeButtonEnabled(true);
    if (savedInstanceState == null) {
        selectItem(0);
    }
}

/**
 * Call this to start a scan - don't forget to stop the scan once it's done.
 * Note the scan will not start immediately,because it needs to establish a connection with Google's servers - you'll be notified of this at onConnected
 */
public void startActivityRecognitionScan(){
    mActivityRecognitionClient  = new ActivityRecognitionClient(context,this);
    mActivityRecognitionClient.connect();
    Log.d(TAG,"startActivityRecognitionScan");
}

@Override
public void run() {
    Debug.log("Thread init");

    databaseHelper = Database.Helper.getInstance(context);

    alarm = (AlarmManager)context.getSystemService(ALARM_SERVICE);
    {
        Intent i = new Intent(context.getApplicationContext(),BackgroundService.class);
        i.putExtra(EXTRA_ALARM_CALLBACK,1);
        alarmCallback = PendingIntent.getService(BackgroundService.this,i,0);
    }

    Looper.prepare();
    handler = new Handler();

    Debug.log("Registering for updates");           
    prefs = PreferenceManager.getDefaultSharedPreferences(context);                 
    long id = prefs.getLong(SettingsFragment.PREF_CURRENT_PROFILE,0);
    if (id > 0) currentProfile = Database.Profile.getById(databaseHelper,id,null);
    if (currentProfile == null) currentProfile = Database.Profile.getoffProfile(databaseHelper);
    metric = !prefs.getString(SettingsFragment.PREF_UNITS,SettingsFragment.PREF_UNITS_DEFAULT).equals(SettingsFragment.VALUE_UNITS_IMPERIAL);
    prefs.registerOnSharedPreferencechangelistener(preferencesUpdated);
    LocalbroadcastManager.getInstance(context).registerReceiver(databaseUpdated,new IntentFilter(Database.Helper.NOTIFY_broADCAST));

    Debug.log("Registering for power levels");
    context.registerReceiver(batteryReceiver,new IntentFilter(Intent.ACTION_BATTERY_CHANGED));

    Debug.log("Connecting ActivityRecognitionClient");
    activityIntent = PendingIntent.getService(context,1,BackgroundService.class),0);
    activityClient = new ActivityRecognitionClient(context,activityConnectionCallbacks,activityConnectionFailed);
    activityClient.connect();

    Debug.log("Connecting LocationClient");
    locationClient = new LocationClient(context,locationConnectionCallbacks,locationConnectionFailed);
    locationClient.connect();

    Debug.log("Entering loop");
    handler.post(new Runnable() {               
        @Override
        public void run() {
            updateListeners(FLAG_SETUP);
        }
    });                     
    Looper.loop();          
    Debug.log("Exiting loop");

    context.unregisterReceiver(batteryReceiver);

    LocalbroadcastManager.getInstance(context).unregisterReceiver(databaseUpdated);
    prefs.unregisterOnSharedPreferencechangelistener(preferencesUpdated);           

    if (activityConnected) {
        activityClient.removeActivityUpdates(activityIntent);
        activityClient.disconnect();
    }
    if (locationConnected) {
        locationClient.removeLocationUpdates(locationListener);
        locationClient.disconnect();
    }           
}

@Override
public void onReceive(Context context,Intent intent) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
    ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

    //Find the activity with the highest percentage
    lastActivity = getProbableActivity(detectedActivities);

    Log.d(TAG,"MOST LIKELY ACTIVITY: " + getActivityString(lastActivity.getType()) + " " + lastActivity.getConfidence());

    if (lastActivity.getType() == DetectedActivity.STILL) {
        if (config.isDebugging()) {
            Toast.makeText(context,"Detected STILL Activity",Toast.LENGTH_SHORT).show();
        }
        // stopTracking();
        // we will delay stop tracking after position is found
    } else {
        if (config.isDebugging()) {
            Toast.makeText(context,"Detected ACTIVE Activity",Toast.LENGTH_SHORT).show();
        }
        startTracking();
    }
    //else do nothing
}

/**
 * Handles incoming intents.
 * @param intent The Intent is provided (inside a PendingIntent) when requestActivityUpdates()
 *               is called.
 */
@SuppressWarnings("unchecked")
@Override
protected void onHandleIntent(Intent intent) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

    // Get the list of the probable activities associated with the current state of the
    // device. Each activity is associated with a confidence level,which is an int between
    // 0 and 100.
    ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

    PreferenceManager.getDefaultSharedPreferences(this)
        .edit()
        .putString(Constants.KEY_DETECTED_ACTIVITIES,Utils.detectedActivitiesToJson(detectedActivities))
        .apply();

    // Log each activity.
    Log.i(TAG,"activities detected");
    for (DetectedActivity da: detectedActivities) {
        Log.i(TAG,Utils.getActivityString(
            getApplicationContext(),da.getType()) + " " + da.getConfidence() + "%"
        );
    }
}

@Override
protected void onNewIntent(Intent intent) {
    Log.v(TAG,"onNewIntent");

    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
    //get most probable activity
    DetectedActivity probably = result.getMostProbableActivity();
    if (probably.getConfidence() >= 50) {  //doc's say over 50% is likely,under is not sure at all.
        speech(getActivityString(probably.getType()));
    }
    logger.append("Most Probable: " +getActivityString(probably.getType()) + " "+ probably.getConfidence()+"%\n" );
    //or we Could go through the list,which is sorted by most likely to least likely.
    List<DetectedActivity> fulllist = result.getProbableActivities();
    for (DetectedActivity da: fulllist) {
        if (da.getConfidence() >=50) {
            logger.append("-->" + getActivityString(da.getType()) + " " + da.getConfidence() + "%\n");
            speech(getActivityString(da.getType()));

        }
    }
}

@Override
public void onReceive(Context context,Intent intent) {
  ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
  ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

  //Find the activity with the highest percentage
  lastActivity = Constants.getProbableActivity(detectedActivities);

  Log.w(TAG,"MOST LIKELY ACTIVITY: " + Constants.getActivityString(lastActivity.getType()) + " " + lastActivity.getConfidence());

  Intent mIntent = new Intent(Constants.CALLBACK_ACTIVITY_UPDATE);
  mIntent.putExtra(Constants.ACTIVITY_EXTRA,detectedActivities);
  getApplicationContext().sendbroadcast(mIntent);
  Log.w(TAG,"Activity is recording" + isRecording);

  if(lastActivity.getType() == DetectedActivity.STILL && isRecording) {
      showDebugToast(context,"Detected Activity was STILL,Stop recording");
      stopRecording();
  } else if(lastActivity.getType() != DetectedActivity.STILL && !isRecording) {
      showDebugToast(context,"Detected Activity was ACTIVE,Start Recording");
      startRecording();
  }
  //else do nothing
}

/**
 * Handles incoming intents.
 *
 * @param intent The Intent is provided (inside a PendingIntent) when requestActivityUpdates()
 *               is called.
 */
@Override
protected void onHandleIntent(Intent intent) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
    Intent localIntent = new Intent(Constants.broADCAST_ACTION);

    // Get the list of the probable activities associated with the current state of the
    // device. Each activity is associated with a confidence level,which is an int between
    // 0 and 100.
    ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

    // Log each activity.
    Log.i(TAG,"activities detected");
    for (DetectedActivity da : detectedActivities) {
        Log.i(TAG,Constants.getActivityString(
                        getApplicationContext(),da.getType()) + " " + da.getConfidence() + "%"
        );
    }

    // broadcast the list of detected activities.
    localIntent.putExtra(Constants.ACTIVITY_EXTRA,detectedActivities);
    LocalbroadcastManager.getInstance(this).sendbroadcast(localIntent);
}

/**
 * Handles incoming intents.
 *
 * @param intent The Intent is provided (inside a PendingIntent) when requestActivityUpdates()
 *               is called.
 */
@Override
protected void onHandleIntent(Intent intent) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
    Intent localIntent = new Intent(Constants.ACTIVITY_broADCAST_ACTION);

    if (result == null) {
        return;
    }

    ArrayList<DetectedActivity> res = new ArrayList<>();
    for (DetectedActivity d : result.getProbableActivities()) {
        if (d.getConfidence() > Constants.MIN_ACTIVITY_CONFIDENCE) {
            res.add(d);
        }
    }

    // broadcast the list of detected activities.
    localIntent.putExtra(Constants.ACTIVITY_EXTRA,res);
    LocalbroadcastManager.getInstance(this).sendbroadcast(localIntent);
}

@Override
public void onReceive(Context context,Toast.LENGTH_SHORT).show();
        }
        startTracking();
    }
    //else do nothing
}

@Subscribe 
public void messageAvailable(AndroidEventMessage m) {

     if(m.getId().equals(Configuration.NO_CONNECTION)){
         //detener geo e ibacon services
         Log.i("pandora","stoping services because NO CONNECTION");
         stopServices(contexto);
     }else if(m.getId().equals(Configuration.CONNECTION)){
        //activar geo e ibacon services
         Log.i("pandora","restarting services because CONNECTION");
         startServices(contexto,this.iBeacon,true);
     }else if(m.getId().equals(Configuration.NEW_ACTIVITY) && GeoService.receivedFix>2){ 

         ActivityRecognitionResult result = (ActivityRecognitionResult) m.getContent(); 
         String activity = parseActivity(result.getMostProbableActivity());
         Log.i("pandora","new activity: "+activity);  
         if(result.getMostProbableActivity().getType()==DetectedActivity.STILL && result.getMostProbableActivity().getConfidence()>80){
             Log.i("pandora","stoping services because STILL");
             stopServices(contexto);
         }else {
             Log.i("pandora","restarting services because NOT STILL");  
             startServices(contexto,true);
         }
     } 
}

/**
 * Handles incoming intents.
 * @param intent The Intent is provided (inside a PendingIntent) when requestActivityUpdates()
 *               is called.
 */
@SuppressWarnings("unchecked")
@Override
protected void onHandleIntent(Intent intent) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

    // Get the list of the probable activities associated with the current state of the
    // device. Each activity is associated with a confidence level,which is an int between
    // 0 and 100.
    ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

    PreferenceManager.getDefaultSharedPreferences(this)
            .edit()
            .putString(Constants.KEY_DETECTED_ACTIVITIES,Utils.detectedActivitiesToJson(detectedActivities))
            .apply();

    // Log each activity.
    Log.i(TAG,Utils.getActivityString(
                        getApplicationContext(),da.getType()) + " " + da.getConfidence() + "%"
        );
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    if (ActivityRecognitionResult.hasResult(intent)) {
        ActivityRecognitionResult result =
                ActivityRecognitionResult.extractResult(intent);
        DetectedActivity mostProbableActivity = result.getMostProbableActivity();
        int confidence = mostProbableActivity.getConfidence();
        int activityType = mostProbableActivity.getType();
        long waitTime = UserSettings.getNotDrivingTime(this);
        boolean diffTimeOK = (new Date().getTime() - waitTime) >= Utils.minutesToMillis(10);
        if (confidence >= Utils.DETECTION_THRESHOLD && activityType == DetectedActivity.IN_VEHICLE && diffTimeOK) {
            if (!CarMode.running) {
                if (UserSettings.getGPS(this) && ContextCompat.checkSelfPermission(this,Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED)
                    startService(new Intent(this,SpeedService.class));
                else
                    startService(new Intent(this,CarMode.class));
            }
        } else if (confidence >= Utils.DETECTION_THRESHOLD) {
            stopService(new Intent(this,CarMode.class));
            UserSettings.setGPSDrive(this,false);
        }

    }
}

@Override
public void onReceive(Context context,Intent intent) {

    if (ActivityRecognitionResult.hasResult(intent)) {
        // Get the update
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
        // Get the most probable activity
        DetectedActivity mostProbableActivity = result.getMostProbableActivity();
        int confidence = mostProbableActivity.getConfidence();
        int activityType = mostProbableActivity.getType();
        String activityName = getNameFromType(activityType);

        DataBundle b = _bundlePool.borrowBundle();
        b.putInt(KEY_CONFIDENCE,confidence);
        b.putString(KEY_RECOGNIZED_ACTIVITY,activityName);
        b.putLong(Input.KEY_TIMESTAMP,System.currentTimeMillis());
        b.putInt(Input.KEY_TYPE,getType().toInt());
        post(b);

    }

}

@Override
protected void onHandleIntent(Intent intent) {
    if (mPreferenceUtils.isActivityUpdatesstarted()) {
        if (ActivityRecognitionResult.hasResult(intent)) {
            mPreferenceUtils.setLastActivityTime(System.currentTimeMillis());
            ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
            boolean moving = isMoving(result);
            mPreferenceUtils.setMoving(moving);
            if (moving) {
                if (!mPreferenceUtils.isLocationUpdatesstarted()) {
                    mLocationUpdatesController.startLocationUpdates();
                }
            } else {
                if (mPreferenceUtils.isLocationUpdatesstarted()) {
                    mLocationUpdatesController.stopLocationUpdates();
                }
            }
        }
    }
}

/**
 * Detecta si el dispositivo se encuentra en un vehículo en movimiento o no
 *
 * @param result resultado de la detección de actividad
 * @return <code>true</code> si se encuentra en un vehículo.
 */
private boolean isMoving(ActivityRecognitionResult result) {
    long currentTime = System.currentTimeMillis();

    DetectedActivity mostProbableActivity = result.getMostProbableActivity();
    int confidence = mostProbableActivity.getConfidence();
    int type = mostProbableActivity.getType();

    if ((type == ON_FOOT || type == RUNNING || type == WALKING) && confidence > 75) {
        return false;
    }

    if (type == IN_VEHICLE && confidence > 75) {
        mPreferenceUtils.setDetectionTimeMillis(currentTime);
        return true;
    }

    if (mPreferenceUtils.wasMoving()) {
        long tolerance = mPreferenceUtils.getActivityRecognitionToleranceMillis();
        long lastDetectionTime = mPreferenceUtils.getDetectionTimeMillis();
        long elapsedtime = currentTime - lastDetectionTime;
        return elapsedtime <= tolerance;
    }

    return false;
}

@Override
protected void onHandleIntent(Intent intent) {

    // If the intent contains an update
    if (ActivityRecognitionResult.hasResult(intent)) {

        // Get the update
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

        Intent i = new Intent(broADCAST_UPDATE);
        i.putExtra(RECOGNITION_RESULT,result);
        LocalbroadcastManager manager = LocalbroadcastManager.getInstance(this);
        manager.sendbroadcast(i);
    }

}

private DetectedActivity getActivity(ActivityRecognitionResult result) {

        // Get the most probable activity from the list of activities in the result
        DetectedActivity mostProbableActivity = result.getMostProbableActivity();

        // If the activity is ON_FOOT,choose between WALKING or RUNNING
        if (mostProbableActivity.getType() == DetectedActivity.ON_FOOT) {

            // Iterate through all possible activities. The activities are sorted by most probable activity first.
            for (DetectedActivity activity : result.getProbableActivities()) {

                if (activity.getType() == DetectedActivity.WALKING || activity.getType() == DetectedActivity.RUNNING) {
                    return activity;
                }
            }

            // It is ON_FOOT,but not sure if it is WALKING or RUNNING
            Log.i(TAG,"Activity ON_FOOT,but not sure if it is WALKING or RUNNING.");
            return mostProbableActivity;
        }
        else
        {
            return mostProbableActivity;
        }

    }

/**
 * Called when a new activity detection update is available.
 */
@Override
protected void onHandleIntent(Intent intent) {
    //...
    // If the intent contains an update
    if (ActivityRecognitionResult.hasResult(intent)) {
        // Get the updatenex
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

        DetectedActivity mostProbableActivity = result.getMostProbableActivity();

        // Get the confidence % (probability)
        int confidence = mostProbableActivity.getConfidence();

        // Get the type
        int activityType = mostProbableActivity.getType();

        Intent sendToLoggerIntent = new Intent("com.pinsonault.androidsensorlogger.ACTIVITY_RECOGNITION_DATA");
        sendToLoggerIntent.putExtra("Activity",activityType);
        sendToLoggerIntent.putExtra("Confidence",confidence);
        sendbroadcast(sendToLoggerIntent);
    }
}

@Override
public void onHandleIntent(Intent intent) {
    if (DEBUG) Log.d(TAG,"onHandleIntent: intent="+intent);
    if (!ActivityRecognitionResult.hasResult(intent)) {
        return;
    }

    ActivityRecognitionResult arr = ActivityRecognitionResult.extractResult(intent);
    DetectedActivity mpa = arr.getMostProbableActivity();

    Intent i = new Intent(Constants.ACTION_RECOGNITION);
    i.putExtra(Constants.EXTRA_TYPE,mpa.getType());
    i.putExtra(Constants.EXTRA_CONFIDENCE,mpa.getConfidence());

    LocalbroadcastManager.getInstance(this).sendbroadcast(i);
}

@Override
protected void onHandleIntent(Intent intent) {
    if (intent.getAction() != LocationActivity.ACTION_ACTIVITY_RECOGNITION) {
        return;
    }
    if (ActivityRecognitionResult.hasResult(intent)) {
        ActivityRecognitionResult result = ActivityRecognitionResult
                .extractResult(intent);
        DetectedActivity detectedActivity = result
                .getMostProbableActivity();
        int activityType = detectedActivity.getType();

        Log.v(LocationActivity.TAG,"activity_type == " + activityType);

        // Put the activity_type as an intent extra and send a broadcast.
        Intent send_intent = new Intent(
                LocationActivity.ACTION_ACTIVITY_RECOGNITION);
        send_intent.putExtra("activity_type",activityType);
        sendbroadcast(send_intent);
    }
}

@Override
protected void onGoogleapiclientReady(Googleapiclient apiclient,Observer<? super ActivityRecognitionResult> observer) {
    receiver = new ActivityUpdatesbroadcastReceiver(observer);
    context.registerReceiver(receiver,new IntentFilter(ACTION_ACTIVITY_DETECTED));
    PendingIntent receiverIntent = getReceiverPendingIntent();
    ActivityRecognition.ActivityRecognitionApi.requestActivityUpdates(apiclient,detectionIntervalMilliseconds,receiverIntent);
}

@Override
public void onReceive(Context context,Intent intent) {
    if (ActivityRecognitionResult.hasResult(intent)) {
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
        observer.onNext(result);
    }
}

@Override
protected void onHandleIntent(final Intent intent) {
    if (DEBUG) {
        MyLog.i(CLS_NAME,"onHandleIntent");
    }

    if (SPH.getMotionEnabled(getApplicationContext())) {

        if (intent != null) {
            if (DEBUG) {
                examineIntent(intent);
            }

            if (ActivityRecognitionResult.hasResult(intent)) {
                final Motion motion = extractMotion(intent);
                if (motion != null) {
                    MotionHelper.setMotion(getApplicationContext(),motion);
                } else {
                    if (DEBUG) {
                        MyLog.i(CLS_NAME,"onHandleIntent: motion null: ignoring");
                    }
                }
            } else {
                if (DEBUG) {
                    MyLog.i(CLS_NAME,"onHandleIntent: no ActivityRecognition results");
                }
            }
        } else {
            if (DEBUG) {
                MyLog.w(CLS_NAME,"onHandleIntent: intent: null");
            }
        }
    } else {
        if (DEBUG) {
            MyLog.i(CLS_NAME,"onHandleIntent: user has switched off. Don't store.");
        }
    }
}

private void handleResult(@NonNull DetectedActivityResult detectedActivityResult){
    ActivityRecognitionResult ar = detectedActivityResult.getActivityRecognitionResult();
    RecognizedActivityResult result = new RecognizedActivityResult();
    List<DetectedActivity> acts = ar.getProbableActivities();
    result.activities = new RecognizedActivity[acts.size()];
    for(int i = 0; i < acts.size(); ++i){
        DetectedActivity act = acts.get(i);
        result.activities[i] = new RecognizedActivity(act.getType(),act.getConfidence());
    }
    resultCallback.onResult(result);
}

public static SubjectFactory<ActivityRecognitionResultSubject,ActivityRecognitionResult> type() {
  return new SubjectFactory<ActivityRecognitionResultSubject,ActivityRecognitionResult>() {
    @Override
    public ActivityRecognitionResultSubject getSubject(FailureStrategy fs,ActivityRecognitionResult that) {
      return new ActivityRecognitionResultSubject(fs,that);
    }
  };
}

/**
 * Handles new motion activity data
 *
 * @param userActivityResult
 */
public void handleData(ActivityRecognitionResult userActivityResult) {

    probableActivities = userActivityResult.getProbableActivities();
    mostProbableActivity = userActivityResult.getMostProbableActivity();

    dumpdata();
}

@Override
public void onReceive(Context context,Intent intent) {

  // Modify the status of mRealTimePositionVeLocityCalculator only if the status is set to auto
  // (indicated by mAutoSwitchGroundTruthMode).
  if (mAutoSwitchGroundTruthMode) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
    setGroundTruthModeOnResult(result);
  }
}

/**
 * Sets up the ground truth mode of {@link RealTimePositionVeLocityCalculator} given an result
 * from Activity Recognition update. For activities other than {@link DetectedActivity#STILL}
 * and {@link DetectedActivity#TILTING},we conservatively assume the user is moving and use the
 * last WLS position solution as ground truth for corrected residual computation.
 */
private void setGroundTruthModeOnResult(ActivityRecognitionResult result){
  if (result != null){
    int detectedActivityType = result.getMostProbableActivity().getType();
    if (detectedActivityType == DetectedActivity.STILL
        || detectedActivityType == DetectedActivity.TILTING){
      mRealTimePositionVeLocityCalculator.setResidualPlotMode(
          RealTimePositionVeLocityCalculator.RESIDUAL_MODE_STILL,null);
    } else {
      mRealTimePositionVeLocityCalculator.setResidualPlotMode(
          RealTimePositionVeLocityCalculator.RESIDUAL_MODE_MOVING,null);
    }
  }
}

/**
 * Called when a new activity detection update is available.
 */
@Override
protected void onHandleIntent(final Intent intent) {
    if (ActivityRecognitionResult.hasResult(intent)) {
        new Handler(getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                activityRecognizerListener.onActivityRecognized(
                        ActivityType.values()[ActivityRecognitionResult.extractResult(intent).getMostProbableActivity().getType()]
                );
            }
        });
    }
}

@Override
protected void onHandleIntent(Intent intent) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
    ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

    Log.d(TAG,"Detected activities:");
    for (DetectedActivity da: detectedActivities) {
        Log.d(TAG,getActivityString(da.getType()) + " (" + da.getConfidence() + "%)");
    }

    Intent localIntent = new Intent(broADCAST_ACTION);
    localIntent.putExtra(ACTIVITY_EXTRA,detectedActivities);
    LocalbroadcastManager.getInstance(this).sendbroadcast(localIntent);
}

@Override
protected void onHandleIntent(Intent intent) {
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
    if (LocationTrackingService.isRunning()) {
        LocationTrackingService.get().locationManager().onActivitiesDetected(result);
    }
}

public void onActivitiesDetected(ActivityRecognitionResult recognitionResult) {
    // if you tilt the phone,this will come through,ignore it
    if (onlyTilting(recognitionResult.getProbableActivities())) {
        return;
    }

    if (_detectedActivitiesCache.size() == 5) {
        _detectedActivitiesCache.remove(0);
    }
    _detectedActivitiesCache.add(recognitionResult);
}

/**
 * Handles incoming intents.
 *
 * @param intent The Intent is provided (inside a PendingIntent) when requestActivityUpdates()
 *               is called.
 */
@Override
protected void onHandleIntent(Intent intent) {
    int currentActivity = DetectedActivity.UNKNowN;
    //get the message handler
    Messenger messenger = null;
    Bundle extras = intent.getExtras();
    if (extras != null) {
        messenger = (Messenger) extras.get("MESSENGER");
    }
    //get the activity info
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

    //get most probable activity
    DetectedActivity probably = result.getMostProbableActivity();
    if (probably.getConfidence() >= 50) {  //doc's say over 50% is likely,under is not sure at all.
        currentActivity = probably.getType();
    }
    Log.v(TAG,"about to send message");
    if (messenger != null) {
        Message msg = Message.obtain();
        msg.arg1 = currentActivity;
        Log.v(TAG,"Sent message");
        try {
            messenger.send(msg);
        } catch (android.os.remoteexception e1) {
            Log.w(getClass().getName(),"Exception sending message",e1);
        }
    }

}

@Override
protected void onHandleIntent(Intent intent) {

    // Get the ActivityRecognitionResult
    ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

    // Get the list of the probable activities
    ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

    String type = "";
    float confidence = 0;

    // Select the most confidence type
    for (DetectedActivity da : detectedActivities) {
        if (da.getConfidence() > confidence) {
            confidence = da.getConfidence();
            type = Constants.getActivityString(
                    getApplicationContext(),da.getType());
        }
    }

    // Add to the notification the current most confidence activity
    NotificationCompat.Builder mBuilder =
            new NotificationCompat.Builder(this)
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setContentTitle("Current activity: " + type)
                    .setongoing(true)
                    .setContentText("Confidence: " + String.valueOf(confidence) + "%");
    int mNotificationId = Constants.NOTIFICATION_ID;
    notificationmanager mNotifyMgr =
            (notificationmanager) getSystemService(NOTIFICATION_SERVICE);
    mNotifyMgr.notify(mNotificationId,mBuilder.build());
}

@Override
protected void onHandleIntent(Intent intent) {
    if (ActivityRecognitionResult.hasResult(intent)) {
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
        if (DSContext.CONTEXT != null && DSContext.CONTEXT.activityNode != null) {
            String name = getNameFromType(result.getMostProbableActivity().getType());
            DSContext.CONTEXT.activityNode.setValue(new Value(name));
        }
    }
}

/** Called when a new activity detection update is available.
 * 
 */
@Override
protected void onHandleIntent(Intent intent){
    if(ActivityRecognitionResult.hasResult(intent)){

        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
        // notify   
        AndroidEventBus.getInstance().getBus().post(new AndroidEventMessage(Configuration.NEW_ACTIVITY,result)); 

    }
}

/**
 * Called when a new activity detection update is available.
 */
@Override
protected void onHandleIntent(Intent intent) {
    Log.i("AS Service","onHandleIntent: Got here!");
    if (ActivityRecognitionResult.hasResult(intent)) {
        // Get the update
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

        DetectedActivity mostProbableActivity = result.getMostProbableActivity();

        // Get the confidence % (probability)
        int confidence = mostProbableActivity.getConfidence();

        // Get the type
        int activityType = mostProbableActivity.getType();

        // process 
        Intent broadcastIntent = new Intent(ACTIVITY_RECOGNITION_DATA);
        broadcastIntent.putExtra(ACTIVITY,activityType);
        broadcastIntent.putExtra(CONFIDENCE,confidence);
        LocalbroadcastManager.getInstance(this).sendbroadcast(broadcastIntent);

        Log.i("AS Service","Sent a local broardcast with the activity data.");

    }
    Log.i("AS","onHandleIntent called");
}

@Override
public void onHandleIntent(Intent intent) {
    if (ActivityRecognitionResult.hasResult(intent)) {
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
        List<DetectedActivity> activities = result.getProbableActivities();

        DetectedActivity bestActivity = null;
        int bestConfidence = 0;

        for (DetectedActivity activity : activities) {
            Log.d(TAG,"Activity " + activity.getType() + " " + activity.getConfidence());
            if (ACTIVITY_MASK.contains(activity.getType())) {
                if (activity.getConfidence() > bestConfidence) {
                    bestActivity = activity;
                    bestConfidence = activity.getConfidence();
                }
            }
        }

        DetectedActivity currentActivity = bestActivity;
        long currentTime = System.currentTimeMillis();
        if (currentActivity == null) {
            Log.w(TAG,"No activity matches!");
            return;
        }
        if (mGameHandler != null && mGameHandler.getLooper().getThread().isAlive()) {
            mGameHandler.sendMessage(
                    mGameHandler.obtainMessage(MESSAGE_ACTIVITY,new activitylog(currentActivity,currentTime))
            );
        }
    }
}

@Override
public void onReceive(Context context,Intent intent) {

    if (ActivityRecognitionResult.hasResult(intent)) {
        // Get the update
        ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
        // Get the most probable activity
        DetectedActivity mostProbableActivity = result.getMostProbableActivity();
        int confidence = mostProbableActivity.getConfidence();
        int activityType = mostProbableActivity.getType();
        String activityName = getNameFromType(activityType);

        if (DEBUG)
            Log.i(TAG,String.format("Recognized %s with confidence %d",activityName,confidence));

        DataBundle b = _bundlePool.borrowBundle();
        b.putInt(KEY_CONFIDENCE,getType().toInt());
        post(b);

        if (_activityRecognitionClient != null && _activityRecognitionClient.isConnected()) {
            _activityRecognitionClient.removeActivityUpdates(_pendingIntent);
            _activityRecognitionClient.disconnect();
            _activityRecognitionClient = null;
        }

    }

}