Google Play API Reference

Controllers

GooglePlayManager

	//Actions

    //triggers when score submit flow is finished
	public static event Action<GP_LeaderboardResult> ActionScoreSubmited = delegate {};
    //triggers when score data is recieved
	public static event Action<GP_LeaderboardResult> ActionScoresListLoaded = delegate {};

    //triggers when Leaderboards data is loaded
	public static event Action<GooglePlayResult> ActionLeaderboardsLoaded = delegate {};

    //triggers when achievement is updated
	public static event Action<GP_AchievementResult> ActionAchievementUpdated = delegate {};
    //triggers when FriendList is loaded
	public static event Action<GooglePlayResult> ActionFriendsListLoaded = delegate {};
    //triggers achievements are loaded
	public static event Action<GooglePlayResult> ActionAchievementsLoaded = delegate {};

    //triggers when GiftSendResult is recieved
	public static event Action<GooglePlayGiftRequestResult> ActionSendGiftResultReceived = delegate {};
    //triggers when a request inbox dialogue is dismissed
	public static event Action ActionRequestsInboxDialogDismissed = delegate {};
    //triggers when game requests are loaded
	public static event Action<List<GPGameRequest>> ActionPendingGameRequestsDetected = delegate {};
    //triggers when game requests are accepted
	public static event Action<List<GPGameRequest>> ActionGameRequestsAccepted = delegate {};

    //triggers upon loading of accounts available on this device, stores the account names in the returned list of strings
	public static event Action<List<string>> ActionAvailableDeviceAccountsLoaded = delegate {};
    //triggers when OAuth token is loaded
	public static event Action<string> ActionOAuthTokenLoaded = delegate {};

    //use this to initialize an instance of a GooglePlayManager object
    public void Create()

    //API call methods

    //gets available on current device account names, ActionAvailableDeviceAccountsLoaded is triggerd when finished
    public void RetrieveDeviceGoogleAccounts()
    //loads an OAuth token for the accountName and specified scopes, triggers ActionOauthTokenLoaded when finished
    public void LoadToken(string accountName,  string scopes)
    //loads an OAuth token for the current account and a "oauth2:https://www.googleapis.com/auth/games" scope, triggers ActionOauthTokenLoaded when finished
    public void LoadToken()
    //invalidates the token
    public void InvalidateToken(string token)
    //shows a standard google achievements UI to the player
    public void ShowAchievementsUI()
    //shows a standard leaderboards UI to the player
    public void ShowLeaderBoardsUI()
    //shows a specified by name leaderboard
    public void ShowLeaderBoard(string leaderboardName)
    //shows a specified by ID leaderboard
    public void ShowLeaderBoardById(string leaderboardId)
    //submits the score to a specified by name leaderboard, ActionScoreSubmited is triggered when finished
    public void SubmitScore(string leaderboardName, long score)
    //submits the score to a specified by ID leaderboard, ActionScoreSubmited is triggered when finished
    public void SubmitScoreById(string leaderboardId, long score)
    //loads all leaderboards in your application, ActionLeaderBoardsLoaded is triggered when finished
    public void LoadLeaderBoards()
    //updates player local score by leaderboard ID
    public void UpdatePlayerScoreLocal(string leaderboardId)
    //loads equal or less than maxResults player centered friend or global scores in a timespan in a specified by ID leaderboard, ActionScoresListLoaded is triggered
    public void LoadPlayerCenteredScores(string leaderboardId, GPBoardTimeSpan span, GPCollectionType collection, int maxResults)
    //loads equal or less than maxResults friend or global scores in a timeSpan in a specified by ID leaderboard, ActionScoresListLoaded is triggered
    public void LoadTopScores(string leaderboardId, GPBoardTimeSpan span, GPCollectionType collection, int maxResults)
    
    //unlocks a specified by name achievement for the current player
    public void UnlockAchievement(string achievementName)
    //unlocks a specified by id achievement for the current player
    public void UnlockAchievementById(string achievementId)
    //reveals a hidden achievement by its name(does not unlock it)
    public void RevealAchievement(string achievementName)
    //reveals a hidden achievement by its ID(does not unlock it)
    public void RevealAchievementById(string achievementId)
    //increments the progress in unlocking a specified by name achievement in numsteps number of steps
    public void IncrementAchievement(string achievementName, int numsteps)
    //increments the progress in unlocking a specified by ID achievement in numsteps number of steps
    public void IncrementAchievementById(string achievementId, int numsteps)
    //sets the progress in unlocking a specified by ID achievemnt to a numsteps number of steps immidiately
    public void SetStepsImmediate(string achievementId, int numsteps)
    //loads achievements, ActionAchievementsLoaded is triggered when finished
    public void LoadAchievements()
    //resets a specified by ID achievement to the initial state
    public void ResetAchievement(string achievementId)
    //resets all achievements to initial state
    public void ResetAllAchievements()
    //resets a specified by ID leaderboard to the initial state
    public void ResetLeaderBoard(string leaderboardId)
    //loads friendlist, ActionFriendsListLoaded is triggered when finished
    public void LoadFriends()

    //sends a gift request of type, available for requestLifetimeDays, with icon, description and payload, fires ActionSendGiftResultReceived when the result is recieved
    public void SendGiftRequest(GPGameRequestType type, int requestLifetimeDays, Texture2D icon, string description, string playload = "")

    //shows the gift request accept dialogue, ActionGameRequestsAccepted is fired when finished
    public void ShowRequestsAccepDialog()
    //accepts all assigned requests
    public void AcceptRequests(params string[] ids)
    //dismisses all assigned requests
	public void DismissRequest(params string[] ids)
    //triggers ActionScoreSubmitted
	public void DispatchLeaderboardUpdateEvent(GP_LeaderboardResult result)
    //returns an assigned by ID leaderboard
	public GPLeaderBoard GetLeaderBoard(string leaderboardId)
    //returns an assigned by ID achievement
	public GPAchievement GetAchievement(string achievementId)
    //returns an assigned by ID player
	public GooglePlayerTemplate GetPlayerById(string playerId)
    //returns an assigned by ID game request
	public GPGameRequest GetGameRequestById(string id)


    //getters
    public string CurrentAccount
    public GooglePlayerTemplate Player
    public Dictionary<string, GooglePlayerTemplate> Players
    public Dictionary<string, GPLeaderBoard> LeaderBoards
    public Dictionary<string, GPAchievement> Achievements
    public List<string> FriendsList
    public List<GPGameRequest> GameRequests
    public List<string> DeviceGoogleAccountList
    public string LoadedAuthToken
    public static bool IsLeaderboardsDataLoaded
	public static GP_Participant ParseParticipanData(string[] data, int index )
	public static List<GP_Participant>  ParseParticipantsData(string[] data, int index )

