path: root/BenchmarkFramework/app/src/main/java/graphics_benchmarks/graphics/Tester.java

/*
 * Copyright (C) 2010 0xlab - http://0xlab.org/
 *
 * 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 graphics_benchmarks.graphics;

import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.util.Log;

import android.os.SystemClock;

import android.app.Activity;
import android.content.Context;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
import android.graphics.Canvas;
import android.os.*;

import org.linaro.iasenov.benchmarkframework.MainActivity;

import java.lang.reflect.Method;

public abstract class Tester extends Activity {
    private String TAG = "";
    public final static String PACKAGE = "graphics_benchmarks.graphics";
    int mRound;
    int mNow;
    int mIndex;

    protected long mTesterStart = 0;
    protected long mTesterEnd   = 0;

    protected abstract String getTag();
    protected abstract int sleepBeforeStart();
    protected abstract int sleepBetweenRound();
    protected abstract void oneRound();

    protected String mSourceTag = "unknown";
    private boolean mNextRound = true;

    protected boolean mDropTouchEvent     = true;
    protected boolean mDropTrackballEvent = true;

    ProgressDialog progressDialog;

    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        TAG = getTag();

        //Prevent screen off cause this will interrupt the test
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        Intent intent = getIntent();
        if (intent != null) {
            mRound = intent.getIntExtra(MainActivity.GRAPHICS_ROUND, 100);
            //mSourceTag = Case.getSource(intent);
            //mIndex     = Case.getIndex(intent);
        } else {
            mRound = 80;
            mIndex = -1;
        }
        mNow   = mRound;


        progressDialog = new ProgressDialog(this);
        progressDialog.setTitle("Step " + MainActivity.mStep + " From " + MainActivity.mFrom);
        progressDialog.setMessage(MainActivity.mSelectedTxt + " is running please wait...");
        progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        progressDialog.setCanceledOnTouchOutside(false);
        progressDialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));

        progressDialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);

        progressDialog.setButton(DialogInterface.BUTTON_NEGATIVE, "Cancel", new DialogInterface.OnClickListener() {
            // Set a click listener for progress dialog cancel button
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Log.i(TAG, "Cancel");
                Intent output = new Intent();
                setResult(Activity.RESULT_CANCELED, output);

                // dismiss the progress dialog
                progressDialog.dismiss();

                finish();

            }
        });

        progressDialog.show();
    }

    @Override
    protected void onPause() {
        super.onPause();
        interruptTester();
    }

    /* drop the annoying event */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (mDropTouchEvent) {
            return false;
        } else {
            return super.dispatchTouchEvent(ev);
        }
    }

    @Override
    public boolean dispatchTrackballEvent(MotionEvent ev) {
        if (mDropTrackballEvent) {
            return false;
        } else {
            return super.dispatchTouchEvent(ev);
        }
    }

    protected void startTester() {
        TesterThread thread = new TesterThread(sleepBeforeStart(), sleepBetweenRound());
        thread.start();

        /*
        progressDialog = new ProgressDialog(this);
        progressDialog.setTitle("Step " + MainActivity.mStep + " From " + MainActivity.mFrom);
        progressDialog.setMessage(MainActivity.mSelectedTxt + " is running please wait...");
        progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        progressDialog.setCanceledOnTouchOutside(false);
        progressDialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
        progressDialog.show();
        */

    }

    public void interruptTester() {
        mNow = 0;
        finish();
    }

    /**
     * Call this method if you finish your testing.
     *
     * @param start The starting time of testing round
     * @param end The ending time of testing round
     */


    public void finishTester(long start, long end) {

        if(progressDialog !=null){
            progressDialog.dismiss();
        }

        mTesterStart = start;
        mTesterEnd   = end;
        Intent output = new Intent();
        /*
        if (mSourceTag == null || mSourceTag.equals("")) {
            Case.putSource(intent, "unknown");
        } else {
            Case.putSource(intent, mSourceTag);
        }
        */

        //Case.putIndex(intent, mIndex);
        //saveResult(intent);
        output.putExtra(MainActivity.GRAPHICS_ELAPSED_TIME, mTesterEnd - mTesterStart);
        output.putExtra(MainActivity.GRAPHICS_ROUND, mRound);
        setResult(Activity.RESULT_OK, output);


        finish();
    }


    /**
     * Save the benchmarking result into intent
     * If this Case and Tester has their own way to pass benchmarking result
     * just override this method
     *
     * @param intent The intent will return to Case
     */
    /*
    protected boolean saveResult(Intent intent) {
        long elapse = mTesterEnd - mTesterStart;
        Case.putResult(intent, elapse);
        return true;
    }
    */

    public void resetCounter() {
        mNow = mRound;
    }

    public void decreaseCounter() {

        if (mNow == mRound) {
            mTesterStart = SystemClock.uptimeMillis();
        } else if (mNow == 1) {
            mTesterEnd = SystemClock.uptimeMillis();
        }

        mNow = mNow - 1;
        mNextRound = true;
        //Log.i(TAG, "mNow:"+ mNow);
    }

    public boolean isTesterFinished() {
        return (mNow <= 0);
    }



    class TesterThread extends Thread {
        int mSleepingStart;
        int mSleepingTime;
        TesterThread(int sleepStart, int sleepPeriod) {
            mSleepingStart = sleepStart;
            mSleepingTime  = sleepPeriod;
        }

        private void lazyLoop() throws Exception {
            while (!isTesterFinished()) {
                if (mNextRound) {
                    mNextRound = false;
                    oneRound();
                } else {
                    sleep(mSleepingTime);
                    // TODO: 
                    // Benchmarks that calculates frequencies (e.g. fps) should be time,
                    // for example, GL cases should run for a fixed time, and calculate 
                    // # of frames rendered, instead of periodically checking if fixed 
                    // # of frames had been rendered (which can hurt performance).
                }
            }
        }

        private void nervousLoop() throws Exception {
            while (!isTesterFinished()) {
                oneRound();
            }
        }

        private void sleepLoop() throws Exception {
            while (!isTesterFinished()) {
                oneRound();
                sleep(mSleepingTime);
            }
        }

        public void run() {
            try {
                sleep(mSleepingStart);

                long start = SystemClock.uptimeMillis();

                lazyLoop();

                long end = SystemClock.uptimeMillis();
                finishTester(start, end);
            } catch (Exception e) {
                    e.printStackTrace();
            }
        }
    }
}