AampScheduler.h

Go to the documentation of this file.

/*
 * If not stated otherwise in this file or this component's license file the
 * following copyright and licenses apply:
 *
 * Copyright 2020 RDK Management
 *
 * 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.
*/
 
/**
 * @file AampScheduler.h
 * @brief Class to schedule commands for async execution
 */
 
#ifndef __AAMP_SCHEDULER_H__
#define __AAMP_SCHEDULER_H__
 
//#define __UNIT_TESTING__
 
#include <functional>
#include <mutex>
#include <condition_variable>
#include <deque>
#include <thread>
#include <utility>
#include "AampDefine.h"
#include "AampEvent.h"
#ifndef __UNIT_TESTING__
#include "AampConfig.h"
#include "AampLogManager.h"
#else
#include <unistd.h>
#define AAMPLOG_WARN(FORMAT, ...) { printf(FORMAT,##__VA_ARGS__);printf("\n");}
#define AAMPLOG_INFO(FORMAT, ...) { printf(FORMAT,##__VA_ARGS__);printf("\n");}
#define AAMPLOG_ERR(FORMAT, ...)  { printf(FORMAT,##__VA_ARGS__);printf("\n");}
#define AAMPLOG_TRACE(FORMAT, ...)  { printf(FORMAT,##__VA_ARGS__);printf("\n");}
#endif
#define AAMP_SCHEDULER_ID_MAX_VALUE INT_MAX  // 10000
#define AAMP_SCHEDULER_ID_DEFAULT 1             //ID ranges from DEFAULT to MAX
 
 
typedef std::function<void (void *)> AsyncTask;
 
/**
 * @brief Async task operations
 */
struct AsyncTaskObj
{
        AsyncTask mTask;
        void * mData;
        int mId;
        std::string mTaskName;
 
        AsyncTaskObj(AsyncTask task, void *data, std::string tskName="", int id = AAMP_TASK_ID_INVALID) :
                                mTask(task), mData(data), mId(id),mTaskName(tskName)
        {
        }
 
        AsyncTaskObj(const AsyncTaskObj &other) : mTask(other.mTask), mData(other.mData), mId(other.mId),mTaskName(other.mTaskName)
        {
        }
 
        AsyncTaskObj& operator=(const AsyncTaskObj& other)
        {
                mTask = other.mTask;
                mData = other.mData;
                mId = other.mId;
                mTaskName = other.mTaskName;
                return *this;
        }
};
 
/**
 * @brief Scheduler class for asynchronous operations
 */
class AampScheduler
{
public:
        /**
         * @fn AampScheduler
         */
        AampScheduler();
 
        AampScheduler(const AampScheduler&) = delete;
        AampScheduler& operator=(const AampScheduler&) = delete;
        /**
         * @fn ~AampScheduler
         */
        virtual ~AampScheduler();
 
        /**
         * @fn ScheduleTask
         *
         * @param[in] obj - object to be scheduled
         * @return int - scheduled task id
         */
        int ScheduleTask(AsyncTaskObj obj);
 
        /**
         * @fn RemoveAllTasks
         *
         * @return void
         */
        void RemoveAllTasks();
 
        /**
         * @fn RemoveTask
         *
         * @param[in] id - ID of task to be removed
         * @return bool true if removed, false otherwise
         */
        bool RemoveTask(int id);
 
        /**
         * @fn StartScheduler
         *
         * @return void
         */
        void StartScheduler();
 
        /**
         * @fn StopScheduler
         *
         * @return void
         */
        void StopScheduler();
 
        /**
         * @fn SuspendScheduler
         *
         * @return void
         */
        void SuspendScheduler();
 
        /**
         * @fn ResumeScheduler
         *
         * @return void
         */
        void ResumeScheduler();
 
        /**
         * @fn EnableScheduleTask
         *
         * @return void
         */
        void EnableScheduleTask();
        /**
         * @fn SetState
         *
         * @return void
         */
        void SetState(PrivAAMPState sstate);
        /**
         *  @brief Set the logger instance for the Scheduler
         *
         *   @return void
         */   
        void SetLogger(AampLogManager *logObj) { mLogObj = logObj;}
protected:
#ifndef __UNIT_TESTING__
        AampLogManager *mLogObj;
#else
    void *mLogObj;
#endif
 
        /**
         * @fn ExecuteAsyncTask
         *
         * @return void
         */
        void ExecuteAsyncTask();
 
        std::deque<AsyncTaskObj> mTaskQueue;    /**< Queue for storing scheduled tasks */
        std::mutex mQMutex;                     /**< Mutex for accessing mTaskQueue */
        std::condition_variable mQCond;         /**< To notify when a task is queued in mTaskQueue */
        bool mSchedulerRunning;                 /**< Flag denotes if scheduler thread is running */
        std::thread mSchedulerThread;           /**< Scheduler thread */
        std::mutex mExMutex;                    /**< Execution mutex for synchronization */
        std::unique_lock<std::mutex> mExLock;   /**< Lock to be used by SuspendScheduler and ResumeScheduler */
        int mNextTaskId;                        /**< counter that holds ID value of next task to be scheduled */
        int mCurrentTaskId;                     /**< ID of current executed task */
        bool mLockOut;                          /**< flag indicates if the queue is locked out or not */
        PrivAAMPState mState;                   /**< Player State */
};
 
#endif /* __AAMP_SCHEDULER_H__ */