GooglePlayConnection

    //actions
    //triggers when Connect() function finishes
	public static event Action<GooglePlayConnectionResult> ActionConnectionResultReceived =  delegate {};

    //triggers when the connection state is changed
	public static event Action<GPConnectionState> ActionConnectionStateChanged =  delegate {};
    //triggers when the player has connected
	public static event Action ActionPlayerConnected =  delegate {};
    //triggers when the player was disconnected
	public static event Action ActionPlayerDisconnected =  delegate {};

    //methods
    //tries to connect via google account(s) stored in the device
	public void Connect()
    //tries to connect via specified accountName
	public void Connect(string accountName)
    //disconnets the current player
	public void Disconnect()
    //checks if the player is connected, returns true if GPConnectionState.STATE_CONNECTED
	public static bool CheckState()

    //getters
	public bool IsConnected
	public static GPConnectionState State
	public  bool IsInitialized

GooglePlaySavedGamesManager

	//Actions
    //triggers on a new game save request
	public static event Action ActionNewGameSaveRequest = delegate {};
    //triggers after snapshot load flow is finished
	public static event Action<GooglePlayResult> ActionAvailableGameSavesLoaded = delegate {};

    //triggers after the gamesave is successfully loaded
	public static event Action<GP_SpanshotLoadResult> ActionGameSaveLoaded = delegate {};
    //triggers after a try to create a new snapshot
	public static event Action<GP_SpanshotLoadResult> ActionGameSaveResult = delegate {};
    //fires when a conflict of gamesaves is detected
	public static event Action<GP_SnapshotConflict> ActionConflict = delegate {};
    //triggers when a delete snapshot flow is finished
	public static event Action<GP_DeleteSnapshotResult> ActionGameSaveRemoved = delegate {};

    //methods

    //shows the default google gamesave UI
	public void ShowSavedGamesUI(string title, int maxNumberOfSavedGamesToShow, bool allowAddButton = true, bool allowDelete = true)
    //creates a new gamesave with string data, ActionNewGameSaveRequest is triggered
	public void CreateNewSnapshot(string name, string description, Texture2D coverImage, string spanshotData, long PlayedTime)
    //creates a new gamesave with byte array data, ActionNewGameSaveRequest is triggered
	public void CreateNewSnapshot(string name, string description, Texture2D coverImage, byte[] spanshotData, long PlayedTime)
    //loads a gamesave specified by name, ActionGameSaveLoaded is triggered if the load was successful
	public void LoadSpanshotByName(string name)
    //attempts to delete a gamesave, ActionGameSaveRemoved is triggered when finished
	public void DeleteSpanshotByName(string name)
    //loads available savegames, ActionAvailableGameSavesLoaded is triggered when finished
	public void LoadAvailableSavedGames()

    //getters
	public List<GP_SnapshotMeta> AvailableGameSaves

