/** Initializes AR application components. */
  private void initApplicationAR() {
      // Do application initialization in native code (e.g. registering
      // callbacks, etc.):
      initApplicationNative(mScreenWidth, mScreenHeight);

      // Create OpenGL ES view:
      int depthSize = 16;
      int stencilSize = 0;
      boolean translucent = QCAR.requiresAlpha();

      mGlView = new QCARSampleGLView(this);
      mGlView.init(mQCARFlags, translucent, depthSize, stencilSize);

      mRenderer = new cameraDemoRenderer();
      mRenderer.mActivity = this;
      mGlView.setRenderer(mRenderer);

      LayoutInflater inflater = LayoutInflater.from(this);
      mUILayout = (RelativeLayout) inflater.inflate(R.layout.activity_main,
              null, false);

      mUILayout.setVisibility(View.VISIBLE);
      mUILayout.setBackgroundColor(Color.BLACK);

      // Gets a reference to the loading dialog
      mLoadingDialogContainer = mUILayout
              .findViewById(R.id.loading_indicator);

      // Shows the loading indicator at start
      loadingDialogHandler.sendEmptyMessage(SHOW_LOADING_DIALOG);

      // Adds the inflated layout to the view
      addContentView(mUILayout, new LayoutParams(LayoutParams.MATCH_PARENT,
              LayoutParams.MATCH_PARENT));
  }

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initApplicationNative(
                            JNIEnv* env, jobject obj, jint width, jint height)
{
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initApplicationNative");

    // Store screen dimensions
    screenWidth = width;
    screenHeight = height;

    // Handle to the activity class:
    jclass activityClass = env->GetObjectClass(obj);

    jmethodID getTextureCountMethodID = env->GetMethodID(activityClass,
                                                    "getTextureCount", "()I");
    if (getTextureCountMethodID == 0)
    {
        LOG("Function getTextureCount() not found.");
        return;
    }

    textureCount = env->CallIntMethod(obj, getTextureCountMethodID);
    if (!textureCount)
    {
        LOG("getTextureCount() returned zero.");
        return;
    }

    textures = new Texture*[textureCount];

    jmethodID getTextureMethodID = env->GetMethodID(activityClass,
        "getTexture", "(I)Lcom/qualcomm/QCARSamples/ImageTargets/Texture;");

    if (getTextureMethodID == 0)
    {
        LOG("Function getTexture() not found.");
        return;
    }

    // Register the textures
    for (int i = 0; i < textureCount; ++i)
    {

        jobject textureObject = env->CallObjectMethod(obj, getTextureMethodID, i);
        if (textureObject == NULL)
        {
            LOG("GetTexture() returned zero pointer");
            return;
        }

        textures[i] = Texture::create(env, textureObject);
    }
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_initApplicationNative finished");
}

    /** An async task to load the tracker data asynchronously. */
    private class LoadTrackerTask extends AsyncTask<Void, Integer, Boolean>
    {
        protected Boolean doInBackground(Void... params)
        {
            // Prevent the onDestroy() method to overlap:
            synchronized (mShutdownLock)
            {
                // Load the tracker data set:
                return (loadTrackerData() > 0);
            }
        }

        protected void onPostExecute(Boolean result)
        {
            DebugLog.LOGD("LoadTrackerTask::onPostExecute: execution " +
                        (result ? "successful" : "failed"));

            if (result)
            {
                // The stones and chips data set is now active:
                mIsStonesAndChipsDataSetActive = true;

                // Done loading the tracker, update application status:
                updateApplicationStatus(APPSTATUS_INITED);
            }
            else
            {
                // Create dialog box for display error:
                AlertDialog dialogError = new AlertDialog.Builder
                (
                    ImageTargets.this
                ).create();

                dialogError.setButton
                (
                    DialogInterface.BUTTON_POSITIVE,
                    "Close",
                    new DialogInterface.OnClickListener()
                    {
                        public void onClick(DialogInterface dialog, int which)
                        {
                            // Exiting application:
                            System.exit(1);
                        }
                    }
                );

                // Show dialog box with error message:
                dialogError.setMessage("Failed to load tracker data.");
                dialogError.show();
            }
        }
    }

