apps/CtsVerifier/src/com/android/cts/verifier/camera/intents/CameraIntentsActivity.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2012 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.android.cts.verifier.camera.intents;

 import android.app.job.JobInfo;
 import android.app.job.JobParameters;
 import android.app.job.JobScheduler;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.hardware.Camera;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.provider.MediaStore;
 import android.util.Log;
 import android.view.SurfaceHolder;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.Button;
 import android.widget.ImageButton;
 import android.widget.TextView;

 import com.android.cts.verifier.camera.intents.CameraContentJobService;
 import com.android.cts.verifier.PassFailButtons;
 import com.android.cts.verifier.R;
 import com.android.cts.verifier.TestResult;

 import java.util.TreeSet;

 /**
  * Tests for manual verification of uri trigger being fired.
  *
  * MediaStore.Images.Media.EXTERNAL_CONTENT_URI - this should fire
  *  when a new picture was captured by the camera app, and it has been
  *  added to the media store.
  * MediaStore.Video.Media.EXTERNAL_CONTENT_URI - this should fire when a new
  *  video has been captured by the camera app, and it has been added
  *  to the media store.
  *
  * The tests verify this both by asking the user to manually launch
  *  the camera activity, as well as by programatically launching the camera
  *  activity via MediaStore intents.
  *
  * Please ensure when replacing the default camera app on a device,
  *  that these intents are still firing as a lot of 3rd party applications
  *  (e.g. social network apps that upload a photo after you take a picture)
  *  rely on this functionality present and correctly working.
  */
 public class CameraIntentsActivity extends PassFailButtons.Activity
 implements OnClickListener, SurfaceHolder.Callback {

     private static final String TAG = "CameraIntents";
     private static final int STATE_OFF = 0;
     private static final int STATE_STARTED = 1;
     private static final int STATE_SUCCESSFUL = 2;
     private static final int STATE_FAILED = 3;
     private static final int NUM_STAGES = 4;
     private static final String STAGE_INDEX_EXTRA = "stageIndex";

     private static final int STAGE_APP_PICTURE = 0;
     private static final int STAGE_APP_VIDEO = 1;
     private static final int STAGE_INTENT_PICTURE = 2;
     private static final int STAGE_INTENT_VIDEO = 3;

     private ImageButton mPassButton;
     private ImageButton mFailButton;
     private Button mStartTestButton;

     private int mState = STATE_OFF;

     private boolean mActivityResult = false;
     private boolean mDetectCheating = false;

     private StringBuilder mReportBuilder = new StringBuilder();
     private final TreeSet<String> mTestedCombinations = new TreeSet<String>();
     private final TreeSet<String> mUntestedCombinations = new TreeSet<String>();

     private CameraContentJobService.TestEnvironment mTestEnv;
     private static final int CAMERA_JOB_ID = CameraIntentsActivity.class.hashCode();
     private static final int JOB_TYPE_IMAGE = 0;
     private static final int JOB_TYPE_VIDEO = 1;

     private static int[] TEST_JOB_TYPES = new int[] {
         JOB_TYPE_IMAGE,
         JOB_TYPE_VIDEO,
         JOB_TYPE_IMAGE,
         JOB_TYPE_VIDEO
     };

     private JobInfo makeJobInfo(int jobType) {
         JobInfo.Builder builder = new JobInfo.Builder(CAMERA_JOB_ID,
                 new ComponentName(this, CameraContentJobService.class));
         // Look for specific changes to images in the provider.
         Uri uriToTrigger = null;
         switch (jobType) {
             case JOB_TYPE_IMAGE:
                 uriToTrigger = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                 break;
             case JOB_TYPE_VIDEO:
                 uriToTrigger = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                 break;
             default:
                 Log.e(TAG, "Unknown jobType" + jobType);
                 return null;
         }
         builder.addTriggerContentUri(new JobInfo.TriggerContentUri(
                 uriToTrigger,
                 JobInfo.TriggerContentUri.FLAG_NOTIFY_FOR_DESCENDANTS));
         // For testing purposes, react quickly.
         builder.setTriggerContentUpdateDelay(100);
         builder.setTriggerContentMaxDelay(100);
         return builder.build();
     }

     private int getStageIndex()
     {
         final int stageIndex = getIntent().getIntExtra(STAGE_INDEX_EXTRA, 0);
         return stageIndex;
     }

     private String getStageString(int stageIndex)
     {
         if (stageIndex == STAGE_APP_PICTURE) {
             return "Application Picture";
         }
         if (stageIndex == STAGE_APP_VIDEO) {
             return "Application Video";
         }
         if (stageIndex == STAGE_INTENT_PICTURE) {
             return "Intent Picture";
         }
         if (stageIndex == STAGE_INTENT_VIDEO) {
             return "Intent Video";
         }

         return "Unknown!!!";
     }

     private String getStageIntentString(int stageIndex)
     {
         if (stageIndex == STAGE_APP_PICTURE) {
             return android.hardware.Camera.ACTION_NEW_PICTURE;
         }
         if (stageIndex == STAGE_APP_VIDEO) {
             return android.hardware.Camera.ACTION_NEW_VIDEO;
         }
         if (stageIndex == STAGE_INTENT_PICTURE) {
             return android.hardware.Camera.ACTION_NEW_PICTURE;
         }
         if (stageIndex == STAGE_INTENT_VIDEO) {
             return android.hardware.Camera.ACTION_NEW_VIDEO;
         }

         return "Unknown Intent!!!";
     }

     private String getStageInstructionLabel(int stageIndex)
     {
         if (stageIndex == STAGE_APP_PICTURE) {
             return getString(R.string.ci_instruction_text_app_picture_label);
         }
         if (stageIndex == STAGE_APP_VIDEO) {
             return getString(R.string.ci_instruction_text_app_video_label);
         }
         if (stageIndex == STAGE_INTENT_PICTURE) {
             return getString(R.string.ci_instruction_text_intent_picture_label);
         }
         if (stageIndex == STAGE_INTENT_VIDEO) {
             return getString(R.string.ci_instruction_text_intent_video_label);
         }

         return "Unknown Instruction Label!!!";
     }

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         setContentView(R.layout.ci_main);
         setPassFailButtonClickListeners();
         setInfoResources(R.string.camera_intents, R.string.ci_info, -1);

         mPassButton         = (ImageButton) findViewById(R.id.pass_button);
         mFailButton         = (ImageButton) findViewById(R.id.fail_button);
         mStartTestButton  = (Button) findViewById(R.id.start_test_button);
         mStartTestButton.setOnClickListener(this);

         // This activity is reused multiple times
         // to test each camera/intents combination
         final int stageIndex = getIntent().getIntExtra(STAGE_INDEX_EXTRA, 0);

         // Hitting the pass button goes to the next test activity.
         // Only the last one uses the PassFailButtons click callback function,
         // which gracefully terminates the activity.
         if (stageIndex + 1 < NUM_STAGES) {
             setPassButtonGoesToNextStage(stageIndex);
         }
         resetButtons();

         // Set initial values

         TextView intentsLabel =
                 (TextView) findViewById(R.id.intents_text);
         intentsLabel.setText(
                 getString(R.string.ci_intents_label)
                 + " "
                 + Integer.toString(getStageIndex()+1)
                 + " of "
                 + Integer.toString(NUM_STAGES)
                 + ": "
                 + getStageIntentString(getStageIndex())
                 );

         TextView instructionLabel =
                 (TextView) findViewById(R.id.instruction_text);
         instructionLabel.setText(R.string.ci_instruction_text_photo_label);

         /* Display the instructions to launch camera app and take a photo */
         TextView cameraExtraLabel =
                 (TextView) findViewById(R.id.instruction_extra_text);
         cameraExtraLabel.setText(getStageInstructionLabel(getStageIndex()));

         mStartTestButton.setEnabled(true);
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         Log.v(TAG, "onDestroy");
     }

     @Override
     public void onResume() {
         super.onResume();
     }

     @Override
     public void onPause() {
         super.onPause();
         /*
         When testing INTENT_PICTURE, INTENT_VIDEO,
         do not allow user to cheat by going to camera app and re-firing
         the intents by taking a photo/video
         */
         if (getStageIndex() == STAGE_INTENT_PICTURE ||
             getStageIndex() == STAGE_INTENT_VIDEO) {

             if (mActivityResult && mState == STATE_STARTED) {
                 mDetectCheating = true;
                 Log.w(TAG, "Potential cheating detected");
             }
         }

     }

     @Override
     protected void onActivityResult(
         int requestCode, int resultCode, Intent data) {
         if (requestCode == 1337 + getStageIndex()) {
             Log.v(TAG, "Activity we launched was finished");
             mActivityResult = true;

             if (mState != STATE_FAILED
                 && getStageIndex() == STAGE_INTENT_PICTURE) {
                 mPassButton.setEnabled(true);
                 mFailButton.setEnabled(false);

                 mState = STATE_SUCCESSFUL;
                 /* successful, unless we get the URI trigger back
                  at some point later on */
             }
         }
     }

     @Override
     public String getTestDetails() {
         return mReportBuilder.toString();
     }

     private class WaitForTriggerTask extends AsyncTask<Void, Void, Boolean> {
         protected Boolean doInBackground(Void... param) {
             try {
                 boolean executed = mTestEnv.awaitExecution();
                 // Check latest test param
                 if (executed && mState == STATE_STARTED) {

                     // this can happen if..
                     //  the camera apps intent finishes,
                     //  user returns to cts verifier,
                     //  user leaves cts verifier and tries to fake receiver intents
                     if (mDetectCheating) {
                         Log.w(TAG, "Cheating attempt suppressed");
                         mState = STATE_FAILED;
                     }

                     // For STAGE_INTENT_PICTURE test, if EXTRA_OUTPUT is not assigned in intent,
                     // file should NOT be saved so triggering this is a test failure.
                     if (getStageIndex() == STAGE_INTENT_PICTURE) {
                         Log.e(TAG, "FAIL: STAGE_INTENT_PICTURE test should not create file");
                         mState = STATE_FAILED;
                     }

                     if (mState != STATE_FAILED) {
                         mState = STATE_SUCCESSFUL;
                         return true;
                     } else {
                         return false;
                     }
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }

             if (getStageIndex() == STAGE_INTENT_PICTURE) {
                 // STAGE_INTENT_PICTURE should timeout
                 return true;
             } else {
                 Log.e(TAG, "FAIL: timeout waiting for URI trigger");
                 return false;
             }
         }

         protected void onPostExecute(Boolean pass) {
             if (pass) {
                 mPassButton.setEnabled(true);
                 mFailButton.setEnabled(false);
             } else {
                 mPassButton.setEnabled(false);
                 mFailButton.setEnabled(true);
             }
         }
     }

     @Override
     public void onClick(View view) {
         Log.v(TAG, "Click detected");

         final int stageIndex = getStageIndex();

         if (view == mStartTestButton) {
             Log.v(TAG, "Starting testing... ");


             mState = STATE_STARTED;

             JobScheduler jobScheduler = (JobScheduler) getSystemService(
                     Context.JOB_SCHEDULER_SERVICE);
             jobScheduler.cancelAll();

             mTestEnv = CameraContentJobService.TestEnvironment.getTestEnvironment();

             mTestEnv.setUp();

             JobInfo job = makeJobInfo(TEST_JOB_TYPES[stageIndex]);
             jobScheduler.schedule(job);

             new WaitForTriggerTask().execute();

             /* we can allow user to fail immediately */
             mFailButton.setEnabled(true);

             /* trigger an ACTION_IMAGE_CAPTURE intent
                 which will run the camera app itself */
             String intentStr = null;
             Intent cameraIntent = null;
             if (stageIndex == STAGE_INTENT_PICTURE) {
                 intentStr = android.provider.MediaStore.ACTION_IMAGE_CAPTURE;
             }
             else if (stageIndex == STAGE_INTENT_VIDEO) {
                 intentStr = android.provider.MediaStore.ACTION_VIDEO_CAPTURE;
             }

             if (intentStr != null) {
                 cameraIntent = new Intent(intentStr);
                 startActivityForResult(cameraIntent, 1337 + getStageIndex());
             }

             mStartTestButton.setEnabled(false);
         }

         if(view == mPassButton || view == mFailButton) {
             // Stop any running wait
             mTestEnv.cancelWait();

             for (int counter = 0; counter < NUM_STAGES; counter++) {
                 String combination = getStageString(counter) + "\n";

                 if(counter < stageIndex) {
                     // test already passed, or else wouldn't have made
                     // it to current stageIndex
                     mTestedCombinations.add(combination);
                 }

                 if(counter == stageIndex) {
                     // current test configuration
                     if(view == mPassButton) {
                         mTestedCombinations.add(combination);
                     }
                     else if(view == mFailButton) {
                         mUntestedCombinations.add(combination);
                     }
                 }

                 if(counter > stageIndex) {
                     // test not passed yet, since haven't made it to
                     // stageIndex
                     mUntestedCombinations.add(combination);
                 }

                 counter++;
             }

             mReportBuilder = new StringBuilder();
             mReportBuilder.append("Passed combinations:\n");
             for (String combination : mTestedCombinations) {
                 mReportBuilder.append(combination);
             }
             mReportBuilder.append("Failed/untested combinations:\n");
             for (String combination : mUntestedCombinations) {
                 mReportBuilder.append(combination);
             }

             if(view == mPassButton) {
                 TestResult.setPassedResult(this, "CameraIntentsActivity",
                         getTestDetails());
             }
             if(view == mFailButton) {
                 TestResult.setFailedResult(this, "CameraIntentsActivity",
                         getTestDetails());
             }

             // restart activity to test next intents
             Intent intent = new Intent(CameraIntentsActivity.this,
                     CameraIntentsActivity.class);
             intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
                     | Intent.FLAG_ACTIVITY_FORWARD_RESULT);
             intent.putExtra(STAGE_INDEX_EXTRA, stageIndex + 1);
             startActivity(intent);
         }
     }

     private void resetButtons() {
         enablePassFailButtons(false);
     }

     private void enablePassFailButtons(boolean enable) {
         mPassButton.setEnabled(enable);
         mFailButton.setEnabled(enable);
     }

     @Override
     public void surfaceChanged(SurfaceHolder holder, int format, int width,
             int height) {
     }

     @Override
     public void surfaceCreated(SurfaceHolder holder) {
         // Auto-generated method stub
     }

     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         // Auto-generated method stub
     }

     private void setPassButtonGoesToNextStage(final int stageIndex) {
         findViewById(R.id.pass_button).setOnClickListener(this);
     }

 }
	/*
	* Copyright (C) 2012 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.android.cts.verifier.camera.intents;

	import android.app.job.JobInfo;
	import android.app.job.JobParameters;
	import android.app.job.JobScheduler;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.hardware.Camera;
	import android.net.Uri;
	import android.os.AsyncTask;
	import android.os.Bundle;
	import android.provider.MediaStore;
	import android.util.Log;
	import android.view.SurfaceHolder;
	import android.view.View;
	import android.view.View.OnClickListener;
	import android.widget.Button;
	import android.widget.ImageButton;
	import android.widget.TextView;

	import com.android.cts.verifier.camera.intents.CameraContentJobService;
	import com.android.cts.verifier.PassFailButtons;
	import com.android.cts.verifier.R;
	import com.android.cts.verifier.TestResult;

	import java.util.TreeSet;

	/**
	* Tests for manual verification of uri trigger being fired.
	*
	* MediaStore.Images.Media.EXTERNAL_CONTENT_URI - this should fire
	* when a new picture was captured by the camera app, and it has been
	* added to the media store.
	* MediaStore.Video.Media.EXTERNAL_CONTENT_URI - this should fire when a new
	* video has been captured by the camera app, and it has been added
	* to the media store.
	*
	* The tests verify this both by asking the user to manually launch
	* the camera activity, as well as by programatically launching the camera
	* activity via MediaStore intents.
	*
	* Please ensure when replacing the default camera app on a device,
	* that these intents are still firing as a lot of 3rd party applications
	* (e.g. social network apps that upload a photo after you take a picture)
	* rely on this functionality present and correctly working.
	*/
	public class CameraIntentsActivity extends PassFailButtons.Activity
	implements OnClickListener, SurfaceHolder.Callback {

	private static final String TAG = "CameraIntents";
	private static final int STATE_OFF = 0;
	private static final int STATE_STARTED = 1;
	private static final int STATE_SUCCESSFUL = 2;
	private static final int STATE_FAILED = 3;
	private static final int NUM_STAGES = 4;
	private static final String STAGE_INDEX_EXTRA = "stageIndex";

	private static final int STAGE_APP_PICTURE = 0;
	private static final int STAGE_APP_VIDEO = 1;
	private static final int STAGE_INTENT_PICTURE = 2;
	private static final int STAGE_INTENT_VIDEO = 3;

	private ImageButton mPassButton;
	private ImageButton mFailButton;
	private Button mStartTestButton;

	private int mState = STATE_OFF;

	private boolean mActivityResult = false;
	private boolean mDetectCheating = false;

	private StringBuilder mReportBuilder = new StringBuilder();
	private final TreeSet<String> mTestedCombinations = new TreeSet<String>();
	private final TreeSet<String> mUntestedCombinations = new TreeSet<String>();

	private CameraContentJobService.TestEnvironment mTestEnv;
	private static final int CAMERA_JOB_ID = CameraIntentsActivity.class.hashCode();
	private static final int JOB_TYPE_IMAGE = 0;
	private static final int JOB_TYPE_VIDEO = 1;

	private static int[] TEST_JOB_TYPES = new int[] {
	JOB_TYPE_IMAGE,
	JOB_TYPE_VIDEO,
	JOB_TYPE_IMAGE,
	JOB_TYPE_VIDEO
	};

	private JobInfo makeJobInfo(int jobType) {
	JobInfo.Builder builder = new JobInfo.Builder(CAMERA_JOB_ID,
	new ComponentName(this, CameraContentJobService.class));
	// Look for specific changes to images in the provider.
	Uri uriToTrigger = null;
	switch (jobType) {
	case JOB_TYPE_IMAGE:
	uriToTrigger = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
	break;
	case JOB_TYPE_VIDEO:
	uriToTrigger = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
	break;
	default:
	Log.e(TAG, "Unknown jobType" + jobType);
	return null;
	}
	builder.addTriggerContentUri(new JobInfo.TriggerContentUri(
	uriToTrigger,
	JobInfo.TriggerContentUri.FLAG_NOTIFY_FOR_DESCENDANTS));
	// For testing purposes, react quickly.
	builder.setTriggerContentUpdateDelay(100);
	builder.setTriggerContentMaxDelay(100);
	return builder.build();
	}

	private int getStageIndex()
	{
	final int stageIndex = getIntent().getIntExtra(STAGE_INDEX_EXTRA, 0);
	return stageIndex;
	}

	private String getStageString(int stageIndex)
	{
	if (stageIndex == STAGE_APP_PICTURE) {
	return "Application Picture";
	}
	if (stageIndex == STAGE_APP_VIDEO) {
	return "Application Video";
	}
	if (stageIndex == STAGE_INTENT_PICTURE) {
	return "Intent Picture";
	}
	if (stageIndex == STAGE_INTENT_VIDEO) {
	return "Intent Video";
	}

	return "Unknown!!!";
	}

	private String getStageIntentString(int stageIndex)
	{
	if (stageIndex == STAGE_APP_PICTURE) {
	return android.hardware.Camera.ACTION_NEW_PICTURE;
	}
	if (stageIndex == STAGE_APP_VIDEO) {
	return android.hardware.Camera.ACTION_NEW_VIDEO;
	}
	if (stageIndex == STAGE_INTENT_PICTURE) {
	return android.hardware.Camera.ACTION_NEW_PICTURE;
	}
	if (stageIndex == STAGE_INTENT_VIDEO) {
	return android.hardware.Camera.ACTION_NEW_VIDEO;
	}

	return "Unknown Intent!!!";
	}

	private String getStageInstructionLabel(int stageIndex)
	{
	if (stageIndex == STAGE_APP_PICTURE) {
	return getString(R.string.ci_instruction_text_app_picture_label);
	}
	if (stageIndex == STAGE_APP_VIDEO) {
	return getString(R.string.ci_instruction_text_app_video_label);
	}
	if (stageIndex == STAGE_INTENT_PICTURE) {
	return getString(R.string.ci_instruction_text_intent_picture_label);
	}
	if (stageIndex == STAGE_INTENT_VIDEO) {
	return getString(R.string.ci_instruction_text_intent_video_label);
	}

	return "Unknown Instruction Label!!!";
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	setContentView(R.layout.ci_main);
	setPassFailButtonClickListeners();
	setInfoResources(R.string.camera_intents, R.string.ci_info, -1);

	mPassButton = (ImageButton) findViewById(R.id.pass_button);
	mFailButton = (ImageButton) findViewById(R.id.fail_button);
	mStartTestButton = (Button) findViewById(R.id.start_test_button);
	mStartTestButton.setOnClickListener(this);

	// This activity is reused multiple times
	// to test each camera/intents combination
	final int stageIndex = getIntent().getIntExtra(STAGE_INDEX_EXTRA, 0);

	// Hitting the pass button goes to the next test activity.
	// Only the last one uses the PassFailButtons click callback function,
	// which gracefully terminates the activity.
	if (stageIndex + 1 < NUM_STAGES) {
	setPassButtonGoesToNextStage(stageIndex);
	}
	resetButtons();

	// Set initial values

	TextView intentsLabel =
	(TextView) findViewById(R.id.intents_text);
	intentsLabel.setText(
	getString(R.string.ci_intents_label)
	+ " "
	+ Integer.toString(getStageIndex()+1)
	+ " of "
	+ Integer.toString(NUM_STAGES)
	+ ": "
	+ getStageIntentString(getStageIndex())
	);

	TextView instructionLabel =
	(TextView) findViewById(R.id.instruction_text);
	instructionLabel.setText(R.string.ci_instruction_text_photo_label);

	/* Display the instructions to launch camera app and take a photo */
	TextView cameraExtraLabel =
	(TextView) findViewById(R.id.instruction_extra_text);
	cameraExtraLabel.setText(getStageInstructionLabel(getStageIndex()));

	mStartTestButton.setEnabled(true);
	}

	@Override
	public void onDestroy() {
	super.onDestroy();
	Log.v(TAG, "onDestroy");
	}

	@Override
	public void onResume() {
	super.onResume();
	}

	@Override
	public void onPause() {
	super.onPause();
	/*
	When testing INTENT_PICTURE, INTENT_VIDEO,
	do not allow user to cheat by going to camera app and re-firing
	the intents by taking a photo/video
	*/
	if (getStageIndex() == STAGE_INTENT_PICTURE \|\|
	getStageIndex() == STAGE_INTENT_VIDEO) {

	if (mActivityResult && mState == STATE_STARTED) {
	mDetectCheating = true;
	Log.w(TAG, "Potential cheating detected");
	}
	}

	}

	@Override
	protected void onActivityResult(
	int requestCode, int resultCode, Intent data) {
	if (requestCode == 1337 + getStageIndex()) {
	Log.v(TAG, "Activity we launched was finished");
	mActivityResult = true;

	if (mState != STATE_FAILED
	&& getStageIndex() == STAGE_INTENT_PICTURE) {
	mPassButton.setEnabled(true);
	mFailButton.setEnabled(false);

	mState = STATE_SUCCESSFUL;
	/* successful, unless we get the URI trigger back
	at some point later on */
	}
	}
	}

	@Override
	public String getTestDetails() {
	return mReportBuilder.toString();
	}

	private class WaitForTriggerTask extends AsyncTask<Void, Void, Boolean> {
	protected Boolean doInBackground(Void... param) {
	try {
	boolean executed = mTestEnv.awaitExecution();
	// Check latest test param
	if (executed && mState == STATE_STARTED) {

	// this can happen if..
	// the camera apps intent finishes,
	// user returns to cts verifier,
	// user leaves cts verifier and tries to fake receiver intents
	if (mDetectCheating) {
	Log.w(TAG, "Cheating attempt suppressed");
	mState = STATE_FAILED;
	}

	// For STAGE_INTENT_PICTURE test, if EXTRA_OUTPUT is not assigned in intent,
	// file should NOT be saved so triggering this is a test failure.
	if (getStageIndex() == STAGE_INTENT_PICTURE) {
	Log.e(TAG, "FAIL: STAGE_INTENT_PICTURE test should not create file");
	mState = STATE_FAILED;
	}

	if (mState != STATE_FAILED) {
	mState = STATE_SUCCESSFUL;
	return true;
	} else {
	return false;
	}
	}
	} catch (InterruptedException e) {
	e.printStackTrace();
	}

	if (getStageIndex() == STAGE_INTENT_PICTURE) {
	// STAGE_INTENT_PICTURE should timeout
	return true;
	} else {
	Log.e(TAG, "FAIL: timeout waiting for URI trigger");
	return false;
	}
	}

	protected void onPostExecute(Boolean pass) {
	if (pass) {
	mPassButton.setEnabled(true);
	mFailButton.setEnabled(false);
	} else {
	mPassButton.setEnabled(false);
	mFailButton.setEnabled(true);
	}
	}
	}

	@Override
	public void onClick(View view) {
	Log.v(TAG, "Click detected");

	final int stageIndex = getStageIndex();

	if (view == mStartTestButton) {
	Log.v(TAG, "Starting testing... ");


	mState = STATE_STARTED;

	JobScheduler jobScheduler = (JobScheduler) getSystemService(
	Context.JOB_SCHEDULER_SERVICE);
	jobScheduler.cancelAll();

	mTestEnv = CameraContentJobService.TestEnvironment.getTestEnvironment();

	mTestEnv.setUp();

	JobInfo job = makeJobInfo(TEST_JOB_TYPES[stageIndex]);
	jobScheduler.schedule(job);

	new WaitForTriggerTask().execute();

	/* we can allow user to fail immediately */
	mFailButton.setEnabled(true);

	/* trigger an ACTION_IMAGE_CAPTURE intent
	which will run the camera app itself */
	String intentStr = null;
	Intent cameraIntent = null;
	if (stageIndex == STAGE_INTENT_PICTURE) {
	intentStr = android.provider.MediaStore.ACTION_IMAGE_CAPTURE;
	}
	else if (stageIndex == STAGE_INTENT_VIDEO) {
	intentStr = android.provider.MediaStore.ACTION_VIDEO_CAPTURE;
	}

	if (intentStr != null) {
	cameraIntent = new Intent(intentStr);
	startActivityForResult(cameraIntent, 1337 + getStageIndex());
	}

	mStartTestButton.setEnabled(false);
	}

	if(view == mPassButton \|\| view == mFailButton) {
	// Stop any running wait
	mTestEnv.cancelWait();

	for (int counter = 0; counter < NUM_STAGES; counter++) {
	String combination = getStageString(counter) + "\n";

	if(counter < stageIndex) {
	// test already passed, or else wouldn't have made
	// it to current stageIndex
	mTestedCombinations.add(combination);
	}

	if(counter == stageIndex) {
	// current test configuration
	if(view == mPassButton) {
	mTestedCombinations.add(combination);
	}
	else if(view == mFailButton) {
	mUntestedCombinations.add(combination);
	}
	}

	if(counter > stageIndex) {
	// test not passed yet, since haven't made it to
	// stageIndex
	mUntestedCombinations.add(combination);
	}

	counter++;
	}

	mReportBuilder = new StringBuilder();
	mReportBuilder.append("Passed combinations:\n");
	for (String combination : mTestedCombinations) {
	mReportBuilder.append(combination);
	}
	mReportBuilder.append("Failed/untested combinations:\n");
	for (String combination : mUntestedCombinations) {
	mReportBuilder.append(combination);
	}

	if(view == mPassButton) {
	TestResult.setPassedResult(this, "CameraIntentsActivity",
	getTestDetails());
	}
	if(view == mFailButton) {
	TestResult.setFailedResult(this, "CameraIntentsActivity",
	getTestDetails());
	}

	// restart activity to test next intents
	Intent intent = new Intent(CameraIntentsActivity.this,
	CameraIntentsActivity.class);
	intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
	\| Intent.FLAG_ACTIVITY_FORWARD_RESULT);
	intent.putExtra(STAGE_INDEX_EXTRA, stageIndex + 1);
	startActivity(intent);
	}
	}

	private void resetButtons() {
	enablePassFailButtons(false);
	}

	private void enablePassFailButtons(boolean enable) {
	mPassButton.setEnabled(enable);
	mFailButton.setEnabled(enable);
	}

	@Override
	public void surfaceChanged(SurfaceHolder holder, int format, int width,
	int height) {
	}

	@Override
	public void surfaceCreated(SurfaceHolder holder) {
	// Auto-generated method stub
	}

	@Override
	public void surfaceDestroyed(SurfaceHolder holder) {
	// Auto-generated method stub
	}

	private void setPassButtonGoesToNextStage(final int stageIndex) {
	findViewById(R.id.pass_button).setOnClickListener(this);
	}

	}