GooglePlayQuests

	//Actions
    
    //triggeres when LoadEvents method has finished
	public Action<GooglePlayResult> OnQuestsLoaded =  delegate{};
    //triggers when a quest is accepted by player
	public Action<GP_QuestResult> OnQuestsAccepted =  delegate{};
    //triggers when a quest is completed by player
	public Action<GP_QuestResult> OnQuestsCompleted =  delegate{};

    //stores a collection of all GP_QuestsSelect enum values
	public static GP_QuestsSelect[] SELECT_ALL_QUESTS
    
    //methods

    //loads quests in a specified order, OnQuestsLoaded is triggered when finished
	public void LoadQuests(GP_QuestSortOrder sortOrder)
    //loads specified quests in a specific order, OnQuestsLoaded is triggered when finished
	public void LoadQuests(GP_QuestSortOrder sortOrder, params GP_QuestsSelect[] selectors)
    //shows the default google UI with quests available in your app
	public void ShowQuests()
    //shows the default google UI with specified quests available in your app
	public void ShowQuests(params GP_QuestsSelect[] selectors)
    //accepts the quest specified by ID, OnQuestsAccepted is triggered upon finishing
	public void AcceptQuest(string id)
    //returns the quest, specified by ID
	public GP_Quest GetQuestById(string id)
    //returns all available quests
	public List<GP_Quest> GetQuests()
    //returns all quests in a specified state
	public List<GP_Quest> GetQuestsByState(GP_QuestState state)

GooglePlayEvents

    //actions
    //triggers when events are loaded
	public Action<GooglePlayResult> OnEventsLoaded =  delegate{};

    //methods
    
    //loads available events, triggers OnEventsLoaded action
	public void LoadEvents()
    //increments the progress of the event by 1
	public void SumbitEvent(string eventId)
    //increments the progress of the event by count
	public void SumbitEvent(string eventId, int count)

    //getters
	public List<GP_Event> Events

GooglePlayInvitationManager

    //actions
    //triggers when an invitation is recieved
	public static event Action<GP_Invite> ActionInvitationReceived = delegate{};
    //triggers when an invitation request is accepted
	public static event Action<GP_Invite> ActionInvitationAccepted = delegate{};

    //triggers when an invitation inbox was closed by player
	public static event Action<AN_InvitationInboxCloseResult> ActionInvitationInboxClosed =  delegate{};
    //triggers whan an invitation was removed
	public static event Action<string> ActionInvitationRemoved = delegate {};

    //methods
    //if a listener is registered by this method, the incoming invitation will not generate a status bar notification as long as this client remains connected
	public void RegisterInvitationListener()
    //you can unregister with this method
	public void UnregisterInvitationListener()