JNIEXPORT int JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_loadTrackerData(JNIEnv *, jobject)
{
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_loadTrackerData");

    // Get the image tracker:
    QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
    QCAR::ImageTracker* imageTracker = static_cast<QCAR::ImageTracker*>(
                    trackerManager.getTracker(QCAR::Tracker::IMAGE_TRACKER));
    if (imageTracker == NULL)
    {
        LOG("Failed to load tracking data set because the ImageTracker has not"
            " been initialized.");
        return 0;
    }

    // Create the data sets:
    dataSetStonesAndChips = imageTracker->createDataSet();
    if (dataSetStonesAndChips == 0)
    {
        LOG("Failed to create a new tracking data.");
        return 0;
    }

    dataSetTarmac = imageTracker->createDataSet();
    if (dataSetTarmac == 0)
    {
        LOG("Failed to create a new tracking data.");
        return 0;
    }

    // Load the data sets:
    if (!dataSetStonesAndChips->load("StonesAndChips.xml", QCAR::DataSet::STORAGE_APPRESOURCE))
    {
        LOG("Failed to load data set.");
        return 0;
    }

    if (!dataSetTarmac->load("Tarmac.xml", QCAR::DataSet::STORAGE_APPRESOURCE))
    //if (!dataSetTarmac->load("FunnyDB.xml", QCAR::DataSet::STORAGE_APPRESOURCE))
    {
        LOG("Failed to load data set.");
        return 0;
    }

    // Activate the data set:
    if (!imageTracker->activateDataSet(dataSetStonesAndChips))
    {
        LOG("Failed to activate data set.");
        return 0;
    }

    LOG("Successfully loaded and activated data set.");
    return 1;
}

QCAR::DataSet* dataSetStonesAndChips    = 0;
QCAR::DataSet* dataSetTarmac            = 0;

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_onQCARInitializedNative(JNIEnv *, jobject)
{
    // Register the update callback where we handle the data set swap:
    QCAR::registerCallback(&updateCallback);

    // Comment in to enable tracking of up to 2 targets simultaneously and
    // split the work over multiple frames:
    // QCAR::setHint(QCAR::HINT_MAX_SIMULTANEOUS_IMAGE_TARGETS, 2);
}

ImageTargets_UpdateCallback updateCallback;

// Object to receive update callbacks from QCAR SDK
class ImageTargets_UpdateCallback : public QCAR::UpdateCallback
{
    virtual void QCAR_onUpdate(QCAR::State& /*state*/)
    {
        if (switchDataSetAsap)
        {
            switchDataSetAsap = false;

            // Get the image tracker:
            QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
            QCAR::ImageTracker* imageTracker = static_cast<QCAR::ImageTracker*>(
                trackerManager.getTracker(QCAR::Tracker::IMAGE_TRACKER));
            if (imageTracker == 0 || dataSetStonesAndChips == 0 || dataSetTarmac == 0 ||
                imageTracker->getActiveDataSet() == 0)
            {
                LOG("Failed to switch data set.");
                return;
            }

            if (imageTracker->getActiveDataSet() == dataSetStonesAndChips)
            {
                imageTracker->deactivateDataSet(dataSetStonesAndChips);
                imageTracker->activateDataSet(dataSetTarmac);
            }
            else
            {
                imageTracker->deactivateDataSet(dataSetTarmac);
                imageTracker->activateDataSet(dataSetStonesAndChips);
            }
        }
    }
};

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_switchDatasetAsap(JNIEnv *, jobject)
{
    switchDataSetAsap = true;
}

