IMeetingPollingHelper.h

Go to the documentation of this file.

 
#ifndef ZRC_IMEETINGPOLLINGHELPER_H
#define ZRC_IMEETINGPOLLINGHELPER_H
 
#include "ZRCSDKTypes.h"
 
NS_ZRCSDK_BEG
 
enum PollingStatus
{
    PollingStatusNotStart = 0,    
    PollingStatusOpen,            
    PollingStatusClosed,          
    PollingStatusShareResult,     
};
 
enum PollingRoleType
{
    PollingRoleTypeUnknown = 0,    
    PollingRoleTypeHost,           
    PollingRoleTypePanelist,       
    PollingRoleTypeAttendee,       
};
 
enum PollingType
{
    PollingTypeUnknown = 0,    
    PollingTypeBasic,          
    PollingTypeAdvanced,       
    PollingTypeQuiz,           
};
 
enum PollingQuestionType
{
    PollingQuestionTypeUnknown = 0,    
    PollingQuestionTypeSingle,         
    PollingQuestionTypeMulti,          
    PollingQuestionTypeMatching,       
    PollingQuestionTypeRankOrder,      
    PollingQuestionTypeShortAnswer,    
    PollingQuestionTypeLongAnswer,     
    PollingQuestionTypeFillBlank,      
    PollingQuestionTypeRatingScale,    
    PollingQuestionTypeDropDown,       
};
 
enum PollingActionType
{
    PollingActionTypeFetch = 0,    
    PollingActionTypeStart,        
    PollingActionTypeClose,        
    PollingActionTypeSubmit,       
    PollingActionTypeShare,        
    PollingActionTypeStopShare,    
    PollingActionTypeError,        
    PollingActionTypeReopen        
};
 
enum PollingDisplayType
{
    PollingDisplayTypeInvalid = -1,    
    PollingDisplayTypeMainView = 0,    
    PollingDisplayTypeImage,           
    PollingDisplayTypeAnswers          
};
 
enum PollingOptionType
{
    PollingOptionTypeAllowRandomOrder = 0,    
    PollingOptionTypeShowQuestionOneByOne,    
    PollingOptionTypeShowAnswerToAll,         
    PollingOptionTypeAllowPanelistVote        
};
 
struct PollingOption
{
    PollingOptionType type = PollingOptionTypeAllowRandomOrder;    
    bool              isAllow = false;                             
};
 
struct PollingAnswer
{
    std::string answerID;         
    std::string answerContent;    
 
    std::string textAnswer;            
    bool        isSelected = false;    
    int32_t     selectedCount = 0;     
};
 
struct PollingQuestionInfo
{
    std::string         questionID;                                   
    PollingQuestionType questionType = PollingQuestionTypeUnknown;    
    bool                isRequired = false;                           
    std::string         questionContent;                              
    int32_t             questionReplyCount = 0;                       
    std::string         imageURL;                                     
    std::string         imageContent;                                 
    int32_t             questionIndex = -1;                           
    std::string         questionSequence;           
    int32_t             minCharacters = 0;          
    int32_t             maxCharacters = 0;          
    bool                isCaseSensitive = false;    
 
    std::vector<PollingQuestionInfo> subQuestions;    
    std::vector<PollingAnswer>       answers;         
    std::vector<PollingAnswer>       rightAnswers;    
};
 
struct PollingInfo
{
    std::string                      pollingId;                                  
    std::string                      pollingName;                                
    PollingType                      pollingType = PollingTypeUnknown;           
    PollingStatus                    pollingStatus = PollingStatusNotStart;      
    PollingStatus                    myPollingStatus = PollingStatusNotStart;    
    bool                             isAnonymous = false;                        
    int32_t                          totalVotedCount = 0;                        
    int32_t                          votableUserCount = 0;                       
    uint64_t                         elapsedTime = 0;                            
    int32_t                          questionCount = 0;                          
    std::vector<PollingQuestionInfo> questions;                                  
};
 
struct PollingUserAction
{
    PollingActionType actionType = PollingActionTypeFetch;        
    int32_t           result = 0;                                 
    std::string       pollingID;                                  
    PollingStatus     pollingStatus = PollingStatusNotStart;      
    PollingStatus     myPollingStatus = PollingStatusNotStart;    
    std::string       errorMessage;                               
    int32_t           unanswerQuestionIndex = -1;                 
};
 
