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.CameraTestHelper; 21 22 import java.io.BufferedWriter; 23 import java.io.File; 24 import java.io.FileWriter; 25 import java.io.IOException; 26 import java.io.Writer; 27 import java.util.concurrent.Semaphore; 28 import java.util.concurrent.TimeUnit; 29 import java.util.HashMap; 30 import java.util.List; 31 import java.util.Map; 32 33 import android.hardware.Camera; 34 import android.hardware.Camera.Parameters; 35 import android.os.Environment; 36 import android.os.Handler; 37 import android.os.Looper; 38 import android.test.ActivityInstrumentationTestCase2; 39 import android.test.suitebuilder.annotation.LargeTest; 40 import android.util.Log; 41 import android.view.SurfaceHolder; 42 import com.android.mediaframeworktest.CameraStressTestRunner; 43 44 import junit.framework.Assert; 45 46 /** 47 * Junit / Instrumentation test case for the following camera APIs: 48 * - flash 49 * - exposure compensation 50 * - white balance 51 * - focus mode 52 * 53 * adb shell am instrument 54 * -e class com.android.mediaframeworktest.functional.camera.CameraFunctionalTest 55 * -w com.android.mediaframework/.CameraStressTestRunner 56 */ 57 public class CameraFunctionalTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> { 58 private static final long WAIT_TIMEOUT = 10 * 1000; // 10 seconds 59 private CameraTestHelper mCameraTestHelper; 60 private Handler mHandler; 61 private Thread mLooperThread; 62 private Writer mOutput; 63 64 private String TAG = "CameraFunctionalTest"; 65 66 public CameraFunctionalTest() { 67 super("com.android.mediaframeworktest", MediaFrameworkTest.class); 68 } 69 70 protected void setUp() throws Exception { 71 final Semaphore sem = new Semaphore(0); 72 mLooperThread = new Thread() { 73 @Override 74 public void run() { 75 Log.v(TAG, "starting looper"); 76 Looper.prepare(); 77 mHandler = new Handler(); 78 sem.release(); 79 Looper.loop(); 80 Log.v(TAG, "quit looper"); 81 } 82 }; 83 mLooperThread.start(); 84 if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) { 85 fail("Failed to start the looper."); 86 } 87 getActivity(); 88 super.setUp(); 89 90 mCameraTestHelper = new CameraTestHelper(); 91 } 92 93 @Override 94 protected void tearDown() throws Exception { 95 if (mHandler != null) { 96 mHandler.getLooper().quit(); 97 mHandler = null; 98 } 99 if (mLooperThread != null) { 100 mLooperThread.join(WAIT_TIMEOUT); 101 if (mLooperThread.isAlive()) { 102 fail("Failed to stop the looper."); 103 } 104 mLooperThread = null; 105 } 106 super.tearDown(); 107 } 108 109 private void runOnLooper(final Runnable command) throws InterruptedException { 110 final Semaphore sem = new Semaphore(0); 111 mHandler.post(new Runnable() { 112 @Override 113 public void run() { 114 try { 115 command.run(); 116 } finally { 117 sem.release(); 118 } 119 } 120 }); 121 if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) { 122 fail("Failed to run the command on the looper."); 123 } 124 } 125 126 /** 127 * Functional test iterating on the range of supported exposure compensation levels 128 */ 129 @LargeTest 130 public void testFunctionalCameraExposureCompensation() throws Exception { 131 try { 132 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 133 Parameters params = mCameraTestHelper.getCameraParameters(); 134 135 int min = params.getMinExposureCompensation(); 136 int max = params.getMaxExposureCompensation(); 137 assertFalse("Adjusting exposure not supported", (max == 0 && min == 0)); 138 float step = params.getExposureCompensationStep(); 139 int stepsPerEV = (int) Math.round(Math.pow((double) step, -1)); 140 141 // only get integer values for exposure compensation 142 for (int i = min; i <= max; i += stepsPerEV) { 143 runOnLooper(new Runnable() { 144 @Override 145 public void run() { 146 mCameraTestHelper.setupCameraTest(); 147 } 148 }); 149 Log.v(TAG, "Setting exposure compensation index to " + i); 150 params.setExposureCompensation(i); 151 mCameraTestHelper.setParameters(params); 152 mCameraTestHelper.startCameraPreview(surfaceHolder); 153 mCameraTestHelper.capturePhoto(); 154 } 155 mCameraTestHelper.cleanupTestImages(); 156 } catch (Exception e) { 157 Log.e(TAG, e.toString()); 158 fail("Camera exposure compensation test Exception"); 159 } 160 } 161 162 /** 163 * Functional test iterating on the various flash modes (on, off, auto, torch) 164 */ 165 @LargeTest 166 public void testFunctionalCameraFlashModes() throws Exception { 167 try { 168 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 169 Parameters params = mCameraTestHelper.getCameraParameters(); 170 List<String> supportedFlashModes = params.getSupportedFlashModes(); 171 assertNotNull("No flash modes supported", supportedFlashModes); 172 173 for (int i = 0; i < supportedFlashModes.size(); i++) { 174 runOnLooper(new Runnable() { 175 @Override 176 public void run() { 177 mCameraTestHelper.setupCameraTest(); 178 } 179 }); 180 Log.v(TAG, "Setting flash mode to " + supportedFlashModes.get(i)); 181 params.setFlashMode(supportedFlashModes.get(i)); 182 mCameraTestHelper.setParameters(params); 183 mCameraTestHelper.startCameraPreview(surfaceHolder); 184 mCameraTestHelper.capturePhoto(); 185 } 186 mCameraTestHelper.cleanupTestImages(); 187 } catch (Exception e) { 188 Log.e(TAG, e.toString()); 189 fail("Camera flash mode test Exception"); 190 } 191 } 192 193 /** 194 * Functional test iterating on the various focus modes (auto, infinitiy, macro, etc.) 195 */ 196 @LargeTest 197 public void testFunctionalCameraFocusModes() throws Exception { 198 try { 199 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 200 Parameters params = mCameraTestHelper.getCameraParameters(); 201 List<String> supportedFocusModes = params.getSupportedFocusModes(); 202 assertNotNull("No focus modes supported", supportedFocusModes); 203 204 for (int i = 0; i < supportedFocusModes.size(); i++) { 205 runOnLooper(new Runnable() { 206 @Override 207 public void run() { 208 mCameraTestHelper.setupCameraTest(); 209 } 210 }); 211 Log.v(TAG, "Setting focus mode to: " + supportedFocusModes.get(i)); 212 params.setFocusMode(supportedFocusModes.get(i)); 213 mCameraTestHelper.setParameters(params); 214 mCameraTestHelper.startCameraPreview(surfaceHolder); 215 mCameraTestHelper.capturePhoto(); 216 } 217 mCameraTestHelper.cleanupTestImages(); 218 } catch (Exception e) { 219 Log.e(TAG, e.toString()); 220 fail("Camera focus modes test Exception"); 221 } 222 } 223 224 /** 225 * Functional test iterating on the various white balances (auto, daylight, cloudy, etc.) 226 */ 227 @LargeTest 228 public void testFunctionalCameraWhiteBalance() throws Exception { 229 try { 230 SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder(); 231 Parameters params = mCameraTestHelper.getCameraParameters(); 232 List<String> supportedWhiteBalance = params.getSupportedWhiteBalance(); 233 assertNotNull("No white balance modes supported", supportedWhiteBalance); 234 235 for (int i = 0; i < supportedWhiteBalance.size(); i++) { 236 runOnLooper(new Runnable() { 237 @Override 238 public void run() { 239 mCameraTestHelper.setupCameraTest(); 240 } 241 }); 242 Log.v(TAG, "Setting white balance to: " + supportedWhiteBalance.get(i)); 243 params.setWhiteBalance(supportedWhiteBalance.get(i)); 244 mCameraTestHelper.setParameters(params); 245 mCameraTestHelper.startCameraPreview(surfaceHolder); 246 mCameraTestHelper.capturePhoto(); 247 } 248 mCameraTestHelper.cleanupTestImages(); 249 } catch (Exception e) { 250 Log.e(TAG, e.toString()); 251 fail("Camera focus modes test Exception"); 252 } 253 } 254 } 255