JNIEXPORT void JNICALL
Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_startCamera(JNIEnv *,
                                                                         jobject)
{
    LOG("Java_com_qualcomm_QCARSamples_ImageTargets_ImageTargets_startCamera");

    // Select the camera to open, set this to QCAR::CameraDevice::CAMERA_FRONT 
    // to activate the front camera instead.
    QCAR::CameraDevice::CAMERA camera = QCAR::CameraDevice::CAMERA_DEFAULT;

    // Initialize the camera:
    if (!QCAR::CameraDevice::getInstance().init(camera))
        return;

    // Configure the video background
    configureVideoBackground();

    // Select the default mode:
    if (!QCAR::CameraDevice::getInstance().selectVideoMode(
                                QCAR::CameraDevice::MODE_DEFAULT))
        return;

    // Start the camera:
    if (!QCAR::CameraDevice::getInstance().start())
        return;

    // Uncomment to enable flash
    //if(QCAR::CameraDevice::getInstance().setFlashTorchMode(true))
    //   LOG("IMAGE TARGETS : enabled torch");

    // Uncomment to enable infinity focus mode, or any other supported focus mode
    // See CameraDevice.h for supported focus modes
    //if(QCAR::CameraDevice::getInstance().setFocusMode(QCAR::CameraDevice::FOCUS_MODE_INFINITY))
    //   LOG("IMAGE TARGETS : enabled infinity focus");

    // Start the tracker:
    QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
    QCAR::Tracker* imageTracker = trackerManager.getTracker(QCAR::Tracker::IMAGE_TRACKER);
    if(imageTracker != 0)
        imageTracker->start();
}

Enumerator:
CAMERA_DEFAULT: Default camera device. Usually BACK.
CAMERA_BACK   : Rear facing camera.
CAMERA_FRONT  : Front facing camera.

bool QCAR::VideoBackgroundConfig::mEnabled
bool QCAR::VideoBackgroundConfig::mSynchronous
Vec2I QCAR::VideoBackgroundConfig::mPosition
Vec2I QCAR::VideoBackgroundConfig::mSize
VIDEO_BACKGROUND_REFLECTION QCAR::VideoBackgroundConfig::mReflection

MODE_DEFAULT: Default camera mode.
MODE_OPTIMIZE_SPEED: Fast camera mode.
MODE_OPTIMIZE_QUALITY: High-quality camera mode.

