/*
 * Copyright (C) 2011 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.analyzer;

import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.ImageFormat;
import android.hardware.Camera;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbManager;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import android.view.SurfaceView;
import android.widget.ImageView;
import android.widget.Toast;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Implements a test to verify whether the Auto Exposure Lock functions as
 * described in the API.
 *
 * The test consists three sub-categories. The first set of tests focus on
 * testing whether the auto exposure lock works in various situations.
 * For all tests in this set, the lock is set during the period when the camera
 * preview is open. In this way the lock locks exposure according to the
 * lighting at the moment of setting the lock. The second set of tests focus on
 * testing whether the auto exposure lock works as expected after turning the
 * preview off and on. The lock is set during the period when the camera
 * preview is turned off. The lock is expected to lock an exposure level
 * identical to the one before the preview is turned off. One special case in
 * this category is to set lock before the preview is turned on for the first
 * time.
 */
public class AutoLockTest extends CameraTests {

    private static final String TAG = "AutoLockTest";
    /** USB permission to connect to ADK. */
    private static final String ACTION_USB_PERMISSION = "com.android.cts.verifier.USB_PERMISSION";
    /** Defines a long sleep period.*/
    private static final int SHORT_SLEEP = 2000;
    /** Defines a short sleep period. */
    private static final int LONG_SLEEP = 4000;

    /** Test results in text format. */
    private String mDebugText = new String();
    /** Detailed report. */
    private String mResultText = new String();
    /** Thread lock of the camera callbacks. */
    private final Object mProcessingImage = new Object();
    /** Memory address of the native test handler. */
    private long mTestHandler;
    /** Array storing the reference test results. */
    private ArrayList<Boolean> mReferenceCompareResults;
    /** Array storing the reference test scenario logs. */
    private ArrayList<String> mReferenceLogs;
    /** Number of tests so far. */
    private int mTestCount;

    /** Usb Manager of the USB connections. */
    private UsbManager mUsbManager;
    /** Intent for getting the permission to access the ADK. */
    private PendingIntent mPermissionIntent;
    /** Boolean to represent whether a permission is gained. */
    private boolean mPermissionRequestPending;
    /** USB accessory pointing to the ADK. */
    private UsbAccessory mAccessory;
    /** File descriptor of the USB communication port. */
    private ParcelFileDescriptor mFileDescriptor;
    /** Output stream to write commands for ADK to. */
    private FileOutputStream mOutputStream;

    /** Pointer to the CameraAnalyzerActivity activity. */
    private CameraAnalyzerActivity mActivity;
    /** Boolean to tell whether the accessory is opened. */
    private boolean mSetupReady;
    /** Thread lock for setting up the usb. */
    private final Object mUsbSetup = new Object();
    /** Boolean to indicate whether there is an ADK attached. */
    private boolean mUsingUsb = false;
    /** Test results.*/
    private int[] mTestResults;
    /** Number of tests. */
    private int mNumTests;
    /** Singleton test instance.*/
    private static AutoLockTest singletonTest = null;

    /**
     * Receives the notice of whether the connection to ADK is granted or
     * denied.
     */
    private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            Log.v(TAG, String.format("Received USB broadcast with action %s ", action));

