MCONTACT CSteamProto::AddToList(int, PROTOSEARCHRESULT* psr)
{
MCONTACT hContact = NULL;
ptrA steamId(mir_u2a(psr->id.t));
if (psr->cbSize == sizeof(PROTOSEARCHRESULT))
{
if (!FindContact(steamId))
{
//hContact = AddContact(steamId, true);
//ForkThread(&CSteamProto::UpdateContactsThread, (void*)mir_strdup(steamId));
ptrA token(getStringA("TokenSecret"));
PushRequest(
new GetUserSummariesRequest(token, steamId),
&CSteamProto::OnGotUserSummaries);
}
}
else if (psr->cbSize == sizeof(STEAM_SEARCH_RESULT))
{
STEAM_SEARCH_RESULT *ssr = (STEAM_SEARCH_RESULT*)psr;
hContact = AddContact(steamId, true);
UpdateContact(hContact, ssr->data);
}
return hContact;
}
int CSteamProto::AuthDeny(MEVENT hDbEvent, const TCHAR*)
{
if (IsOnline() && hDbEvent)
{
MCONTACT hContact = GetContactFromAuthEvent(hDbEvent);
if (hContact == INVALID_CONTACT_ID)
return 1;
//ForkThread(&CSteamProto::AuthDenyThread, (void*)hContact);
ptrA token(getStringA("TokenSecret"));
ptrA sessionId(getStringA("SessionID"));
ptrA steamId(getStringA("SteamID"));
char *who = getStringA(hContact, "SteamID");
PushRequest(
new IgnorePendingRequest(token, sessionId, steamId, who),
&CSteamProto::OnPendingIgnoreded,
who, MirFreeArg);
return 0;
}
return 1;
}
void CSteamProto::OnGotHistoryMessages(const HttpResponse *response, void *arg)
{
MCONTACT hContact = FindContact((char*)arg);
if (!hContact)
return;
if (!ResponseHttpOk(response))
return;
JSONROOT root(response->pData);
if (root == NULL)
return;
JSONNode *node = json_get(root, "response");
JSONNode *messages = json_get(node, "messages");
JSONNode *nmessages = json_as_array(messages);
// Self SteamID
ptrA steamId(getStringA("SteamID"));
for (size_t i = json_size(nmessages); i > 0; i--)
{
JSONNode *message = json_at(nmessages, i - 1);
node = json_get(message, "accountid");
const char *authorSteamId = AccountIdToSteamId(_ttoi64(ptrT(json_as_string(node))));
node = json_get(message, "message");
ptrT text(json_as_string(node));
T2Utf szMessage(text);
node = json_get(message, "timestamp");
time_t timestamp = _ttoi64(ptrT(json_as_string(node)));
// Ignore already existing messages
if (timestamp <= m_lastMessageTS)
continue;
PROTORECVEVENT recv = { 0 };
recv.timestamp = timestamp;
recv.szMessage = szMessage;
if (strcmp(steamId, authorSteamId))
{
// Received message
ProtoChainRecvMsg(hContact, &recv);
}
else
{
// Sent message
recv.flags = PREF_SENT;
Proto_RecvMessage(hContact, &recv);
}
}
json_delete(nmessages);
}
void CSteamProto::OnLoggedOn(const HttpResponse *response)
{
if (!CheckResponse(response))
{
if (response && response->resultCode == HTTP_CODE_UNAUTHORIZED)
{
// Probably expired TokenSecret
HandleTokenExpired();
return;
}
// Probably timeout or no connection, we can do nothing here
ShowNotification(_T("Steam"), TranslateT("Unknown login error."));
SetStatus(ID_STATUS_OFFLINE);
return;
}
JSONROOT root(response->pData);
JSONNode *node = json_get(root, "error");
ptrT error(json_as_string(node));
if (mir_tstrcmpi(error, _T("OK")))
{
// Probably expired TokenSecret
HandleTokenExpired();
return;
}
node = json_get(root, "umqid");
setString("UMQID", ptrA(mir_u2a(ptrT(json_as_string(node)))));
node = json_get(root, "message");
setDword("MessageID", json_as_int(node));
if (m_lastMessageTS <= 0) {
node = json_get(root, "utc_timestamp");
time_t timestamp = _ttoi64(ptrT(json_as_string(node)));
setDword("LastMessageTS", timestamp);
}
// load contact list
ptrA token(getStringA("TokenSecret"));
ptrA steamId(getStringA("SteamID"));
PushRequest(
new GetFriendListRequest(token, steamId),
&CSteamProto::OnGotFriendList);
// start polling thread
m_hPollingThread = ForkThreadEx(&CSteamProto::PollingThread, 0, NULL);
// go to online now
ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)ID_STATUS_CONNECTING, m_iStatus = m_iDesiredStatus);
}
INT_PTR CSteamProto::OpenBlockListCommand(WPARAM, LPARAM)
{
ptrA token(getStringA("TokenSecret"));
ptrA steamId(getStringA("SteamID"));
PushRequest(
new SteamWebApi::GetFriendListRequest(token, steamId, "ignoredfriend"),
&CSteamProto::OnGotBlockList);
return 0;
}
void CSteamProto::OnGotConversations(const HttpResponse *response)
{
// Don't load any messages when we don't have lastMessageTS, as it may cause duplicates
if (m_lastMessageTS <= 0)
return;
if (!ResponseHttpOk(response))
return;
JSONROOT root(response->pData);
if (root == NULL)
return;
JSONNode *node = json_get(root, "response");
JSONNode *sessions = json_get(node, "message_sessions");
JSONNode *nsessions = json_as_array(sessions);
if (nsessions != NULL)
{
ptrA token(getStringA("TokenSecret"));
ptrA steamId(getStringA("SteamID"));
for (size_t i = 0; i < json_size(nsessions); i++)
{
JSONNode *session = json_at(nsessions, i);
node = json_get(session, "accountid_friend");
const char *who = AccountIdToSteamId(_ttoi64(ptrT(json_as_string(node))));
node = json_get(session, "last_message");
time_t lastMessageTS = _ttoi64(ptrT(json_as_string(node)));
/*node = json_get(session, "last_view");
time_t last_view = _ttoi64(ptrT(json_as_string(node)));
node = json_get(session, "unread_message_count");
long unread_count = json_as_int(node);*/
if (lastMessageTS > m_lastMessageTS)
{
PushRequest(
new GetHistoryMessagesRequest(token, steamId, who, m_lastMessageTS),
&CSteamProto::OnGotHistoryMessages,
mir_strdup(who),
MirFreeArg);
}
}
json_delete(nsessions);
}
}
int CSteamProto::BlockCommand(WPARAM hContact, LPARAM)
{
ptrA token(getStringA("TokenSecret"));
ptrA sessionId(getStringA("SessionID"));
ptrA steamId(getStringA("SteamID"));
char *who = getStringA(hContact, "SteamID");
PushRequest(
new SteamWebApi::BlockFriendRequest(token, sessionId, steamId, who),
&CSteamProto::OnFriendBlocked,
who);
return 0;
}
HANDLE CSteamProto::SearchBasic(const TCHAR* id)
{
if (!this->IsOnline())
return 0;
//ForkThread(&CSteamProto::SearchByIdThread, mir_wstrdup(id));
ptrA token(getStringA("TokenSecret"));
ptrA steamId(mir_t2a(id));
PushRequest(
new GetUserSummariesRequest(token, steamId),
&CSteamProto::OnSearchByIdEnded,
mir_tstrdup(id),
MirFreeArg);
return (HANDLE)STEAM_SEARCH_BYID;
}
int __cdecl CSteamProto::OnEvent(PROTOEVENTTYPE eventType, WPARAM wParam, LPARAM lParam)
{
switch (eventType)
{
case EV_PROTO_ONLOAD:
return this->OnModulesLoaded(wParam, lParam);
case EV_PROTO_ONEXIT:
return this->OnPreShutdown(wParam, lParam);
/*case EV_PROTO_ONOPTIONS:
return this->OnOptionsInit(wParam, lParam);*/
case EV_PROTO_ONCONTACTDELETED:
if (IsOnline())
{
MCONTACT hContact = (MCONTACT)wParam;
ptrA token(getStringA("TokenSecret"));
ptrA sessionId(getStringA("SessionID"));
ptrA steamId(getStringA("SteamID"));
ptrA who(getStringA(hContact, "SteamID"));
// Don't request delete contact from server when we're not friends anyway
if (getByte(hContact, "Auth", 0) != 0)
return 0;
PushRequest(
new RemoveFriendRequest(token, sessionId, steamId, who),
&CSteamProto::OnFriendRemoved,
(void*)hContact);
}
return 0;
case EV_PROTO_ONMENU:
this->OnInitStatusMenu();
break;
}
return 1;
}
int CSteamProto::AuthRequest(MCONTACT hContact, const TCHAR*)
{
if (IsOnline() && hContact)
{
UINT hAuth = InterlockedIncrement(&hAuthProcess);
SendAuthParam *param = (SendAuthParam*)mir_calloc(sizeof(SendAuthParam));
param->hContact = hContact;
param->hAuth = (HANDLE)hAuth;
//ForkThread(&CSteamProto::AddContactThread, param);
ptrA token(getStringA("TokenSecret"));
ptrA sessionId(getStringA("SessionID"));
ptrA steamId(getStringA("SteamID"));
ptrA who(getStringA(hContact, "SteamID"));
/*
posilame: (kdyz my zadame)
sessionID MjYzNDM4NDgw
steamid 76561198166125402
accept_invite 0
pri uspesnem pozadavku vrati: {"invited":["76561198166125402"],"success":1}
kdyz nas ignoruje: {"failed_invites":["76561198166125402"],"failed_invites_result":[41],"success":1}
*/
PushRequest(
new AddFriendRequest(token, sessionId, steamId, who),
&CSteamProto::OnFriendAdded,
param);
return hAuth;
}
return 1;
}
bool CFriends::HasFriend(SteamID steamIDFriend, s32 friendFlags)
{
CSteamID steamId(steamIDFriend);
return friends->HasFriend(steamId, friendFlags);
}
PConstantUtf8String CFriends::GetFriendPersonaNameHistory(SteamID steamIDFriend, s32 personaName)
{
CSteamID steamId(steamIDFriend);
return friends->GetFriendPersonaNameHistory(steamId, personaName);
}
bool CFriends::GetFriendGamePlayed(SteamID steamIDFriend, PDataPointer friendGameInfo)
{
CSteamID steamId(steamIDFriend);
return friends->GetFriendGamePlayed(steamId, reinterpret_cast<FriendGameInfo_t *>(friendGameInfo));
}
PConstantUtf8String CFriends::GetFriendPersonaName(SteamID steamIDFriend)
{
CSteamID steamId(steamIDFriend);
return friends->GetFriendPersonaName(steamId);
}
Enum CFriends::GetFriendPersonaState(SteamID steamIDFriend)
{
CSteamID steamId(steamIDFriend);
return friends->GetFriendPersonaState(steamId);
}
Enum CFriends::GetFriendRelationship(SteamID steamIDFriend)
{
CSteamID steamId(steamIDFriend);
return friends->GetFriendRelationship(steamId);
}
SteamID CFriends::GetFriendFromSourceByIndex(SteamID steamIDSource, s32 friendIndex)
{
CSteamID steamId(steamIDSource);
CSteamID resultId = friends->GetFriendFromSourceByIndex(steamId, friendIndex);
return resultId.ConvertToUint64();
}
bool CFriends::GetClanActivityCounts(SteamID steamIDClan, s32 *online, s32 *inGame, s32 *chatting)
{
CSteamID steamId(steamIDClan);
return friends->GetClanActivityCounts(steamId, online, inGame, chatting);
}
PConstantString CFriends::GetClanTag(SteamID steamIDClan)
{
CSteamID steamId(steamIDClan);
return friends->GetClanTag(steamId);
}
void CSteamProto::ParsePollData(JSONNode *data)
{
JSONNode *node, *item = NULL;
std::string steamIds;
for (size_t i = 0; i < json_size(data); i++)
{
item = json_at(data, i);
if (item == NULL)
break;
node = json_get(item, "steamid_from");
ptrA steamId(mir_t2a(ptrT(json_as_string(node))));
node = json_get(item, "utc_timestamp");
time_t timestamp = atol(ptrA(mir_t2a(ptrT(json_as_string(node)))));
node = json_get(item, "type");
ptrT type(json_as_string(node));
if (!lstrcmpi(type, _T("saytext")) || !lstrcmpi(type, _T("emote")) ||
!lstrcmpi(type, _T("my_saytext")) || !lstrcmpi(type, _T("my_emote")))
{
MCONTACT hContact = FindContact(steamId);
if (!hContact)
continue;
node = json_get(item, "text");
ptrT text(json_as_string(node));
T2Utf szMessage(text);
if (_tcsstr(type, _T("my_")) == NULL)
{
PROTORECVEVENT recv = { 0 };
recv.timestamp = timestamp;
recv.szMessage = szMessage;
ProtoChainRecvMsg(hContact, &recv);
}
else
{
AddDBEvent(hContact, EVENTTYPE_MESSAGE, timestamp, DBEF_UTF | DBEF_SENT, (int)mir_strlen(szMessage) + 1, (PBYTE)(char*)szMessage);
}
}
else if (!lstrcmpi(type, _T("typing")))
{
MCONTACT hContact = FindContact(steamId);
if (hContact)
{
CallService(MS_PROTO_CONTACTISTYPING, hContact, (LPARAM)STEAM_TYPING_TIME);
}
}
else if (!lstrcmpi(type, _T("personastate")))
{
node = json_get(item, "persona_state");
int status = node ? SteamToMirandaStatus(json_as_int(node)) : -1;
if (IsMe(steamId))
{
node = json_get(item, "persona_name");
setTString("Nick", ptrT(json_as_string(node)));
if (status == -1 || status == ID_STATUS_OFFLINE)
continue;
if (status != m_iStatus)
{
debugLog(_T("CSteamProto::ParsePollData: Change own status to %i"), status);
int oldStatus = m_iStatus;
m_iStatus = m_iDesiredStatus = status;
ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus);
}
continue;
}
MCONTACT hContact = FindContact(steamId);
if (hContact == NULL)
continue; // probably this is info about random player playing on same server, so we ignore it
if (status != -1)
SetContactStatus(hContact, status);
node = json_get(item, "persona_name");
setTString(hContact, "Nick", ptrT(json_as_string(node)));
// todo: find difference between state changing and info changing
steamIds.append(steamId).append(",");
}
else if (!lstrcmpi(type, _T("personarelationship")))
{
node = json_get(item, "persona_state");
int state = json_as_int(node);
switch (state)
{
case 0:
{// removed
MCONTACT hContact = FindContact(steamId);
if (hContact)
{
ContactIsRemoved(hContact);
}
}
break;
case 1:
{// ignored
MCONTACT hContact = FindContact(steamId);
if (hContact)
{
ContactIsIgnored(hContact);
}
}
break;
case 2:
{// auth request
/*MCONTACT hContact = FindContact(steamId);
if (!hContact)
hContact = AddContact(steamId, true);*/
//RaiseAuthRequestThread((void*)hContact);
ptrA token(getStringA("TokenSecret"));
PushRequest(
new GetUserSummariesRequest(token, steamId),
&CSteamProto::OnAuthRequested,
mir_strdup(steamId),
MirFreeArg);
}
break;
case 3:
// add to list
// todo
break;
default: continue;
}
}
/*else if (!lstrcmpi(type, _T("leftconversation")))
{
}*/
else
{
continue;
}
}
if (!steamIds.empty())
{
steamIds.pop_back();
ptrA token(getStringA("TokenSecret"));
PushRequest(
new GetUserSummariesRequest(token, steamIds.c_str()),
&CSteamProto::OnGotUserSummaries);
}
}
s32 CFriends::GetFriendCountFromSource(SteamID steamIDSource)
{
CSteamID steamId(steamIDSource);
return friends->GetFriendCountFromSource(steamId);
}
void CFriends::ActivateGameOverlayInviteDialog(SteamID steamIDLobby)
{
CSteamID steamId(steamIDLobby);
friends->ActivateGameOverlayInviteDialog(steamId);
}
