suite/audio_quality/lib/src/task/TaskSequential.cpp

/*
 * 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.
 */
#include <stdlib.h>
#include <algorithm>
#include "Log.h"
#include "StringUtil.h"
#include "task/TaskSequential.h"
#include "task/TaskCase.h"
#include "task/TaskAsync.h"

TaskSequential::TaskSequential()
    : TaskGeneric(TaskGeneric::ETaskSequential),
      mRepeatCount(1),
      mRepeatIndex(-1)
{

}

TaskSequential::~TaskSequential()
{

}


TaskGeneric::ExecutionResult TaskSequential::run()
{
    mRepeatIndex = -1;
    bool storeIndex = (mIndexName.length() == 0 ? false: true);
    if (storeIndex && !getTestCase()->registerIndex(mIndexName, mRepeatIndex)) {
        if (!getTestCase()->updateIndex(mIndexName, mRepeatIndex)) {
            LOGE("register/update of index %s failed", mIndexName.string());
            return TaskGeneric::EResultError;
        }
    }

    TaskGeneric::ExecutionResult firstError(TaskGeneric::EResultOK);

    for (mRepeatIndex = 0; mRepeatIndex < mRepeatCount; mRepeatIndex++) {
        LOGI("  TaskSequential index %s loop %d-th", mIndexName.string(), mRepeatIndex);
        if (storeIndex && !getTestCase()->updateIndex(mIndexName, mRepeatIndex)) {
            return TaskGeneric::EResultError;
        }
        std::list<TaskGeneric*>::iterator i = getChildren().begin();
        std::list<TaskGeneric*>::iterator end = getChildren().end();
        for (; i != end; i++) {
            TaskGeneric* child = *i;
            TaskGeneric::ExecutionResult result = child->run();
            if ((result != TaskGeneric::EResultOK) && (firstError == TaskGeneric::EResultOK)) {
                firstError = result;
                break;
            }
        }
        TaskGeneric::ExecutionResult result = runAsyncTasksQueued();
        if ((result != TaskGeneric::EResultOK) && (firstError == TaskGeneric::EResultOK)) {
                    firstError = result;
        }
        switch (firstError) {
        case TaskGeneric::EResultOK:
        case TaskGeneric::EResultContinue:
            // continue at the last index should be treated as OK
            firstError = TaskGeneric::EResultOK;
            break; // continue for loop
        case TaskGeneric:: EResultBreakOneLoop:
            return TaskGeneric::EResultOK;
        case TaskGeneric::EResultError:
        case TaskGeneric::EResultFail:
        case TaskGeneric::EResultPass:
            mRepeatIndex = mRepeatCount; //exit for loop
            break;
        }
    }
    // update to the loop exit value
    if (storeIndex && !getTestCase()->updateIndex(mIndexName, mRepeatIndex)) {
        return TaskGeneric::EResultError;
    }
    return firstError;
}

bool TaskSequential::queueAsyncTask(TaskAsync* task)
{
    std::list<TaskAsync*>::iterator it;
    it = std::find(mAsyncTasks.begin(), mAsyncTasks.end(), task);
    if (it != mAsyncTasks.end()) { // already queued
        return true;
    }
    mAsyncTasks.push_back(task);
    return true;
}

TaskGeneric::ExecutionResult TaskSequential::runAsyncTasksQueued()
{
    std::list<TaskAsync*>::iterator i = mAsyncTasks.begin();
    std::list<TaskAsync*>::iterator end = mAsyncTasks.end();
    TaskGeneric::ExecutionResult firstError(TaskGeneric::EResultOK);

    for (; i != end; i++) {
        TaskAsync* child = *i;
        TaskGeneric::ExecutionResult result = child->complete();
        if ((result != TaskGeneric::EResultOK) && (firstError == TaskGeneric::EResultOK)) {
            firstError = result;
        }
    }
    mAsyncTasks.clear();
    return firstError;
}


bool TaskSequential::parseAttribute(const android::String8& name, const android::String8& value)
{
    if (StringUtil::compare(name, "repeat") == 0) {
        mRepeatCount = atoi(value.string());
        if (mRepeatCount <= 0) {
            LOGE("TaskSequential::parseAttribute invalid value %s for key %s",
                    value.string(), name.string());
            return false;
        }
        return true;
    } else if (StringUtil::compare(name, "index") == 0) {
        mIndexName.append(value);
        LOGD("TaskSequential::parseAttribute index %s", mIndexName.string());
        return true;
    } else {
        return false;
    }
}