GooglePlayRTM

	//Actions

    //triggers when the client recieves data from other players
	public static Action<GP_RTM_Network_Package> ActionDataRecieved = delegate{};
    //triggers when a room is updated and when client leaves a room
	public static Action<GP_RTM_Room> ActionRoomUpdated = delegate{};
    //fires after a reliable message is sent
	public static Action<GP_RTM_ReliableMessageSentResult> ActionReliableMessageSent = delegate{};
    //triggers after a reliable message is delivered 
	public static Action<GP_RTM_ReliableMessageDeliveredResult> ActionReliableMessageDelivered = delegate{};
	
    //triggers when a player has connected to a room
	public static Action ActionConnectedToRoom = delegate{};
    //triggers when a player has been disconnected from a room
	public static Action ActionDisconnectedFromRoom = delegate{};

	//contains participant id
    //triggers when player connects to the peer-to-peer room
	public static Action<string>  ActionP2PConnected = delegate{};
    //triggers when player disconnects from the peer-to-peer room
	public static Action<string>  ActionP2PDisconnected = delegate{};

	//contains participants ids
    //triggers when a peer declines invitation to the room
	public static Action<string[]> ActionPeerDeclined = delegate{};
    //triggers when a peer has been invited to the room
	public static Action<string[]> ActionPeerInvitedToRoom = delegate{};
    //triggers when a peer has joined the room
	public static Action<string[]> ActionPeerJoined = delegate{};
    //triggers when a peer has left the room
	public static Action<string[]> ActionPeerLeft = delegate{};
    //triggers when peer(s) are connected
	public static Action<string[]> ActionPeersConnected = delegate{};
    //triggers when peer(s) had been disconnectd
	public static Action<string[]> ActionPeersDisconnected = delegate{};
    
    //triggers when player started to look for a game via automatching system
	public static Action ActionRoomAutomatching = delegate{};
    //triggers when player attempts to connet a room
	public static Action ActionRoomConnecting = delegate{};
    //triggers after player has joined a room
	public static Action<GP_GamesStatusCodes> ActionJoinedRoom = delegate{};
    //triggers after player has left a room
	public static Action<GP_RTM_Result> ActionLeftRoom = delegate{};
    //triggers after player has connected to a room
	public static Action<GP_GamesStatusCodes> ActionRoomConnected = delegate{};
    //triggers after player has created a room
	public static Action<GP_GamesStatusCodes> ActionRoomCreated = delegate{};
	
    //triggers after player closes invitation box
	public static Action<AndroidActivityResult> ActionInvitationBoxUIClosed = delegate{};
    //triggers when player closes a waiting room
	public static Action<AndroidActivityResult> ActionWatingRoomIntentClosed = delegate{};
	
	//contains invitation id
    //triggers when an invitation was recieved
	public static Action<GP_Invite> ActionInvitationReceived = delegate{};
    //triggers when player removes an invitation
	public static Action<string> ActionInvitationRemoved = delegate{};

    //methods
    //attempts to find players to play with via auto-matching
	public void FindMatch(int minPlayers, int maxPlayers)
    //attempts to find players to play with via auto-matching, also inviting friends
	public void FindMatch(int minPlayers, int maxPlayers, params GooglePlayerTemplate[] playersToInvite)
    //attempts to find players to play with via auto-matching, also inviting friends
	public void FindMatch(int minPlayers, int maxPlayers, params string[] playersToInvite)
    //attempts to find players to play with via auto-matching, also inviting friends
	public void FindMatch(GooglePlayerTemplate[] playersToInvite)
    //attempts to find players to play with via auto-matching, also inviting friends
	public void FindMatch(string[] playersToInvite)
    //sends a data package to all players in the match
	public void SendDataToAll(byte[] data, GP_RTM_PackageType sendType)
    //sends a data package to specified players in the match
	public void sendDataToPlayers(byte[] data, GP_RTM_PackageType sendType, params string[] players)
    //shows a default waiting room UI
	public void ShowWaitingRoomIntent()
    //launches a default player picker UI and invites picked players
	public void OpenInvitationBoxUI(int minPlayers, int maxPlayers)
    //leaves current room, ActionLeftRoom is triggered
	public void LeaveRoom()
    //accepts the invitation by id
	public void AcceptInvitation(string invitationId)
    //declines the invitation by id
	public void DeclineInvitation(string invitationId)
    //dismisses the invitation by id
	public void DismissInvitation(string invitationId)

    //launches a default player picker UI 
	public void OpenInvitationInBoxUI()

    //auto-matching: searches players with the same variant
	public void SetVariant(int val)
    //auto-matching: searches players with mismatching bitmasks
	public void SetExclusiveBitMask(int val)
    //Clear messages with this data token id from Google Play RTM controller
	public void ClearReliableMessageListener(int dataTokenId)

    //getters
    public GP_RTM_Room CurrentRoom
    public List<GP_Invite> Invitations

    //static methods 
	public static byte[] ConvertStringToByteData(string data)
	public static string ConvertByteDataToString(byte[] data)

