socialtypes.h

Go to the documentation of this file.

/********************************************************************************************
* Twitch Broadcasting SDK
*
* This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
* may not be copied or used except in accordance with the terms of that agreement
* Copyright (c) 2012-2016 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/social/socialerrortypes.h"
#include "twitchsdk/core/types/coretypes.h"
#include "twitchsdk/core/coreutilities.h"


namespace ttv
{
    namespace social
    {
        struct FeatureFlags
        {
            FeatureFlags();
            
            static FeatureFlags All();
            static FeatureFlags None();
            
            bool friendList : 1;
            bool friendRequests : 1;
            bool presence : 1;
        };
        
        
        enum class PresenceUserAvailability
        {
            Offline,
            Online,
            Away,
            Busy
        };
        
        
        enum class PresenceSessionAvailability
        {
            Offline,
            Online,
            Idle
        };
        
        
        struct PresenceSettings
        {
            PresenceSettings();
            
            bool operator==(const PresenceSettings& rhs);
            bool operator!=(const PresenceSettings& rhs);
            
            enum class AvailabilityOverride
            {
                None,
                Offline,
                Away,
                Busy
            };
            
            AvailabilityOverride availabilityOverride;
            
            bool shareActivity : 1;
        };
        
        
        using PresenceActivityToken = uint32_t;
        
        
        struct PresenceActivity
        {
            enum class Type
            {
                Broadcasting,
                Watching,
                Playing,
                Unknown
            };
            
            virtual Type GetType() const = 0;
            
            virtual std::unique_ptr<PresenceActivity> Clone() const = 0;
        };
        
        
        struct BroadcastingActivity : public Cloneable<PresenceActivity, BroadcastingActivity>
        {
            BroadcastingActivity();
            
            std::string channelLogin;           
            std::string channelDisplayName;     
            std::string gameName;               
            
            ChannelId channelId;                
            GameId gameId;                      
            
            virtual Type GetType() const override
            {
                return Type::Broadcasting;
            }
        };
        
        
        struct WatchingActivity : public Cloneable<PresenceActivity, WatchingActivity>
        {
            WatchingActivity();
            
            std::string channelLogin;               
            std::string channelDisplayName;         
            
            std::string hostedChannelLogin;         
            std::string hostedChannelDisplayName;   
            
            std::string gameName;                   
            
            ChannelId channelId;                    
            ChannelId hostedChannelId;              
            GameId gameId;                          
            
            virtual Type GetType() const override
            {
                return Type::Watching;
            }
        };
        
        
        struct PlayingActivity : public Cloneable<PresenceActivity, PlayingActivity>
        {
            PlayingActivity();
            
            std::string gameName;               
            std::string gameDisplayContext;     
            
            GameId gameId;                      
            
            virtual Type GetType() const override
            {
                return Type::Playing;
            }
        };
        
        
        struct PresenceStatus
        {
            PresenceStatus();
            PresenceStatus(const PresenceStatus& source);
            PresenceStatus& operator=(const PresenceStatus& source);
            
            std::unique_ptr<PresenceActivity> activity; 
            PresenceUserAvailability availability;      
            Timestamp lastUpdate;                       
        };
        
        
        enum class FriendAction
        {
            SendRequest,
            AcceptRequest,
            RejectRequest,
            DeleteFriend
        };
        
        
        enum class UpdateFriendResult
        {
            RequestSent,
            
            RequestAccepted,
            
            RequestNotAllowed,
            
            RequestNotFound,
            
            RequestRejected,
            
            RequestDeleted,
            
            FriendDeleted,
            
            FriendNotFound,
            
            AlreadyExists,
            
            Unknown
        };
        
        
        enum class FriendRequestRemovalReason
        {
            Invalid, 
            SelfAccepted, 
            TargetAccepted, 
            SelfRejected, 
            TargetRejected 
        };
        
        
        enum class FriendStatus
        {
            NoRelation,
            
            Blocked,
            
            Blocks,
            
            SentRequest,
            
            ReceivedRequest,
            
            Friends,
            
            Unknown
        };
        
        
        struct Friend
        {
            Friend();
            
            UserInfo userInfo;
            
            Timestamp friendsSinceTime;
            
            PresenceStatus presenceStatus;
        };
        
        
        struct FriendRequest
        {
            FriendRequest();
            
            UserInfo userInfo;
            
            Timestamp requestTime;
        };
    }
}