            if (ACTION_USB_PERMISSION.equals(action)) {
                synchronized (this) {
                    UsbAccessory accessory =
                        (UsbAccessory) intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);

                    if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                        // Grants the permission to connect to the ADK.
                        Log.v(TAG, "Open accessory 3");
                        openAccessory(accessory);
                        // Overwrites the old camera instsance with the one currently opened
                        // by the CameraAnalyzerActivity instance, since the permission
                        // dialogue pauses the CameraAnalyzerActivity and forces the camera to
                        // be released and reopened when the dialogue disappears.
                        mTestCamera = mActivity.getCameraInstance();
                    } else {
                        // Denies the permission to connect to the ADK.
                        Log.d(TAG, "permission denied for accessory " + accessory);
                    }
                    // Marks that the permission request has been processed.
                    mPermissionRequestPending = false;
                }
            } else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) {
                // Invokes when the USB is detached.
                // Closes the accessory if it has not been closed.
                Log.v(TAG, "Usb device detached");
                mUsingUsb = false;
                UsbAccessory accessory =
                    (UsbAccessory) intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
                if (accessory != null && accessory.equals(mAccessory)) {
                    closeAccessory();
                }
            }
        }
    };

    /**
     * Opens the ADK from USB and attaches the output stream with it.
     *
     * Notifies the tread lock that the USB setup is ready.
     */
    private void openAccessory(UsbAccessory accessory) {
        Log.d(TAG, "openAccessory: " + accessory);
        mFileDescriptor = mUsbManager.openAccessory(accessory);

        if (mFileDescriptor != null) {
            mAccessory = accessory;
            FileDescriptor fd = mFileDescriptor.getFileDescriptor();
            mOutputStream = new FileOutputStream(fd);
            Log.d(TAG, "accessory opened");
        } else {
            Log.d(TAG, "accessory open fail");
        }

        // Unlocks the thread lock of waiting for the USB to be ready.
        synchronized (mUsbSetup) {
            mSetupReady = true;
            Log.v(TAG, "Setup ready");
            mUsbSetup.notifyAll();
        }
    }

    /**
     * Closes the ADK and detaches the output stream from it.
     */
    private void closeAccessory() {
        try {
            if (mFileDescriptor != null) {
                mFileDescriptor.close();
            }
        } catch (IOException e) {
        } finally {
            mFileDescriptor = null;
            mAccessory = null;
        }
    }

    /**
     * Constructs the AutoLockTest class, which can execute a series of tests
     * to verify whether the device's Auto Exposure Lock is working properly.
     *
     * The test uses the LED lights on an ADK device as light source to change
     * the lighting condition of the environment. The usb connection to the
     * ADK board is established in the constructor.
     *
     * @param hostActivity pointer to the <code>CameraAnalyzerActivity</code>
     * that instructs the Auto Lock Test
     * @param mCamera pointer to the current camera instance
     */
    private AutoLockTest(){
        super();
    }

    public static synchronized AutoLockTest getSingletonTest() {
        if (singletonTest == null) {
            Log.v(TAG, "Creating a new AutoLockTest instance");
            singletonTest = new AutoLockTest();
            singletonTest.initializeTest();
        }
        return singletonTest;
    }

    private void initializeTest() {
        // Creates a native test handler with a 120x160 pixel debug output
        mTestHandler = createAutoLockTest();
        mReferenceCompareResults = new ArrayList<Boolean>();
        mReferenceLogs = new ArrayList<String>();
        mNumTests = 4;
        mTestResults = new int[mNumTests];
        for (int i = 0; i < mNumTests; ++i) {
            mTestResults[i] = CameraTests.CAMERA_TEST_NOT_RUN;
        }
    }

    public void updateCamera() {}

    public void setActivity(CameraAnalyzerActivity hostActivity){
        if (mUsingUsb) {
            closeConnection();
        }

        mActivity = hostActivity;

        mSetupReady = false;

        Log.v(TAG, "Start to test ADK connection");
        // Starts to establish the connection to the ADK board.
        mUsbManager = (UsbManager) mActivity.getSystemService(Context.USB_SERVICE);
        mPermissionIntent = PendingIntent.getBroadcast(mActivity, 0,
                                                       new Intent(ACTION_USB_PERMISSION), 0);
        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
        filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
        filter.addAction(UsbManager.ACTION_USB_ACCESSORY_ATTACHED);
        mActivity.registerReceiver(mUsbReceiver, filter);

        if (mActivity.getLastNonConfigurationInstance() != null) {
            mAccessory = (UsbAccessory) mActivity.getLastNonConfigurationInstance();
            Log.v(TAG, "Open acceossory 1");
            openAccessory(mAccessory);
        }

        // Skips the permission listener if the user already grants the ADK
        // permission previously in the app.
        UsbAccessory[] accessories = mUsbManager.getAccessoryList();
        UsbAccessory accessory = (accessories == null ? null : accessories[0]);
        if (accessory != null) {
            if (mUsbManager.hasPermission(accessory)) {
                Log.v(TAG, "Open accessory 2");
                openAccessory(accessory);
            } else {
                synchronized (mUsbReceiver) {
                    if (!mPermissionRequestPending) {
                        mUsbManager.requestPermission(accessory, mPermissionIntent);
                        mPermissionRequestPending = true;
                    }
                }
            }
            mUsingUsb = true;
        } else {
            Log.d(TAG, "accessory is null");
            mUsingUsb = false;
        }

    }

    /**
     * Closes the accessories and unregister the USB listener at the end of
     * tests.
     */
    public void closeConnection() {
        closeAccessory();
        mActivity.unregisterReceiver(mUsbReceiver);
    }

    protected void finalize ()  {
        if (mUsingUsb) {
            closeConnection();
        }
    }

    /**
     * Runs the Auto Lock tests. A total of 19 tests have been coded and
     * included. Developers can freely comment out tests not interested. In
     * the release version, all tests will be executed.
     */
    @Override
    public synchronized void run(int index){
        if (index == 0) {
            for (int i = 1; i < mNumTests; ++i) {
                run(i);
            }
            return;
        }

        Log.v(TAG, "AutoLockTest thread started!");

        if (mUsingUsb && (!mSetupReady)) {
            // USB connection is not set up. Locks thread and wait.
            Log.v(TAG, "Setup not ready, waiting");
            synchronized (mUsbSetup) {
                try{
                    Log.v(TAG, "Start waiting for Image");
                    mUsbSetup.wait();
                } catch (InterruptedException e) {
                    Log.v(TAG, "Callback wait fails!");
                }
            }
        }

        // Restarts the camera intance and attach the preview to the corrent
        // UI elements.
        restartCamera();
        startPreview();

        mTestCount = 0;
        switch (index) {
            case 1:
                Log.v(TAG, "SP -> TP1 -> SP -> +1 -> Lock -> -1 -> TP2");
                test0();
                Log.v(TAG, "SP -> TP1 -> SP -> Lock -> +1 -> TP2 -> -1");
                test1();
                Log.v(TAG, "SP -> Lock -> +1 -> TP1 -> SP -> -1 -> Lock -> TP2");
                test2();
                Log.v(TAG, "SP -> Lock -> +1 -> TP1 -> SP -> Lock -> -1 -> TP2");
                test3();
                break;
            case 2:
                Log.v(TAG, "SP -> +1 -> TP1 -> -1 -> Lock -> SP -> TP2");
                test4();
                Log.v(TAG, "SP -> +1 -> TP1 -> Lock -> SP -> -1 -> TP2");
                test5();
                Log.v(TAG, "SP -> TP1 -> +1 -> Lock -> SP -> -1 -> TP2");
                test6();
                Log.v(TAG, "SP -> TP1 -> +1 -> Lock -> SP -> TP2");
                test7();
                Log.v(TAG, "SP -> TP1 -> Lock -> SP -> +1 -> TP2");
                test8();
                Log.v(TAG, "SP -> +1 -> Lock -> -1 -> TP1 -> Lock -> SP -> TP2");
                test9();
                Log.v(TAG, "SP -> +1 -> Lock -> TP1 -> -1 -> Lock -> SP -> TP2");
                test10();
                Log.v(TAG, "SP -> Lock -> TP1 -> +1 -> Lock -> SP -> -1 -> TP2");
                test11();
                break;
            case 3:
                Log.v(TAG, "Restart -> Lock -> SP -> TP1 -> Restart -> Lock -> SP -> +1 -> TP2");
                test12();
                Log.v(TAG, "Restart -> Lock -> SP -> +1 -> TP1 -> -1 -> Lock -> SP -> TP2");
                test13();
                Log.v(TAG, "Restart -> Lock -> SP -> +1 -> TP1 -> Lock -> SP -> -1 -> TP2");
                test14();
                Log.v(TAG, "Restart -> Lock -> SP -> TP1 -> +1 -> Lock -> SP -> -1 -> TP2");
                test15();
                Log.v(TAG, "Restart -> Lock -> SP -> TP1 -> +1 -> Lock -> SP -> TP2");
                test16();
                Log.v(TAG, "Restart -> Lock -> SP -> TP1 -> Lock -> SP -> +1 -> TP2");
                test17();
                Log.v(TAG, "Restart -> Lock -> SP -> TP1 -> Lock -> SP -> TP2");
                test18();
                break;
            default:
                break;
        }

        releaseLock();

        Log.v(TAG, "Ready to process data");
        boolean[] testCompareResults = new boolean[2 * mTestCount];

        // Processes the data stored in the native test handler instance.
        // Stores the test results into a boolean array.
        processAutoLockTest(mTestHandler, testCompareResults);

        // Prepares the test result text output with the booelan result array.
        prepareDebugText(testCompareResults, index);
        mReferenceCompareResults.clear();
        mReferenceLogs.clear();
    }

    /**
     * Compares two images taken under the same lighting, Image 1 without AE
     * lock and Image 2 with AE locked under a bright light. Image 1 is
     * expected to be brighter than Image 2.
     * Tests whether AE lock works compared to no AE lock.
     */
    private void test0() {
        releaseLock();
        takePicture();
        startPreview();
        turnOnLight();
        setLock();
        turnOffLight();
        takePicture();
        startPreview();
        releaseLock();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Same lighting condition with one different lock");
        ++mTestCount;
    }

    /**
     * Compares two images taken under different lighting, Image 1 without AE
     * lock and Image 2 with with AE locked under the same light Image 1 is
     * taken. Image 2 is taken under a bright light. Image 1 is expected to be
     * darker than Image 2.
     * Tests whether AE lock works compared to no AE lock.
     */
    private void test1() {
        releaseLock();
        takePicture();
        startPreview();
        setLock();
        turnOnLight();
        takePicture();
        turnOffLight();
        startPreview();
        releaseLock();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("One same lock with different lighting");
        ++mTestCount;
    }

    /**
     * Compares two images taken under different light, both with AE locked
     * under the same lighting. Image 1 is taken under a brighter light.
     * Image 1 is expected to be brighter than Image 2.
     * Tests whether AE locks the exposure to the same level in the same
     * lighting condition after preview restarts.
     */
     private void test2() {
        releaseLock();
        setLock();
        turnOnLight();
        takePicture();
        startPreview();
        turnOffLight();
        setLock();
        takePicture();
        startPreview();
        releaseLock();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Same locking locations with different lighting");
        ++mTestCount;
    }

    /**
     * Compares two images taken under different light, Image 1 with AE locked
     * under normal light and Image 2 with AE locked under a bright light.
     * Image 1 is taken under a bright light and Image 2 is taken in the normal
     * lighting. Image 1 is expected to be brighter than Image 2.
     * Tests whether AE lock can adjust to change of lighting conditions.
     */
    private void test3() {
        releaseLock();
        setLock();
        turnOnLight();
        takePicture();
        startPreview();
        setLock();
        turnOffLight();
        takePicture();
        startPreview();
        releaseLock();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Different locking locations with different lighting");
        ++mTestCount;
    }

    /**
     * Compares two images taken under different lighting, Image 1 without
     * AE lock and Image 2 with AE lock set before camera preview resumes.
     * Image 1 is taken under a bright light and the light is turned off before
     * camera preview starts again. Image 1 is expected to be brighter than
     * Image 2.
     * Tests whether setting AE lock between camera preview stops and restarts
     * can retain the exposure level of the previous AE-unlocked photo.
     */
    private void test4() {
        releaseLock();
        turnOnLight();
        takePicture();
        turnOffLight();
        setLock();
        startPreview();
        takePicture();
        startPreview();
        releaseLock();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after takePicture and light change, before preview");
        ++mTestCount;
    }

    /**
     * Compares two images taken under different lighting, Image 1 without
     * AE lock and Image 2 with AE lock set before camera preview resumes.
     * Image 1 is taken under a bright light and the light is turned off after
     * preview restars but before Image 2 is taken. Image 1 is expected to be
     * brighter than Image 2.
     * Tests whether setting AE lock between camera preview stops and restarts
     * can retain the exposure level of the previous AE-unlocked photo.
     */
    private void test5() {
        releaseLock();
        turnOnLight();
        takePicture();
        setLock();
        startPreview();
        turnOffLight();
        takePicture();
        startPreview();
        releaseLock();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock between takePicture and light change, w/o light change");
        ++mTestCount;
    }

    private void test6() {
        releaseLock();
        takePicture();
        turnOnLight();
        setLock();
        startPreview();
        turnOffLight();
        takePicture();
        startPreview();
        releaseLock();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(true);
        mReferenceLogs.add("Lock after takePicture and light change, before preview.");
        ++mTestCount;
    }

    private void test7() {
        releaseLock();
        takePicture();
        turnOnLight();
        setLock();
        startPreview();
        takePicture();
        startPreview();
        releaseLock();
        turnOffLight();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after takePicture and light change, before preview.");
        ++mTestCount;
    }

    private void test8() {
        releaseLock();
        takePicture();
        setLock();
        startPreview();
        turnOnLight();
        takePicture();
        startPreview();
        releaseLock();
        turnOffLight();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after takePicture and before startPreview.");
        ++mTestCount;
    }

    private void test9() {
        releaseLock();
        turnOnLight();
        setLock();
        turnOffLight();
        takePicture();
        setLock();
        startPreview();
        takePicture();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(true);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test10() {
        releaseLock();
        turnOnLight();
        setLock();
        takePicture();
        turnOffLight();
        setLock();
        startPreview();
        takePicture();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test11() {
        releaseLock();
        setLock();
        takePicture();
        turnOnLight();
        setLock();
        startPreview();
        turnOffLight();
        takePicture();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(true);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test12() {
        //"Restart -> Lock -> SP -> TP1 -> Restart -> Lock -> SP -> +1 -> TP2"
        restartCamera();
        setLock();
        startPreview();
        takePicture();
        releaseLock();
        restartCamera();
        setLock();
        startPreview();
        turnOnLight();
        takePicture();
        releaseLock();
        turnOffLight();
        startPreview();
        //mTestCamera.release();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock before first preview");
        ++mTestCount;
    }

    private void test13() {
        //"Restart -> Lock -> SP -> +1 -> TP1 -> -1 -> Lock -> SP -> TP2"
        restartCamera();
        setLock();
        startPreview();
        turnOnLight();
        takePicture();
        turnOffLight();
        setLock();
        startPreview();
        takePicture();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test14() {
        //"Restart -> Lock -> SP -> +1 -> TP1 -> Lock -> SP -> -1 -> TP2"
        restartCamera();
        setLock();
        startPreview();
        turnOnLight();
        takePicture();
        setLock();
        startPreview();
        turnOffLight();
        takePicture();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(true);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test15() {
        //"Restart -> Lock -> SP -> TP1 -> +1 -> Lock -> SP -> -1 -> TP2"
         restartCamera();
        setLock();
        startPreview();
        takePicture();
        turnOnLight();
        setLock();
        startPreview();
        turnOffLight();
        takePicture();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(true);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test16() {
        //"Restart -> Lock -> SP -> TP1 -> +1 -> Lock -> SP -> TP2"
        restartCamera();
        setLock();
        startPreview();
        takePicture();
        turnOnLight();
        setLock();
        startPreview();
        takePicture();
        turnOffLight();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test17() {
        //"Restart -> Lock -> SP -> TP1 -> Lock -> SP -> +1 -> TP2"
        restartCamera();
        setLock();
        startPreview();
        takePicture();
        setLock();
        startPreview();
        turnOnLight();
        takePicture();
        turnOffLight();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(false);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    private void test18() {
        //"Restart -> Lock -> SP -> TP1 -> Lock -> SP -> TP2"
        restartCamera();
        setLock();
        startPreview();
        takePicture();
        setLock();
        startPreview();
        takePicture();
        releaseLock();
        startPreview();
        mReferenceCompareResults.add(false);
        mReferenceCompareResults.add(true);
        mReferenceLogs.add("Lock after first lock with changing light");
        ++mTestCount;
    }

    /**
     * Restarts the camera by releasing the current instance and get a new
     * instance. Also connects this new camera instance's preview to the proper
     * UI surfaceview.
     */
    private void restartCamera() {
        Log.v(TAG, "Restarting Camera");

        mTestCamera.release();
        Log.v(TAG, "Camera released");

        try {
            mTestCamera = Camera.open(mActivity.getCameraIdx());
        } catch (RuntimeException e) {
            throw new RuntimeException("Failed to open the camera", e);
        }

        Camera.Parameters params = mTestCamera.getParameters();
        params.setPictureFormat(ImageFormat.JPEG);
        params.setPictureSize(640, 480);
        mTestCamera.setParameters(params);

        try {
            mTestCamera.setPreviewDisplay(super.getCameraView().getHolder());
        } catch (IOException e) {
            throw new RuntimeException("Unable to connect camera to display: " + e);
        }
    }

    /**
     * Starts Camera preview with a delay of 2 seconds to let it adjust to
     * the lighting condition.
     */
    private void startPreview() {
        mTestCamera.startPreview();
        try{
            Log.v(TAG, "Waiting");
            Thread.sleep(2000);
            Log.v(TAG, "END Waiting");
        } catch (InterruptedException e){}
    }

    /**
     * Sends command to ADK to turn on all the LED lights to white.
     * Waits for 4 seconds for the camera to adjust to the new lighting.
     */
    private void turnOnLight() {
        Log.v(TAG, "Turn on light");
        if (mUsingUsb) {
            byte[] buffer = new byte[3];

            buffer[0] = (byte) 3;
            buffer[1] = (byte) 0;
            buffer[2] = (byte) 1;
            if (mOutputStream != null && buffer[1] != -1) {
                try {
                    mOutputStream.write(buffer);
                } catch (IOException e) {
                    Log.e(TAG, "write failed", e);
                }
            }
        } else {
            mActivity.runOnUiThread(new Runnable() {
                public void run() {
                    Toast.makeText(mActivity.getApplicationContext(), "Turn on light!", 4).show();

                }
            });
        }

        try{
            Log.v(TAG, "Waiting, Please Turn on light");
            Thread.sleep(LONG_SLEEP);
            Log.v(TAG, "END Waiting");
        } catch (InterruptedException e){}
    }

    /**
     * Sends command to ADK to turn off all LED lights.
     * Waits for 4 seconds for the camera to adjust to the new lighting.
     */
    private void turnOffLight() {
        Log.v(TAG, "Turn off light");
        if (mUsingUsb) {
            byte[] buffer = new byte[3];

            buffer[0] = (byte) 3;
            buffer[1] = (byte) 0;
            buffer[2] = (byte) 0;
            if (mOutputStream != null && buffer[1] != -1) {
                try {
                    mOutputStream.write(buffer);
                } catch (IOException e) {
                    Log.e(TAG, "write failed", e);
                }
            }
        } else {
            mActivity.runOnUiThread(new Runnable() {
                public void run() {
                    Toast.makeText(mActivity.getApplicationContext(), "Turn off light!", 4).show();

                }
            });
        }

        try{
            Log.v(TAG, "Waiting, Please Turn off light");
            Thread.sleep(LONG_SLEEP);
            Log.v(TAG, "END Waiting");
        } catch (InterruptedException e){}
    }

    /**
     * Sets the Auto Exposure Lock.
     * Waits for 2 seonds for the lock to function.
     */
    private void setLock() {
        Camera.Parameters params = mTestCamera.getParameters();

        params.setAutoExposureLock(true);
        params.setAutoWhiteBalanceLock(true);
        mTestCamera.setParameters(params);
        try{
            Log.v(TAG, "Waiting to set lock");
            Thread.sleep(2000);
            Log.v(TAG, "END Waiting");
        } catch (InterruptedException e){}
    }

    /**
     * Releases the Auto Exposure Lock.
     * Waits for 4 seconds afterwards for the Auto Exposure to be adjusted
     * to the lighting condition.
     */
    private void releaseLock() {
        Camera.Parameters params = mTestCamera.getParameters();

        params.setAutoExposureLock(false);
        params.setAutoWhiteBalanceLock(false);
        mTestCamera.setParameters(params);
        try{
            Log.v(TAG, "Waiting to release lock");
            Thread.sleep(LONG_SLEEP);
            Log.v(TAG, "END Waiting");
        } catch (InterruptedException e){}

    }

    /**
     * Takes a picture and locks thread until the picture callback finishes.
     */
    private void takePicture(){
        mTestCamera.takePicture(null, null, null, mTestJpegListener);

        synchronized (mProcessingImage) {
            try{
                Log.v(TAG, "Start waiting for Image");
              //  System.gc();
                mProcessingImage.wait();
            } catch (InterruptedException e){
                 Log.v(TAG, "Callback wait fails!");
            }
        }
    }

    /**
     * Prepare for the result to be shown in the UI. The result for each single
     * test is shown in green if it matches the reference result. It is shown
     * in red otherwise.
     */
    private void prepareDebugText(boolean[] testCompareResults, int index) {
        boolean groupTestPassed = true;
         for (int i = 0; i < mTestCount; ++i) {
              String testLog;
              boolean testPassed = true;
              testLog = mReferenceLogs.get(i);
              mDebugText += (testLog + "<br/>");

              if (testCompareResults[i * 2] == mReferenceCompareResults.get(i * 2)) {
                  mDebugText += String.format(
                      "Picture 1 brighter than Picture 2 is %b \n",
                      testCompareResults[i * 2]);
              } else {
                  mDebugText += String.format(
                      "Picture 1 brighter than Picture 2 is %b \n",
                      testCompareResults[i * 2]);
                  testPassed = false;
              }

              if (testCompareResults[i * 2 + 1] == mReferenceCompareResults.get(i * 2 + 1)) {
                  mDebugText += String.format(
                      "Picture 1 is equivalent to Picture 2 is %b \n",
                      testCompareResults[i * 2 + 1]);
              } else {
                  mDebugText += String.format(
                      "Picture 1 is equivalent to Picture 2 is %b \n",
                      testCompareResults[i * 2 + 1]);
                  testPassed = false;
              }

              if (testPassed) {
                  mDebugText += "Test passed! \n";
              } else {
                  mDebugText += "Test failed! \n";
                  groupTestPassed = false;
              }
         }
        if (groupTestPassed) {
            mTestResults[index] = CameraTests.CAMERA_TEST_SUCCESS;
        } else {
            mTestResults[index] = CameraTests.CAMERA_TEST_FAILURE;
        }
    }

    /**
     * Clears the debug text so that new test results can be added.
     */
    public void clearDebugText() {
        mDebugText = "";
    }

    @Override
    public String getDebugText() {
        return mDebugText;
    }

    @Override
    public String getResultText() {
        return mDebugText;
    }

    @Override
    public String getTestName() {
        return "Auto Exposure Lock test: \n";
    }

    @Override
    public String getTestName(int index) {
        switch (index) {
            case 0:
                return "Run all tests";
            case 1:
                return "Compulsory tests";
            case 2:
                return "Recommended tests (preview behavior)";
            case 3:
                return "Optional tests (default lock)";
            default:
                return "";
        }
    }

    @Override
    public int getResult(int index) {
        return mTestResults[index];
    }

    @Override
    public int getNumTests() {
        return mNumTests;
    }

    private Camera.PictureCallback mTestJpegListener = new Camera.PictureCallback() {
        public void onPictureTaken(byte[] data, Camera mCamera) {
            Log.v(TAG, "Shutter pressed down!");
            Bitmap inputImage;

            // Decodes the camera input data into Bitmap.
            // Constructs a native image class with the image.
            inputImage = BitmapFactory.decodeByteArray(data, 0, data.length);
            long bufferAddress = findNative(inputImage);
            Log.v(TAG, "findNative method finishes");

            // Cleans up memory taken by the Bitmap.
            data = null;
            inputImage.recycle();
            inputImage = null;
            System.gc();

            // Passes data from the native image class to the native
            // test handler.
            createAutoLockClass(bufferAddress, mTestHandler,
                                getCheckerCenter(), getCheckerRadius());

            // Unlocks the thread lock.
            synchronized (mProcessingImage) {
                mProcessingImage.notifyAll();
            }
        }
    };

    private native long createAutoLockTest();

    private native void createAutoLockClass(long bufferAddress, long handlerAddress,
                                            long checkerCenterAddress,
                                            long checkerRadiusAddress);

    private native void processAutoLockTest(long handlerAddress, boolean[] testCompareResults);

    static {
        System.loadLibrary("cameraanalyzer");
    }
}