GooglePlayTBM

    //actions
    //triggers after some TBM matches are loaded
    public static Action<GP_TBM_LoadMatchesResult> ActionMatchesResultLoaded = delegate { };
    //triggers after player initiates a match or tries to auto-match
    public static Action<GP_TBM_MatchInitiatedResult> ActionMatchInitiated = delegate { };
    //triggers when CancelMatch() has finished
    public static Action<GP_TBM_CancelMatchResult> ActionMatchCanceled = delegate { };
    //triggers when LeaveMatch(...) or LeaveMatchDuringTurn(...) has finished
    public static Action<GP_TBM_LeaveMatchResult> ActionMatchLeaved = delegate { };
    //triggers after the match data has been loaded
    public static Action<GP_TBM_LoadMatchResult> ActionMatchDataLoaded = delegate { };
    //triggers after the match data has been updated
    public static Action<GP_TBM_UpdateMatchResult> ActionMatchUpdated = delegate { };

    //triggers whenever the match is updated following a player's turn
    public static Action<GP_TBM_MatchReceivedResult> ActionMatchReceived = delegate { };
    //triggers whenever the match is updated following a player's turn
    public static Action<GP_TBM_MatchRemovedResult> ActionMatchRemoved = delegate { };

    //triggers when initiated by player match creation was canceled
    public static Action<AndroidActivityResult> ActionMatchCreationCanceled = delegate { };

    //methods
    //accept invitation by id
    public void AcceptInvitation(string invitationId)
    //decline invitation by id
    public void DeclineInvitation(string invitationId)
    //dismiss invitation by id
    public void DismissInvitation(string invitationId)
    //create a new match, ActionMatchInitiated is triggered
	public void CreateMatch(int minPlayers, int maxPlayers, string[] playersIds = null)
    //cancels the match
    public void CancelMatch(string matchId)
    //hides the match from the dismisser's match list UI and causes the match to eventually expire
    public void DismissMatch(string matchId)
    //finishes the match with some results
    public void FinishMatch(string matchId, byte[] matchData, params GP_ParticipantResult[] results)
    //leave specified match when it is not user's turn, ActionMatchLeaved is triggered
    public void LeaveMatch(string matchId)
    //leave specified match during user's turn, ActionMatchLeaved is triggered
    public void LeaveMatchDuringTurn(string matchId, string pendingParticipantId)
    //loads the information about specified match, ActionMatchDataLoaded is triggered when finsihed
    public void LoadMatchInfo(string matchId)
    //loads the information of specified matches, ActionMatchesResultLoaded is triggered when finsihed
    public void LoadMatchesInfo(GP_TBM_MatchesSortOrder sortOreder, params GP_TBM_MatchTurnStatus[] matchTurnStatuses)
    //loads the information of all matches, ActionMatchesResultLoaded is triggered when finsihed
    public void LoadAllMatchesInfo(GP_TBM_MatchesSortOrder sortOreder)
    //creates a new turn-based match object with the same participants as the previous match
    public void Rematch(string matchId)
    //register Match Update Listener to be notified whenever any participant in the match takes a turn, when it happens, ActionMatchReceived and ActionMatchRemoved are triggered
    public void RegisterMatchUpdateListener()
    //unregisters the listener
    public void UnregisterMatchUpdateListener()
    //takes turn by a participant with some data
    public void TakeTrun(string matchId, byte[] matchData, string pendingParticipantId, params GP_ParticipantResult[] results)
    //shows a standard automatching UI to choose opponents
    public void StartSelectOpponentsView(int minPlayers, int maxPlayers, bool allowAutomatch)

    public void ShowInbox()
    //auto-matching: searches players with the same variant
    public void SetVariant(int val)
    //auto-matching: searches players with mismatching bitmasks
    public void SetExclusiveBitMask(int val)

    //getters
    public Dictionary<string, GP_TBM_Match> Matches

    //utils
    public static GP_TBM_Match ParceMatchInfo(string data)
    public static GP_TBM_Match ParceMatchInfo(string[] MatchData, int index)

GooglePlayUtils

	//Actions
    //triggers when advertising ID has been loaded
	public static Action<GP_AdvertisingIdLoadResult> ActionAdvertisingIdLoaded = delegate {};

    //methods
	public  void GetAdvertisingId()

Models

 GooglePlayerTemplate

    //new features
    //triggers when high-resolution image has been loaded
	public event Action<Texture2D> BigPhotoLoaded =  delegate {};
    //triggers when icon has been loaded
	public event Action<Texture2D> SmallPhotoLoaded =  delegate {};

    //use these methods to initialize
	public GooglePlayerTemplate(string pId, string pName, string iconUrl, string imageUrl, string pHasIconImage, string pHasHiResImage)

    //BigPhotoLoaded is triggered
	public void LoadImage()
    //SmallPhotoLoaded is triggered
	public void LoadIcon()

    //getters
    public string PlayerId
    public string Name
    public bool HasIconImage
    public bool HasHiResImage
    public string IconImageUrl
    public string HiResImageUrl
    public Texture2D Icon
    public Texture2D Image

GPAchievement

    public string Id
    public string Name
    public string Description
    public int CurrentSteps
    public int TotalSteps
    public GPAchievementType Type
    public GPAchievementState State

GPLeaderBoard

    //stores the scores of player's friendlist
	public GPScoreCollection SocsialCollection
    //stores the global scores
	public GPScoreCollection GlobalCollection
    //stores the player's scores
	public List<GPScore> CurrentPlayerScore

    //updates the leaderboard's name
	public void UpdateName(string lName)
    //returns global/social score over a timespan
	public List<GPScore> GetScoresList(GPBoardTimeSpan timeSpan, GPCollectionType collection)
    //returns a specified by id player's score over a timespan in a global/social leaderboard
	public GPScore GetScoreByPlayerId(string playerId, GPBoardTimeSpan timeSpan, GPCollectionType collection)
    //returns a specified by rank player's score over a timespan in a global/social leaderboard
	public GPScore GetScore(int rank, GPBoardTimeSpan timeSpan, GPCollectionType collection)
    //returns current player's score
	public GPScore GetCurrentPlayerScore(GPBoardTimeSpan timeSpan, GPCollectionType collection)
    //creates a score update listener
	public void CreateScoreListener(int requestId)
    //adds a listener to send local score to global scores
	public void ReportLocalPlayerScoreUpdate (GPScore score, int requestId)
    //adds a listener to track any local score reports failures
	public void ReportLocalPlayerScoreUpdateFail(string errorData, int requestId)
    //updates current player's score
	public void UpdateCurrentPlayerScore(List<GPScore> newScores)
    //updates current player's score
	public void UpdateCurrentPlayerScore(GPScore score)
    //updates assigned score in the leaderboard
	public void UpdateScore(GPScore score)

    //getters
	public string Id
	public string Name

