content: /*
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
  
  package com.example.android.batchstepsensor;
  
  import android.app.Activity;
  import android.content.pm.PackageManager;
  import android.hardware.Sensor;
  import android.hardware.SensorEvent;
  import android.hardware.SensorEventListener;
  import android.hardware.SensorManager;
  import android.os.Bundle;
  import android.support.v4.app.Fragment;
  
  import com.example.android.common.logger.Log;
  import com.example.android.batchstepsensor.cardstream.Card;
  import com.example.android.batchstepsensor.cardstream.CardStream;
  import com.example.android.batchstepsensor.cardstream.CardStreamFragment;
  import com.example.android.batchstepsensor.cardstream.OnCardClickListener;
  
  public class BatchStepSensorFragment extends Fragment implements OnCardClickListener {
  
      public static final String TAG = "StepSensorSample";
      // Cards
      private CardStreamFragment mCards = null;
  
      // Card tags
      public static final String CARD_INTRO = "intro";
      public static final String CARD_REGISTER_DETECTOR = "register_detector";
      public static final String CARD_REGISTER_COUNTER = "register_counter";
      public static final String CARD_BATCHING_DESCRIPTION = "register_batching_description";
      public static final String CARD_COUNTING = "counting";
      public static final String CARD_EXPLANATION = "explanation";
      public static final String CARD_NOBATCHSUPPORT = "error";
  
      // Actions from REGISTER cards
      public static final int ACTION_REGISTER_DETECT_NOBATCHING = 10;
      public static final int ACTION_REGISTER_DETECT_BATCHING_5s = 11;
      public static final int ACTION_REGISTER_DETECT_BATCHING_10s = 12;
      public static final int ACTION_REGISTER_COUNT_NOBATCHING = 21;
      public static final int ACTION_REGISTER_COUNT_BATCHING_5s = 22;
      public static final int ACTION_REGISTER_COUNT_BATCHING_10s = 23;
      // Action from COUNTING card
      public static final int ACTION_UNREGISTER = 1;
      // Actions from description cards
      private static final int ACTION_BATCHING_DESCRIPTION_DISMISS = 2;
      private static final int ACTION_EXPLANATION_DISMISS = 3;
  
      // State of application, used to register for sensors when app is restored
      public static final int STATE_OTHER = 0;
      public static final int STATE_COUNTER = 1;
      public static final int STATE_DETECTOR = 2;
  
      // Bundle tags used to store data when restoring application state
      private static final String BUNDLE_STATE = "state";
      private static final String BUNDLE_LATENCY = "latency";
      private static final String BUNDLE_STEPS = "steps";
  
      // max batch latency is specified in microseconds
      private static final int BATCH_LATENCY_0 = 0; // no batching
      private static final int BATCH_LATENCY_10s = 10000000;
      private static final int BATCH_LATENCY_5s = 5000000;
  
      /*
      For illustration we keep track of the last few events and show their delay from when the
      event occurred until it was received by the event listener.
      These variables keep track of the list of timestamps and the number of events.
       */
      // Number of events to keep in queue and display on card
      private static final int EVENT_QUEUE_LENGTH = 10;
      // List of timestamps when sensor events occurred
      private float[] mEventDelays = new float[EVENT_QUEUE_LENGTH];
  
      // number of events in event list
      private int mEventLength = 0;
      // pointer to next entry in sensor event list
      private int mEventData = 0;
  
      // Steps counted in current session
      private int mSteps = 0;
      // Value of the step counter sensor when the listener was registered.
      // (Total steps are calculated from this value.)
      private int mCounterSteps = 0;
      // Steps counted by the step counter previously. Used to keep counter consistent across rotation
      // changes
      private int mPreviousCounterSteps = 0;
      // State of the app (STATE_OTHER, STATE_COUNTER or STATE_DETECTOR)
      private int mState = STATE_OTHER;
      // When a listener is registered, the batch sensor delay in microseconds
      private int mMaxDelay = 0;
  
      @Override
      public void onResume() {
          super.onResume();
  
          CardStreamFragment stream = getCardStream();
          if (stream.getVisibleCardCount() < 1) {
              // No cards are visible, started for the first time
              // Prepare all cards and show the intro card.
              initialiseCards();
              showIntroCard();
              // Show the registration card if the hardware is supported, show an error otherwise
              if (isKitkatWithStepSensor()) {
                  showRegisterCard();
              } else {
                  showErrorCard();
              }
          }
      }
  
      @Override
      public void onPause() {
          super.onPause();
          // BEGIN_INCLUDE(onpause)
          // Unregister the listener when the application is paused
          unregisterListeners();
          // END_INCLUDE(onpause)
      }
  
      /**
       * Returns true if this device is supported. It needs to be running Android KitKat (4.4) or
       * higher and has a step counter and step detector sensor.
       * This check is useful when an app provides an alternative implementation or different
       * functionality if the step sensors are not available or this code runs on a platform version
       * below Android KitKat. If this functionality is required, then the minSDK parameter should
       * be specified appropriately in the AndroidManifest.
       *
       * @return True iff the device can run this sample
       */
      private boolean isKitkatWithStepSensor() {
          // BEGIN_INCLUDE(iskitkatsensor)
          // Require at least Android KitKat
          int currentApiVersion = android.os.Build.VERSION.SDK_INT;
          // Check that the device supports the step counter and detector sensors
          PackageManager packageManager = getActivity().getPackageManager();
          return currentApiVersion >= android.os.Build.VERSION_CODES.KITKAT
                  && packageManager.hasSystemFeature(PackageManager.FEATURE_SENSOR_STEP_COUNTER)
                  && packageManager.hasSystemFeature(PackageManager.FEATURE_SENSOR_STEP_DETECTOR);
          // END_INCLUDE(iskitkatsensor)
      }
  
      /**
       * Handles a click on a card action.
       * Registers a SensorEventListener (see {@link #registerEventListener(int, int)}) with the
       * selected delay, dismisses cards and unregisters the listener
       * (see {@link #unregisterListeners()}).
       * Actions are defined when a card is created.
       *
       * @param cardActionId
       * @param cardTag
       */
      @Override
      public void onCardClick(int cardActionId, String cardTag) {
  
          switch (cardActionId) {
              // BEGIN_INCLUDE(onclick)
              // Register Step Counter card
              case ACTION_REGISTER_COUNT_NOBATCHING:
                  registerEventListener(BATCH_LATENCY_0, Sensor.TYPE_STEP_COUNTER);
                  break;
              case ACTION_REGISTER_COUNT_BATCHING_5s:
                  registerEventListener(BATCH_LATENCY_5s, Sensor.TYPE_STEP_COUNTER);
                  break;
              case ACTION_REGISTER_COUNT_BATCHING_10s:
                  registerEventListener(BATCH_LATENCY_10s, Sensor.TYPE_STEP_COUNTER);
                  break;
  
              // Register Step Detector card
              case ACTION_REGISTER_DETECT_NOBATCHING:
                  registerEventListener(BATCH_LATENCY_0, Sensor.TYPE_STEP_DETECTOR);
                  break;
              case ACTION_REGISTER_DETECT_BATCHING_5s:
                  registerEventListener(BATCH_LATENCY_5s, Sensor.TYPE_STEP_DETECTOR);
                  break;
              case ACTION_REGISTER_DETECT_BATCHING_10s:
                  registerEventListener(BATCH_LATENCY_10s, Sensor.TYPE_STEP_DETECTOR);
                  break;
  
              // Unregister card
              case ACTION_UNREGISTER:
                  showRegisterCard();
                  unregisterListeners();
                  // reset the application state when explicitly unregistered
                  mState = STATE_OTHER;
                  break;
              // END_INCLUDE(onclick)
              // Explanation cards
              case ACTION_BATCHING_DESCRIPTION_DISMISS:
                  // permanently remove the batch description card, it will not be shown again
                  getCardStream().removeCard(CARD_BATCHING_DESCRIPTION);
                  break;
              case ACTION_EXPLANATION_DISMISS:
                  // permanently remove the explanation card, it will not be shown again
                  getCardStream().removeCard(CARD_EXPLANATION);
          }
  
          // For register cards, display the counting card
          if (cardTag.equals(CARD_REGISTER_COUNTER) || cardTag.equals(CARD_REGISTER_DETECTOR)) {
              showCountingCards();
          }
      }
  
      /**
       * Register a {@link android.hardware.SensorEventListener} for the sensor and max batch delay.
       * The maximum batch delay specifies the maximum duration in microseconds for which subsequent
       * sensor events can be temporarily stored by the sensor before they are delivered to the
       * registered SensorEventListener. A larger delay allows the system to handle sensor events more
       * efficiently, allowing the system to switch to a lower power state while the sensor is
       * capturing events. Once the max delay is reached, all stored events are delivered to the
       * registered listener. Note that this value only specifies the maximum delay, the listener may
       * receive events quicker. A delay of 0 disables batch mode and registers the listener in
       * continuous mode.
       * The optimium batch delay depends on the application. For example, a delay of 5 seconds or
       * higher may be appropriate for an  application that does not update the UI in real time.
       *
       * @param maxdelay
       * @param sensorType
       */
      private void registerEventListener(int maxdelay, int sensorType) {
          // BEGIN_INCLUDE(register)
  
          // Keep track of state so that the correct sensor type and batch delay can be set up when
          // the app is restored (for example on screen rotation).
          mMaxDelay = maxdelay;
          if (sensorType == Sensor.TYPE_STEP_COUNTER) {
              mState = STATE_COUNTER;
              /*
              Reset the initial step counter value, the first event received by the event listener is
              stored in mCounterSteps and used to calculate the total number of steps taken.
               */
              mCounterSteps = 0;
              Log.i(TAG, "Event listener for step counter sensor registered with a max delay of "
                      + mMaxDelay);
          } else {
              mState = STATE_DETECTOR;
              Log.i(TAG, "Event listener for step detector sensor registered with a max delay of "
                      + mMaxDelay);
          }
  
          // Get the default sensor for the sensor type from the SenorManager
          SensorManager sensorManager =
                  (SensorManager) getActivity().getSystemService(Activity.SENSOR_SERVICE);
          // sensorType is either Sensor.TYPE_STEP_COUNTER or Sensor.TYPE_STEP_DETECTOR
          Sensor sensor = sensorManager.getDefaultSensor(sensorType);
  
          // Register the listener for this sensor in batch mode.
          // If the max delay is 0, events will be delivered in continuous mode without batching.
          final boolean batchMode = sensorManager.registerListener(
                  mListener, sensor, SensorManager.SENSOR_DELAY_NORMAL, maxdelay);
  
          if (!batchMode) {
              // Batch mode could not be enabled, show a warning message and switch to continuous mode
              getCardStream().getCard(CARD_NOBATCHSUPPORT)
                      .setDescription(getString(R.string.warning_nobatching));
              getCardStream().showCard(CARD_NOBATCHSUPPORT);
              Log.w(TAG, "Could not register sensor listener in batch mode, " +
                      "falling back to continuous mode.");
          }
  
          if (maxdelay > 0 && batchMode) {
              // Batch mode was enabled successfully, show a description card
              getCardStream().showCard(CARD_BATCHING_DESCRIPTION);
          }
  
          // Show the explanation card
          getCardStream().showCard(CARD_EXPLANATION);
  
          // END_INCLUDE(register)
  
      }
  
      /**
       * Unregisters the sensor listener if it is registered.
       */
      private void unregisterListeners() {
          // BEGIN_INCLUDE(unregister)
          SensorManager sensorManager =
                  (SensorManager) getActivity().getSystemService(Activity.SENSOR_SERVICE);
          sensorManager.unregisterListener(mListener);
          Log.i(TAG, "Sensor listener unregistered.");
  
          // END_INCLUDE(unregister)
      }
  
      /**
       * Resets the step counter by clearing all counting variables and lists.
       */
      private void resetCounter() {
          // BEGIN_INCLUDE(reset)
          mSteps = 0;
          mCounterSteps = 0;
          mEventLength = 0;
          mEventDelays = new float[EVENT_QUEUE_LENGTH];
          mPreviousCounterSteps = 0;
          // END_INCLUDE(reset)
      }
  
  
      /**
       * Listener that handles step sensor events for step detector and step counter sensors.
       */
      private final SensorEventListener mListener = new SensorEventListener() {
          @Override
          public void onSensorChanged(SensorEvent event) {
              // BEGIN_INCLUDE(sensorevent)
              // store the delay of this event
              recordDelay(event);
              final String delayString = getDelayString();
  
              if (event.sensor.getType() == Sensor.TYPE_STEP_DETECTOR) {
                  // A step detector event is received for each step.
                  // This means we need to count steps ourselves
  
                  mSteps += event.values.length;
  
                  // Update the card with the latest step count
                  getCardStream().getCard(CARD_COUNTING)
                          .setTitle(getString(R.string.counting_title, mSteps))
                          .setDescription(getString(R.string.counting_description,
                                  getString(R.string.sensor_detector), mMaxDelay, delayString));
  
                  Log.i(TAG,
                          "New step detected by STEP_DETECTOR sensor. Total step count: " + mSteps);
  
              } else if (event.sensor.getType() == Sensor.TYPE_STEP_COUNTER) {
  
                  /*
                  A step counter event contains the total number of steps since the listener
                  was first registered. We need to keep track of this initial value to calculate the
                  number of steps taken, as the first value a listener receives is undefined.
                   */
                  if (mCounterSteps < 1) {
                      // initial value
                      mCounterSteps = (int) event.values[0];
                  }
  
                  // Calculate steps taken based on first counter value received.
                  mSteps = (int) event.values[0] - mCounterSteps;
  
                  // Add the number of steps previously taken, otherwise the counter would start at 0.
                  // This is needed to keep the counter consistent across rotation changes.
                  mSteps = mSteps + mPreviousCounterSteps;
  
                  // Update the card with the latest step count
                  getCardStream().getCard(CARD_COUNTING)
                          .setTitle(getString(R.string.counting_title, mSteps))
                          .setDescription(getString(R.string.counting_description,
                                  getString(R.string.sensor_counter), mMaxDelay, delayString));
                  Log.i(TAG, "New step detected by STEP_COUNTER sensor. Total step count: " + mSteps);
                  // END_INCLUDE(sensorevent)
              }
          }
  
          @Override
          public void onAccuracyChanged(Sensor sensor, int accuracy) {
  
          }
      };
  
      /**
       * Records the delay for the event.
       *
       * @param event
       */
      private void recordDelay(SensorEvent event) {
          // Calculate the delay from when event was recorded until it was received here in ms
          // Event timestamp is recorded in us accuracy, but ms accuracy is sufficient here
          mEventDelays[mEventData] = System.currentTimeMillis() - (event.timestamp / 1000000L);
  
          // Increment length counter
          mEventLength = Math.min(EVENT_QUEUE_LENGTH, mEventLength + 1);
          // Move pointer to the next (oldest) location
          mEventData = (mEventData + 1) % EVENT_QUEUE_LENGTH;
      }
  
      private final StringBuffer mDelayStringBuffer = new StringBuffer();
  
      /**
       * Returns a string describing the sensor delays recorded in
       * {@link #recordDelay(android.hardware.SensorEvent)}.
       *
       * @return
       */
      private String getDelayString() {
          // Empty the StringBuffer
          mDelayStringBuffer.setLength(0);
  
          // Loop over all recorded delays and append them to the buffer as a decimal
          for (int i = 0; i < mEventLength; i++) {
              if (i > 0) {
                  mDelayStringBuffer.append(", ");
              }
              final int index = (mEventData + i) % EVENT_QUEUE_LENGTH;
              final float delay = mEventDelays[index] / 1000f; // convert delay from ms into s
              mDelayStringBuffer.append(String.format("%1.1f", delay));
          }
  
          return mDelayStringBuffer.toString();
      }
  
      /**
       * Records the state of the application into the {@link android.os.Bundle}.
       *
       * @param outState
       */
      @Override
      public void onSaveInstanceState(Bundle outState) {
          // BEGIN_INCLUDE(saveinstance)
          super.onSaveInstanceState(outState);
          // Store all variables required to restore the state of the application
          outState.putInt(BUNDLE_LATENCY, mMaxDelay);
          outState.putInt(BUNDLE_STATE, mState);
          outState.putInt(BUNDLE_STEPS, mSteps);
          // END_INCLUDE(saveinstance)
      }
  
      @Override
      public void onActivityCreated(Bundle savedInstanceState) {
          super.onActivityCreated(savedInstanceState);
          // BEGIN_INCLUDE(restore)
          // Fragment is being restored, reinitialise its state with data from the bundle
          if (savedInstanceState != null) {
              resetCounter();
              mSteps = savedInstanceState.getInt(BUNDLE_STEPS);
              mState = savedInstanceState.getInt(BUNDLE_STATE);
              mMaxDelay = savedInstanceState.getInt(BUNDLE_LATENCY);
  
              // Register listeners again if in detector or counter states with restored delay
              if (mState == STATE_DETECTOR) {
                  registerEventListener(mMaxDelay, Sensor.TYPE_STEP_DETECTOR);
              } else if (mState == STATE_COUNTER) {
                  // store the previous number of steps to keep  step counter count consistent
                  mPreviousCounterSteps = mSteps;
                  registerEventListener(mMaxDelay, Sensor.TYPE_STEP_COUNTER);
              }
          }
          // END_INCLUDE(restore)
      }
  
      /**
       * Hides the registration cards, reset the counter and show the step counting card.
       */
      private void showCountingCards() {
          // Hide the registration cards
          getCardStream().hideCard(CARD_REGISTER_DETECTOR);
          getCardStream().hideCard(CARD_REGISTER_COUNTER);
  
          // Show the explanation card if it has not been dismissed
          getCardStream().showCard(CARD_EXPLANATION);
  
          // Reset the step counter, then show the step counting card
          resetCounter();
  
          // Set the inital text for the step counting card before a step is recorded
          String sensor = "-";
          if (mState == STATE_COUNTER) {
              sensor = getString(R.string.sensor_counter);
          } else if (mState == STATE_DETECTOR) {
              sensor = getString(R.string.sensor_detector);
          }
          // Set initial text
          getCardStream().getCard(CARD_COUNTING)
                  .setTitle(getString(R.string.counting_title, 0))
                  .setDescription(getString(R.string.counting_description, sensor, mMaxDelay, "-"));
  
          // Show the counting card and make it undismissable
          getCardStream().showCard(CARD_COUNTING, false);
  
      }
  
      /**
       * Show the introduction card
       */
      private void showIntroCard() {
          Card c = new Card.Builder(this, CARD_INTRO)
                  .setTitle(getString(R.string.intro_title))
                  .setDescription(getString(R.string.intro_message))
                  .build(getActivity());
          getCardStream().addCard(c, true);
      }
  
      /**
       * Show two registration cards, one for the step detector and counter sensors.
       */
      private void showRegisterCard() {
          // Hide the counting and explanation cards
          getCardStream().hideCard(CARD_BATCHING_DESCRIPTION);
          getCardStream().hideCard(CARD_EXPLANATION);
          getCardStream().hideCard(CARD_COUNTING);
  
          // Show two undismissable registration cards, one for each step sensor
          getCardStream().showCard(CARD_REGISTER_DETECTOR, false);
          getCardStream().showCard(CARD_REGISTER_COUNTER, false);
      }
  
      /**
       * Show the error card.
       */
      private void showErrorCard() {
          getCardStream().showCard(CARD_NOBATCHSUPPORT, false);
      }
  
      /**
       * Initialise Cards.
       */
      private void initialiseCards() {
          // Step counting
          Card c = new Card.Builder(this, CARD_COUNTING)
                  .setTitle("Steps")
                  .setDescription("")
                  .addAction("Unregister Listener", ACTION_UNREGISTER, Card.ACTION_NEGATIVE)
                  .build(getActivity());
          getCardStream().addCard(c);
  
          // Register step detector listener
          c = new Card.Builder(this, CARD_REGISTER_DETECTOR)
                  .setTitle(getString(R.string.register_detector_title))
                  .setDescription(getString(R.string.register_detector_description))
                  .addAction(getString(R.string.register_0),
                          ACTION_REGISTER_DETECT_NOBATCHING, Card.ACTION_NEUTRAL)
                  .addAction(getString(R.string.register_5),
                          ACTION_REGISTER_DETECT_BATCHING_5s, Card.ACTION_NEUTRAL)
                  .addAction(getString(R.string.register_10),
                          ACTION_REGISTER_DETECT_BATCHING_10s, Card.ACTION_NEUTRAL)
                  .build(getActivity());
          getCardStream().addCard(c);
  
          // Register step counter listener
          c = new Card.Builder(this, CARD_REGISTER_COUNTER)
                  .setTitle(getString(R.string.register_counter_title))
                  .setDescription(getString(R.string.register_counter_description))
                  .addAction(getString(R.string.register_0),
                          ACTION_REGISTER_COUNT_NOBATCHING, Card.ACTION_NEUTRAL)
                  .addAction(getString(R.string.register_5),
                          ACTION_REGISTER_COUNT_BATCHING_5s, Card.ACTION_NEUTRAL)
                  .addAction(getString(R.string.register_10),
                          ACTION_REGISTER_COUNT_BATCHING_10s, Card.ACTION_NEUTRAL)
                  .build(getActivity());
          getCardStream().addCard(c);
  
  
          // Batching description
          c = new Card.Builder(this, CARD_BATCHING_DESCRIPTION)
                  .setTitle(getString(R.string.batching_queue_title))
                  .setDescription(getString(R.string.batching_queue_description))
                  .addAction(getString(R.string.action_notagain),
                          ACTION_BATCHING_DESCRIPTION_DISMISS, Card.ACTION_POSITIVE)
                  .build(getActivity());
          getCardStream().addCard(c);
  
          // Explanation
          c = new Card.Builder(this, CARD_EXPLANATION)
                  .setDescription(getString(R.string.explanation_description))
                  .addAction(getString(R.string.action_notagain),
                          ACTION_EXPLANATION_DISMISS, Card.ACTION_POSITIVE)
                  .build(getActivity());
          getCardStream().addCard(c);
  
          // Error
          c = new Card.Builder(this, CARD_NOBATCHSUPPORT)
                  .setTitle(getString(R.string.error_title))
                  .setDescription(getString(R.string.error_nosensor))
                  .build(getActivity());
          getCardStream().addCard(c);
      }
  
      /**
       * Returns the cached CardStreamFragment used to show cards.
       *
       * @return
       */
      private CardStreamFragment getCardStream() {
          if (mCards == null) {
              mCards = ((CardStream) getActivity()).getCardStream();
          }
          return mCards;
      }
  
  }
  