struct PollingDisplayOnZRInfo
{
    bool               isShowOnZROption = false;            
    bool               isShowOnInChargeZRC = false;         
    PollingDisplayType type = PollingDisplayTypeInvalid;    
    std::string        pollingID;                           
    std::string        questionID;                          
    int32_t            questionIndex = -1;                  
};
 
struct PollingBasicInfo
{
    PollingRoleType          roleType = PollingRoleTypeUnknown;    
    bool                     isPollingButtonVisible = false;       
    bool                     isPollSessionInactive = false;        
    bool                     isInChargeDevice = false;    
    PollingInfo              detailPolling;               
    std::vector<PollingInfo> pollings;                    
    bool                     isShowOnZrOption = false;    
    bool                     isInRandomOrder = false;     
    bool                     isShowCorrectAnswerToAll = false;    
    bool                     isAllowPanelistVote = false;         
    bool                     isShowQuestionOneByOne = false;      
    bool                     isShowPollOverlay = false;           
};
 
class IMeetingPollingHelperSink
{
public:
    virtual ~IMeetingPollingHelperSink() {}
 
    virtual void OnUpdatePollingBasicInfo(const PollingBasicInfo& basicInfo) = 0;
 
    virtual void OnUpdateDetailPollingInfo(const PollingInfo& detailPolling) = 0;
 
    virtual void OnPollingStatusChange(const PollingInfo& polling, PollingRoleType roleType, const std::string& deviceID) = 0;
 
    virtual void OnPollingDocReceived(const PollingInfo& detailPolling, const std::vector<PollingInfo>& pollings, bool isPollingButtonVisible) = 0;
 
    virtual void OnPollingResultUpdated(const PollingInfo& polling) = 0;
 
    virtual void OnPollingActionNotification(const PollingUserAction& userAction) = 0;
 
    virtual void OnTakeInChargeNotification(bool isSelfIncharge) = 0;
 
    virtual void OnPollingDisplayOnZRNotification(bool enable) = 0;
 
    virtual void OnPollingIsShowPollOverlay(bool isShow) = 0;
 
    virtual void OnPollingRoleChanged(PollingRoleType roleType, bool isPollingButtonVisible) = 0;
 
    virtual void OnPollingSessionInactiveNotification(bool isInactive) = 0;
 
    virtual void OnPollingOptionsUpdated(const std::vector<PollingOption>& pollingOptions) = 0;
 
    virtual void OnPollingAnswerUpdated(const PollingQuestionInfo& question) = 0;
 
    virtual void OnDownloadingFinished(const std::string& localFilePath, uint32_t result) = 0;
};
 
class IMeetingPollingHelper
{
public:
    virtual ~IMeetingPollingHelper() {}
 
    virtual ZRCSDKError RegisterSink(IMeetingPollingHelperSink* pSink) = 0;
 
    virtual ZRCSDKError DeregisterSink(IMeetingPollingHelperSink* pSink) = 0;
 
    virtual ZRCSDKError GetPollingDetail(const std::string& pollingID) = 0;
 
    virtual ZRCSDKError OperatePolling(PollingActionType actionType, const std::string& pollingID) = 0;
 
    virtual ZRCSDKError SyncAnswer(const PollingQuestionInfo& question) = 0;
 
    virtual ZRCSDKError UpdatePollingOption(const PollingOption& option) = 0;
 
    virtual ZRCSDKError TakeInChargePolling() = 0;
 
    virtual ZRCSDKError IsSelfInChargePolling(bool& inCharge) = 0;
 
    virtual ZRCSDKError GetMyPollingRoleType(PollingRoleType& myRole) = 0;
 
    virtual ZRCSDKError UpdateDisplayOnZRInfo(const PollingDisplayOnZRInfo& option) = 0;
 
    virtual ZRCSDKError EnableShowPollOverlay(bool enable, const std::string& pollingID, const std::string& questionID, int32_t questionIndex) = 0;
 
    virtual ZRCSDKError ShowPollOverlay(bool show, const std::string& pollingID, const std::string& questionID, int32_t questionIndex) = 0;
 
    virtual ZRCSDKError DownloadQuestionImage(const std::string& imageUrl, const std::string& localFilePath) = 0;
};
 
NS_ZRCSDK_END
 
#endif    //ZRC_IMEETINGPOLLINGHELPER_H