GPScoreCollection

	public Dictionary<int, GPScore> AllTimeScores
	public Dictionary<int, GPScore> WeekScores
	public Dictionary<int, GPScore> TodayScores

GPScore

    //sets assigned score to the object
	public void UpdateScore(long vScore)

    //getters
	public int Rank
	public long LongScore
	public float CurrencyScore
	public System.TimeSpan TimeScore
	public string PlayerId
	public GooglePlayerTemplate Player
	public string LeaderboardId
	public GPCollectionType Collection
	public GPBoardTimeSpan TimeSpan

GP_SnapshotConflict

    //contains the initial gamesave
	public GP_Snapshot Snapshot
    //contains the new conflicting snapshot
	public GP_Snapshot ConflictingSnapshot
    //uses the assigned snapshot as a solution
	public void Resolve(GP_Snapshot snapshot)

GP_Snapshot

	public GP_SnapshotMeta meta
    //these two variables store data needed by your application
	public byte[] bytes
	public string stringData

GP_SnapshotMeta

	public string Title
	public string Description
	public string CoverImageUrl

	public long LastModifiedTimestamp
	public long TotalPlayedTime

GPGameRequest

	public string id
	public string playload


	public long expirationTimestamp
	public long creationTimestamp


	public string sender
	public GPGameRequestType type

GP_Event

	public string Id
	public string Description

	public string IconImageUrl
	public string FormattedValue
	
	public long Value

	public void LoadIcon()

	public Texture2D icon

GP_Quest

	public string Id
	public string Name
	public string Description

	public string IconImageUrl
	public string BannerImageUrl

	public GP_QuestState state

	public long LastUpdatedTimestamp
	public long AcceptedTimestamp
	public long EndTimestamp

	public void LoadIcon()
	public void LoadBanner()

	public Texture2D Icon
	public Texture2D Banner

GP_Invite

	public string Id
	public long CreationTimestamp
	public GP_InvitationType InvitationType
	public int Variant
	public GP_Participant Participant

GP_Participant

	public void SetResult(GP_ParticipantResult r)

    //getters
    public string Id
    public string PlayerId
    public string HiResImageUrl
	public string IconImageUrl
	public string DisplayName
	public GP_RTM_ParticipantStatus Status
	public GP_ParticipantResult Result

GP_RTM_Network_Package

	public string participantId
	public byte[] buffer
	public static byte[] ConvertStringToByteData(string data)

GP_RTM_Room

	public string id
	public string creatorId
	public GP_RTM_RoomStatus status
	public long creationTimestamp

	public List<GP_Participant> participants

    //adds the participant to the group
	public void AddParticipant(GP_Participant p)
    //finds and returns a participant by his ID
	public GP_Participant GetParticipantById(string id)

 GP_TBM_Match

	public string Id
	public string RematchId
    //stores the ID of the match initiator
	public string CreatorId
    //stores the ID of the player who finished his turn and updated the game last time
	public string LastUpdaterId
	public string PendingParticipantId
	public int MatchNumber

	public string Description

	public int AvailableAutoMatchSlots


	public long CreationTimestamp
	public long LastUpdatedTimestamp
	
	public GP_TBM_MatchStatus Status
	public GP_TBM_MatchTurnStatus TurnStatus

	public bool CanRematch

	public int Variant
	public int Version

	public byte[] Data
	public byte[] PreviousMatchData

	public List<GP_Participant> Participants

    //methods
    //automatically convers assigned string value to byte array and sets it into Data variable
	public void SetData(string val)
    //automatically convers assigned string value to byte array and sets it into PreviousMatchDatavariable
	public void SetPreviousMatchData(string val)

Results

GooglePlayConnectionResult

    public GP_ConnectionResultCode code;
    public bool HasResolution;
    //getter
    public bool IsSuccess

 GP_AchievementResult : GooglePlayResult

	public string achievementId

GooglePlayResult

    public GP_GamesStatusCodes Response
    public string Message
    public bool IsSuccess
    public bool IsFailure

 GP_LeaderboardResult : GooglePlayResult

	public GPLeaderBoard Leaderboard

GooglePlayGiftRequestResult

    //getters
	public GP_GamesActivityResultCodes Code
    public bool IsSuccess
    public bool IsFailure

