@Override
  protected void onCreate(Bundle savedInstanceState) {
      DebugLog.LOGD("cameraDemo", "cameraDemo::onCreate");
      super.onCreate(savedInstanceState);
      // Load any sample specific textures:
      // mTextures = new Vector<Texture>();
      // loadTextures();
      // Query the QCAR initialization flags:
      mQCARFlags = getInitializationFlags();
      // Creates the GestureDetector listener for processing double tap
      // mGestureDetector = new GestureDetector(this, new GestureListener());
      // Update the application status to start initializing application:
      updateApplicationStatus(APPSTATUS_INIT_APP);
  }

 /** Configure QCAR with the desired version of OpenGL ES. */
  private int getInitializationFlags() {
      int flags = 0;

      // Query the native code:
      if (getOpenGlEsVersionNative() == 1) {
          flags = QCAR.GL_11;
      } else {
          flags = QCAR.GL_20;
      }

      return flags;
  }

// Application status constants:
private static final int APPSTATUS_UNINITED = -1;
private static final int APPSTATUS_INIT_APP = 0;
private static final int APPSTATUS_INIT_QCAR = 1;
private static final int APPSTATUS_INIT_TRACKER = 2;
private static final int APPSTATUS_INIT_APP_AR = 3;
private static final int APPSTATUS_LOAD_TRACKER = 4;
private static final int APPSTATUS_INITED = 5;
private static final int APPSTATUS_CAMERA_STOPPED = 6;
private static final int APPSTATUS_CAMERA_RUNNING = 7;

 /** Initialize application GUI elements that are not related to AR. */
  private void initApplication() {
      // Set the screen orientation:
      // NOTE: Use SCREEN_ORIENTATION_LANDSCAPE or SCREEN_ORIENTATION_PORTRAIT
      // to lock the screen orientation for this activity.
      int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR;

      // This is necessary for enabling AutoRotation in the Augmented View
      if (screenOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR) {
          // NOTE: We use reflection here to see if the current platform
          // supports the full sensor mode (available only on Gingerbread
          // and above.
          try {
              // SCREEN_ORIENTATION_FULL_SENSOR is required to allow all
              // 4 screen rotations if API level >= 9:
              Field fullSensorField = ActivityInfo.class
                      .getField("SCREEN_ORIENTATION_FULL_SENSOR");
              screenOrientation = fullSensorField.getInt(null);
          } catch (NoSuchFieldException e) {
              // App is running on API level < 9, do nothing.
          } catch (Exception e) {
              e.printStackTrace();
          }
      }

      // Apply screen orientation
      setRequestedOrientation(screenOrientation);

      updateActivityOrientation();

      // Query display dimensions:
      storeScreenDimensions();

      // As long as this window is visible to the user, keep the device's
      // screen turned on and bright:
      getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
              WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  }

 /** An async task to initialize QCAR asynchronously. */
  private class InitQCARTask extends AsyncTask<Void, Integer, Boolean> {
      // Initialize with invalid value:
      private int mProgressValue = -1;

      protected Boolean doInBackground(Void... params) {
          // Prevent the onDestroy() method to overlap with initialization:
          synchronized (mShutdownLock) {
              QCAR.setInitParameters(cameraDemo.this, mQCARFlags);

              do {
                  // QCAR.init() blocks until an initialization step is
                  // complete, then it proceeds to the next step and reports
                  // progress in percents (0 ... 100%).
                  // If QCAR.init() returns -1, it indicates an error.
                  // Initialization is done when progress has reached 100%.
                  mProgressValue = QCAR.init();

                  // Publish the progress value:
                  publishProgress(mProgressValue);

                  // We check whether the task has been canceled in the
                  // meantime (by calling AsyncTask.cancel(true)).
                  // and bail out if it has, thus stopping this thread.
                  // This is necessary as the AsyncTask will run to completion
                  // regardless of the status of the component that
                  // started is.
              } while (!isCancelled() && mProgressValue >= 0
                      && mProgressValue < 100);

              return (mProgressValue > 0);
          }
      }

      protected void onProgressUpdate(Integer... values) {
          // Do something with the progress value "values[0]", e.g. update
          // splash screen, progress bar, etc.
      }

      protected void onPostExecute(Boolean result) {
          // Done initializing QCAR, proceed to next application
          // initialization status:
          if (result) {
              DebugLog.LOGD("cameraDemo",
                      "InitQCARTask::onPostExecute: QCAR "
                              + "initialization successful");

              updateApplicationStatus(APPSTATUS_INIT_TRACKER);
          } else {
              // Create dialog box for display error:
              AlertDialog dialogError = new AlertDialog.Builder(
                      cameraDemo.this).create();

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

              String logMessage;

              // NOTE: Check if initialization failed because the device is
              // not supported. At this point the user should be informed
              // with a message.
              if (mProgressValue == QCAR.INIT_DEVICE_NOT_SUPPORTED) {
                  logMessage = "Failed to initialize QCAR because this "
                          + "device is not supported.";
              } else {
                  logMessage = "Failed to initialize QCAR.";
              }

              // Log error:
              DebugLog.LOGE("cameraDemo", "InitQCARTask::onPostExecute: "
                      + logMessage + " Exiting.");

              // Show dialog box with error message:
              dialogError.setMessage(logMessage);
              dialogError.show();
          }
      }
  }
  

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

    // Initialize the image tracker:
    QCAR::TrackerManager& trackerManager = QCAR::TrackerManager::getInstance();
    QCAR::Tracker* tracker = trackerManager.initTracker(QCAR::Tracker::IMAGE_TRACKER);
    if (tracker == NULL)
    {
        LOG("Failed to initialize ImageTracker.");
        return 0;
    }

    LOG("Successfully initialized ImageTracker.");
    return 1;
}

Instance：An instanceis an object created from a class. The class describes the (behavior and information)structure of the instance, while the current state of the instance is defined by the operations performed on the instance.

 /**
  * 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");
      }
  }