void
configureVideoBackground()
{
    // Get the default video mode:
    QCAR::CameraDevice& cameraDevice = QCAR::CameraDevice::getInstance();
    QCAR::VideoMode videoMode = cameraDevice.
                                getVideoMode(QCAR::CameraDevice::MODE_DEFAULT);


    // Configure the video background
    QCAR::VideoBackgroundConfig config;
    config.mEnabled = true;
    config.mSynchronous = true;
    config.mPosition.data[0] = 0.0f;
    config.mPosition.data[1] = 0.0f;

    if (isActivityInPortraitMode)
    {
        //LOG("configureVideoBackground PORTRAIT");
        config.mSize.data[0] = videoMode.mHeight
                                * (screenHeight / (float)videoMode.mWidth);
        config.mSize.data[1] = screenHeight;

        if(config.mSize.data[0] < screenWidth)
        {
            LOG("Correcting rendering background size to handle missmatch between screen and video aspect ratios.");
            config.mSize.data[0] = screenWidth;
            config.mSize.data[1] = screenWidth *
                              (videoMode.mWidth / (float)videoMode.mHeight);
        }
    }
    else
    {
        //LOG("configureVideoBackground LANDSCAPE");
        config.mSize.data[0] = screenWidth;
        config.mSize.data[1] = videoMode.mHeight
                            * (screenWidth / (float)videoMode.mWidth);

        if(config.mSize.data[1] < screenHeight)
        {
            LOG("Correcting rendering background size to handle missmatch between screen and video aspect ratios.");
            config.mSize.data[0] = screenHeight
                                * (videoMode.mWidth / (float)videoMode.mHeight);
            config.mSize.data[1] = screenHeight;
        }
    }

    LOG("Configure Video Background : Video (%d,%d), Screen (%d,%d), mSize (%d,%d)", videoMode.mWidth, videoMode.mHeight, screenWidth, screenHeight, config.mSize.data[0], config.mSize.data[1]);

    // Set the config:
    QCAR::Renderer::getInstance().setVideoBackgroundConfig(config);
}

 /**
  * NOTE: this method is synchronized because of a potential concurrent
  * access by ImageTargets::onResume() and InitQCARTask::onPostExecute().
  */
  private synchronized void updateApplicationStatus(int appStatus) {
      // Exit if there is no change in status:
      if (mAppStatus == appStatus)
          return;

      // Store new status value:
      mAppStatus = appStatus;

      // Execute application state-specific actions:
      switch (mAppStatus) {
      case APPSTATUS_INIT_APP:
          // Initialize application elements that do not rely on QCAR
          // initialization:
          initApplication();

          // Proceed to next application initialization status:
          updateApplicationStatus(APPSTATUS_INIT_QCAR);
          break;

      case APPSTATUS_INIT_QCAR:
          // Initialize QCAR SDK asynchronously to avoid blocking the
          // main (UI) thread.
          //
          // NOTE: This task instance must be created and invoked on the
          // UI thread and it can be executed only once!
          try {
              mInitQCARTask = new InitQCARTask();
              mInitQCARTask.execute();
          } catch (Exception e) {
              DebugLog.LOGE("cameraDemo", "Initializing QCAR SDK failed");
          }
          break;

      case APPSTATUS_INIT_TRACKER:
          // Initialize the ImageTracker:
          if (initTracker() > 0) {
              // Proceed to next application initialization status:
              updateApplicationStatus(APPSTATUS_INIT_APP_AR);
          }
          break;

      case APPSTATUS_INIT_APP_AR:
          // Initialize Augmented Reality-specific application elements
          // that may rely on the fact that the QCAR SDK has been
          // already initialized:
          initApplicationAR();

          // Proceed to next application initialization status:
          updateApplicationStatus(APPSTATUS_LOAD_TRACKER);
          break;

      case APPSTATUS_LOAD_TRACKER:
          // Load the tracking data set:
          //
          // NOTE: This task instance must be created and invoked on the
          // UI thread and it can be executed only once!
          try {
              mLoadTrackerTask = new LoadTrackerTask();
              mLoadTrackerTask.execute();
          } catch (Exception e) {
              DebugLog.LOGE("cameraDemo", "Loading tracking data set failed");
          }
          break;

      case APPSTATUS_INITED:
          // Hint to the virtual machine that it would be a good time to
          // run the garbage collector:
          //
          // NOTE: This is only a hint. There is no guarantee that the
          // garbage collector will actually be run.
          System.gc();

          // Native post initialization:
          onQCARInitializedNative();

          // Activate the renderer:
          mRenderer.mIsActive = true;

          // Now add the GL surface view. It is important
          // that the OpenGL ES surface view gets added
          // BEFORE the camera is started and video
          // background is configured.
          addContentView(mGlView, new LayoutParams(LayoutParams.MATCH_PARENT,
                  LayoutParams.MATCH_PARENT));

          // Sets the UILayout to be drawn in front of the camera
          // mUILayout.bringToFront();

          // Start the camera:
          updateApplicationStatus(APPSTATUS_CAMERA_RUNNING);

          break;

      case APPSTATUS_CAMERA_STOPPED:
          // Call the native function to stop the camera:
          stopCamera();
          break;

      case APPSTATUS_CAMERA_RUNNING:
          // Call the native function to start the camera:
          startCamera();

          // Hides the Loading Dialog
          // loadingDialogHandler.sendEmptyMessage(HIDE_LOADING_DIALOG);

          // Sets the layout background to transparent
          // mUILayout.setBackgroundColor(Color.TRANSPARENT);

          // Set continuous auto-focus if supported by the device,
          // otherwise default back to regular auto-focus mode.
          // This will be activated by a tap to the screen in this
          // application.
          if (!setFocusMode(FOCUS_MODE_CONTINUOUS_AUTO)) {
              mContAutofocus = false;
              setFocusMode(FOCUS_MODE_NORMAL);
          } else {
              mContAutofocus = true;
          }
          break;

      default:
          throw new RuntimeException("Invalid application state");
      }
  }