GP_SpanshotLoadResult : GooglePlayResult

	public void SetSnapShot(GP_Snapshot s)
	public GP_Snapshot Snapshot

GP_DeleteSnapshotResult : GooglePlayResult

    //sets the operated snapshot id
	public void SetId(string sid)
	public string SnapshotId

GP_QuestResult : GooglePlayResult

	public string questId
	public string reward

	public GP_Quest quest
	public GP_Quest GetQuest()

GP_ParticipantResult

    //getters
	public int Placing
	public int Result
	public int VersionCode
	public string ParticipantId

GP_RTM_Result

    //getters
    public GP_GamesStatusCodes Status
    public string RoomId

GP_TBM_LoadMatchesResult

	public Dictionary<string, GP_TBM_Match> LoadedMatches

GP_TBM_MatchResult : GooglePlayResult

	public GP_TBM_Match Match

GP_TBM_CancelMatchResult : GooglePlayResult

	public string MatchId

GP_TBM_MatchReceivedResult

	public GP_TBM_Match Match

GP_TBM_MatchRemovedResult

	public string MatchId

GP_AdvertisingIdLoadResult

	public string id
	public bool isLimitAdTrackingEnabled

Enums

GPConnectionState

public enum GPConnectionState  {
	STATE_UNCONFIGURED,  //the default sate, means we never tried to connect in current session
	STATE_DISCONNECTED,
	STATE_CONNECTING,
	STATE_CONNECTED
}

GPBoardTimeSpan

public enum GPBoardTimeSpan  {
	ALL_TIME = 2,
	WEEK = 1,
	TODAY = 0
}

GPCollectionType

public enum GPCollectionType  {
	GLOBAL = 0,
	FRIENDS = 1
}

GP_ConnectionResultCode

public enum GP_ConnectionResultCode  {

	//results description can be found at:
	//http://developer.android.com/reference/com/google/android/gms/common/ConnectionResult.html

	CANCELED = 13,
	DATE_INVALID = 12,
	DEVELOPER_ERROR = 10,
	DRIVE_EXTERNAL_STORAGE_REQUIRED = 1500,
	INTERNAL_ERROR = 8,
	INTERRUPTED = 15,
	INVALID_ACCOUNT = 5,
	LICENSE_CHECK_FAILED = 11,
	NETWORK_ERROR = 7,
	RESOLUTION_REQUIRED = 6,
	SERVICE_DISABLED = 3,
	SERVICE_INVALID = 9,
	SERVICE_MISSING = 1,
	SERVICE_VERSION_UPDATE_REQUIRED = 2,
	SIGN_IN_REQUIRED = 4,
	SUCCESS = 0,
	TIMEOUT = 14

}

GPAchievementType

public enum GPAchievementType  {
	TYPE_STANDARD,
	TYPE_INCREMENTAL
}

GPAchievementState

public enum GPAchievementState  {

	STATE_UNLOCKED,
	STATE_REVEALED,
	STATE_HIDDEN
}

 GP_GamesStatusCodes

public enum GP_GamesStatusCodes {

	//results description can be found at:
	//http://developer.android.com/reference/com/google/android/gms/games/GamesStatusCodes.html

	STATUS_OK = 0,
	STATUS_INTERNAL_ERROR = 1,
	STATUS_CLIENT_RECONNECT_REQUIRED = 2,
	STATUS_NETWORK_ERROR_STALE_DATA = 3,
	STATUS_NETWORK_ERROR_NO_DATA = 4,
	STATUS_NETWORK_ERROR_OPERATION_DEFERRED = 5,
	STATUS_NETWORK_ERROR_OPERATION_FAILED = 6,
	STATUS_LICENSE_CHECK_FAILED = 7,
	STATUS_APP_MISCONFIGURED = 8,
	STATUS_GAME_NOT_FOUND = 9,
	STATUS_INTERRUPTED = 14,
	STATUS_TIMEOUT = 15,


	STATUS_REQUEST_UPDATE_PARTIAL_SUCCESS = 2000,
	STATUS_REQUEST_UPDATE_TOTAL_FAILURE = 2001,

	STATUS_ACHIEVEMENT_UNLOCK_FAILURE = 3000,
	STATUS_ACHIEVEMENT_UNKNOWN = 3001,
	STATUS_ACHIEVEMENT_UNLOCKED = 3003,
	STATUS_ACHIEVEMENT_NOT_INCREMENTAL = 3002,

	STATUS_MULTIPLAYER_ERROR_CREATION_NOT_ALLOWED = 6000,
	STATUS_MULTIPLAYER_ERROR_NOT_TRUSTED_TESTER = 6001,
	STATUS_MULTIPLAYER_ERROR_INVALID_MULTIPLAYER_TYPE = 6002,
	STATUS_MULTIPLAYER_DISABLED = 6003,
	STATUS_MULTIPLAYER_ERROR_INVALID_OPERATION = 6004,



