1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.mediaframeworktest.functional.camera; 18 19 import com.android.mediaframeworktest.MediaFrameworkTest; 20 import com.android.mediaframeworktest.helpers.CameraTestHelper; 21 22 import java.io.Writer; 23 import java.util.concurrent.Semaphore; 24 import java.util.concurrent.TimeUnit; 25 import java.util.List; 26 27 import android.hardware.Camera.Parameters; 28 import android.os.Handler; 29 import android.os.Looper; 30 import android.test.ActivityInstrumentationTestCase2; 31 import android.test.suitebuilder.annotation.LargeTest; 32 import android.util.Log; 33 import android.view.SurfaceHolder; 34 35 /** 36 * Junit / Instrumentation test case for the following camera APIs: 37 * - flash 38 * - exposure compensation 39 * - white balance 40 * - focus mode 41 * 42 * adb shell am instrument 43 * -e class com.android.mediaframeworktest.functional.camera.CameraFunctionalTest 44 * -w com.android.mediaframework/.CameraStressTestRunner 45 */ 46 public class CameraFunctionalTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> { 47 private static final long WAIT_TIMEOUT = 10 * 1000; // 10 seconds 48 private CameraTestHelper mCameraTestHelper; 49 private Handler mHandler; 50 private Thread mLooperThread; 51 private Writer mOutput; 52 53 private String TAG = "CameraFunctionalTest"; 54 55 public CameraFunctionalTest() { 56 super("com.android.mediaframeworktest", MediaFrameworkTest.class); 57 } 58 59 protected void setUp() throws Exception { 60 final Semaphore sem = new Semaphore(0); 61 mLooperThread = new Thread() { 62 @Override 63 public void run() { 64 Log.v(TAG, "starting looper"); 65 Looper.prepare(); 66 mHandler = new Handler(); 67 sem.release(); 68 Looper.loop(); 69 Log.v(TAG, "quit looper"); 70 } 71 }; 72 mLooperThread.start(); 73 if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) { 74 fail("Failed to start the looper."); 75 } 76 getActivity(); 77 super.setUp(); 78 79 mCameraTestHelper = new CameraTestHelper(); 80 } 81 82 @Override 83 protected void tearDown() throws Exception { 84 if (mHandler != null) { 85 mHandler.getLooper().quit(); 86 mHandler = null; 87 } 88 if (mLooperThread != null) { 89 mLooperThread.join(WAIT_TIMEOUT); 90 if (mLooperThread.isAlive()) { 91 fail("Failed to stop the looper."); 92 } 93 mLooperThread = null; 94 } 95 super.tearDown(); 96 } 97 98 private void runOnLooper(final Runnable command) throws InterruptedException { 99 final Semaphore sem = new Semaphore(0); 100 mHandler.post(new Runnable() { 101 @Override 102 public void run() { 103 try { 104 command.run(); 105 } finally { 106 sem.release(); 107 } 108 } 109 }); 110 if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) { 111 fail("Failed to run the command on the looper."); 112 } 113 } 114 115 /** 116 * Functional test iterating on the range of supported exposure compensation levels 117 */ 118 @LargeTest 119 public void testFunctionalCameraExposureCompensation() throws Exception { 120 try { 121 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 122 Parameters params = mCameraTestHelper.getCameraParameters(); 123 124 int min = params.getMinExposureCompensation(); 125 int max = params.getMaxExposureCompensation(); 126 assertFalse("Adjusting exposure not supported", (max == 0 && min == 0)); 127 float step = params.getExposureCompensationStep(); 128 int stepsPerEV = (int) Math.round(Math.pow((double) step, -1)); 129 130 // only get integer values for exposure compensation 131 for (int i = min; i <= max; i += stepsPerEV) { 132 runOnLooper(new Runnable() { 133 @Override 134 public void run() { 135 mCameraTestHelper.setupCameraTest(); 136 } 137 }); 138 Log.v(TAG, "Setting exposure compensation index to " + i); 139 params.setExposureCompensation(i); 140 mCameraTestHelper.setParameters(params); 141 mCameraTestHelper.startCameraPreview(surfaceHolder); 142 mCameraTestHelper.capturePhoto(); 143 } 144 mCameraTestHelper.cleanupTestImages(); 145 } catch (Exception e) { 146 Log.e(TAG, e.toString()); 147 fail("Camera exposure compensation test Exception"); 148 } 149 } 150 151 /** 152 * Functional test iterating on the various flash modes (on, off, auto, torch) 153 */ 154 @LargeTest 155 public void testFunctionalCameraFlashModes() throws Exception { 156 try { 157 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 158 Parameters params = mCameraTestHelper.getCameraParameters(); 159 List<String> supportedFlashModes = params.getSupportedFlashModes(); 160 assertNotNull("No flash modes supported", supportedFlashModes); 161 162 for (int i = 0; i < supportedFlashModes.size(); i++) { 163 runOnLooper(new Runnable() { 164 @Override 165 public void run() { 166 mCameraTestHelper.setupCameraTest(); 167 } 168 }); 169 Log.v(TAG, "Setting flash mode to " + supportedFlashModes.get(i)); 170 params.setFlashMode(supportedFlashModes.get(i)); 171 mCameraTestHelper.setParameters(params); 172 mCameraTestHelper.startCameraPreview(surfaceHolder); 173 mCameraTestHelper.capturePhoto(); 174 } 175 mCameraTestHelper.cleanupTestImages(); 176 } catch (Exception e) { 177 Log.e(TAG, e.toString()); 178 fail("Camera flash mode test Exception"); 179 } 180 } 181 182 /** 183 * Functional test iterating on the various focus modes (auto, infinitiy, macro, etc.) 184 */ 185 @LargeTest 186 public void testFunctionalCameraFocusModes() throws Exception { 187 try { 188 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 189 Parameters params = mCameraTestHelper.getCameraParameters(); 190 List<String> supportedFocusModes = params.getSupportedFocusModes(); 191 assertNotNull("No focus modes supported", supportedFocusModes); 192 193 for (int i = 0; i < supportedFocusModes.size(); i++) { 194 runOnLooper(new Runnable() { 195 @Override 196 public void run() { 197 mCameraTestHelper.setupCameraTest(); 198 } 199 }); 200 Log.v(TAG, "Setting focus mode to: " + supportedFocusModes.get(i)); 201 params.setFocusMode(supportedFocusModes.get(i)); 202 mCameraTestHelper.setParameters(params); 203 mCameraTestHelper.startCameraPreview(surfaceHolder); 204 mCameraTestHelper.capturePhoto(); 205 } 206 mCameraTestHelper.cleanupTestImages(); 207 } catch (Exception e) { 208 Log.e(TAG, e.toString()); 209 fail("Camera focus modes test Exception"); 210 } 211 } 212 213 /** 214 * Functional test iterating on the various white balances (auto, daylight, cloudy, etc.) 215 */ 216 @LargeTest 217 public void testFunctionalCameraWhiteBalance() throws Exception { 218 try { 219 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 220 Parameters params = mCameraTestHelper.getCameraParameters(); 221 List<String> supportedWhiteBalance = params.getSupportedWhiteBalance(); 222 assertNotNull("No white balance modes supported", supportedWhiteBalance); 223 224 for (int i = 0; i < supportedWhiteBalance.size(); i++) { 225 runOnLooper(new Runnable() { 226 @Override 227 public void run() { 228 mCameraTestHelper.setupCameraTest(); 229 } 230 }); 231 Log.v(TAG, "Setting white balance to: " + supportedWhiteBalance.get(i)); 232 params.setWhiteBalance(supportedWhiteBalance.get(i)); 233 mCameraTestHelper.setParameters(params); 234 mCameraTestHelper.startCameraPreview(surfaceHolder); 235 mCameraTestHelper.capturePhoto(); 236 } 237 mCameraTestHelper.cleanupTestImages(); 238 } catch (Exception e) { 239 Log.e(TAG, e.toString()); 240 fail("Camera focus modes test Exception"); 241 } 242 } 243 } 244