	STATUS_MATCH_ERROR_INVALID_PARTICIPANT_STATE = 6500,
	STATUS_MATCH_ERROR_INACTIVE_MATCH = 6501,
	STATUS_MATCH_ERROR_INVALID_MATCH_STATE = 6502,
	STATUS_MATCH_ERROR_OUT_OF_DATE_VERSION = 6503,
	STATUS_MATCH_ERROR_INVALID_MATCH_RESULTS = 6504,
	STATUS_MATCH_ERROR_ALREADY_REMATCHED = 6505,
	STATUS_MATCH_NOT_FOUND = 6506,
	STATUS_MATCH_ERROR_LOCALLY_MODIFIED = 6507,



	STATUS_REAL_TIME_CONNECTION_FAILED = 7000,
	STATUS_REAL_TIME_MESSAGE_SEND_FAILED = 7001,
	STATUS_INVALID_REAL_TIME_ROOM_ID = 7002,
	STATUS_PARTICIPANT_NOT_CONNECTED = 7003,
	STATUS_REAL_TIME_ROOM_NOT_JOINED = 7004,
	STATUS_REAL_TIME_INACTIVE_ROOM = 7005,

	STATUS_OPERATION_IN_FLIGHT = 7007,
	

	STATUS_UNKNOWN = 99999

}

GPGameRequestType

public enum GPGameRequestType  {

	TYPE_GIFT = 1,
	TYPE_WISH = 2
}

GP_QuestState  

public enum GP_QuestState  {

	STATE_UPCOMING = 1,
	STATE_OPEN = 2,
	STATE_ACCEPTED = 3,
	STATE_COMPLETED = 4,
	STATE_EXPIRED = 5,
	STATE_FAILED = 6

}

GP_QuestsSelect

public enum GP_QuestsSelect  {

	SELECT_UPCOMING = 1,
	SELECT_OPEN = 2,
	SELECT_ACCEPTED = 3,
	SELECT_COMPLETED = 4,
	SELECT_EXPIRED = 5,
	SELECT_FAILED = 6,
	SELECT_COMPLETED_UNCLAIMED = 101,
	SELECT_ENDING_SOON = 102
}

GP_QuestSortOrder

public enum GP_QuestSortOrder {

	SORT_ORDER_RECENTLY_UPDATED_FIRST = 0,
	SORT_ORDER_ENDING_SOON_FIRST = 1
}

GP_InvitationType

public enum GP_InvitationType {

	//https://developer.android.com/reference/com/google/android/gms/games/multiplayer/Invitation.html#INVITATION_TYPE_REAL_TIME

	INVITATION_TYPE_REAL_TIME = 0,
	INVITATION_TYPE_TURN_BASED = 1
}

GP_RTM_RoomStatus

public enum GP_RTM_RoomStatus {

	ROOM_VARIANT_DEFAULT = -1,
	ROOM_STATUS_INVITING = 0,
	ROOM_STATUS_AUTO_MATCHING = 1,
	ROOM_STATUS_CONNECTING = 2,
	ROOM_STATUS_ACTIVE = 3

}

GP_RTM_ParticipantStatus

public enum GP_RTM_ParticipantStatus {
	STATUS_NOT_INVITED_YET = 0,
	STATUS_INVITED = 1,
	STATUS_JOINED = 2,
	STATUS_DECLINED = 3,
	STATUS_LEFT = 4,
	STATUS_FINISHED = 5,
	STATUS_UNRESPONSIVE = 6
}

GP_RTM_PackageType

public enum GP_RTM_PackageType  {

	RELIABLE = 0, 
	UNRELIABLE = 1
}

GP_TBM_MatchesSortOrder

public enum GP_TBM_MatchesSortOrder  {

	SORT_ORDER_MOST_RECENT_FIRST = 0,
	SORT_ORDER_SOCIAL_AGGREGATION = 1
}

GP_TBM_MatchTurnStatus

public enum GP_TBM_MatchTurnStatus {

	MATCH_TURN_STATUS_INVITED = 0,
	MATCH_TURN_STATUS_MY_TURN = 1,
	MATCH_TURN_STATUS_THEIR_TURN = 2,
	MATCH_TURN_STATUS_COMPLETE = 3,
}

GP_TBM_MatchStatus

public enum GP_TBM_MatchStatus  {

	MATCH_STATUS_AUTO_MATCHING = 0,
	MATCH_STATUS_ACTIVE = 1,
	MATCH_STATUS_COMPLETE = 2,
	MATCH_STATUS_EXPIRED = 3,
	MATCH_STATUS_CANCELED = 4

}