Poco::SharedPtr<MessageData> Util::dataFromMessage(const MessageRef &message) { int messageType = message->GetProp(Message::P_TYPE).toInt(); SEString author; SEString authorName; SEString bodyXmlString; unsigned int timeStamp; message->GetPropAuthor(author); message->GetPropAuthorDisplayname(authorName); message->GetPropBodyXml(bodyXmlString); message->GetPropTimestamp(timeStamp); Poco::SharedPtr<MessageData> data = new MessageData; data->author = author.data(); data->authorDisplayname = authorName.data(); data->body = bodyXmlString.data(); data->timestamp = timeStamp; data->isEmote = (messageType == Message::POSTED_EMOTE); return data; }
void SkypeContact::OnChange(int prop) { /* Here is the place where you can capture all property changes when they * happen. It's important to know that this method will receive ALL changes * from ALL properties, which means that it's necessary to create a nice and * robust filter inside this method to handle each type of property, * otherwise it can fail by acting incorrectly or even lose some events. * * Another interesting thing is that this method does not receive the new * value of the changed property. It's necessary to get the value from the * Contact class itself, because once this method is called the property is * already changed in the class. */ /* For our Contact class we will ony watch for the following * properties: * * - Contact::P_AVAILABILITY : Changes when the online status is set. * - Contact::P_DISPLAYNAME : Changes when a new Display Name is set. * - Contact::P_SKYPENAME : Changes when the skypename is updated. */ if (prop == Contact::P_AVAILABILITY || prop == Contact::P_DISPLAYNAME || prop == Contact::P_SKYPENAME) { // Let's log that it has changed! SEString skypeName; GetPropSkypename(skypeName); printf("%s: Contact's property changed.\n", skypeName.data()); /* And then notify the other interested objects that some of these * properties have changed. */ ContactRef ref = this->ref(); contactChanged(this, ref); } }
const Poco::SharedPtr<ContactData> Util::dataFromAccount(const AccountRef &account) { Poco::SharedPtr<ContactData> data(0); data = Poco::SharedPtr<ContactData>(new ContactData); SEString value; // Get the Skype Name from the account. account->GetPropSkypename(value); data->skypeName = value.data(); // Get the Display Name from the account. account->GetPropFullname(value); data->displayName = value; /* Get the availability from the Account and translate it to a readable * string. */ Contact::AVAILABILITY availability; account->GetPropAvailability(availability); std::pair<ContactAvailability, std::string> ret = convertAvailability(availability); data->status = ret.first; data->availability = ret.second; //Get the contact Avatar. SEBinary rawData; if (account->GetPropAvatarImage(rawData) && rawData.size() > 0) data->avatar.assignRaw(rawData.data(), rawData.size()); return data; }
void ConvManagerService::setParticipants( const std::vector<std::string> &participantSkypeNames) { // Get the new participants. unsigned int newSkypeNamesSize = participantSkypeNames.size(); std::vector<std::string> newSkypeNames = participantSkypeNames; // Get the current participants. ParticipantRefs currentSkypeNames; m_conversation->GetParticipants(currentSkypeNames, Conversation::OTHER_CONSUMERS); unsigned int currentSkypeNamesSize = currentSkypeNames.size(); // Check which participant needs to be added to the conversation. SEStringList addSkypeNames; for (unsigned int i = 0; i < newSkypeNamesSize; ++i) { bool contain = false; for (unsigned int j = 0; j < currentSkypeNamesSize; ++j) { SEString oid; currentSkypeNames[j]->GetPropIdentity(oid); if (newSkypeNames[i] == oid.data()) { if (m_conversationMode == Call) currentSkypeNames[j]->Ring(); contain = true; break; } } if (!contain) addSkypeNames.append(SEString(newSkypeNames[i].c_str())); } // Check which participant needs to be removed from the conversation. ParticipantRefs remSkypeNames; for (unsigned int i = 0; i < currentSkypeNamesSize; ++i) { bool contain = false; for (unsigned int j = 0; j < newSkypeNamesSize; ++j) { SEString oid; currentSkypeNames[i]->GetPropIdentity(oid); if (oid.data() == newSkypeNames[j]) { contain = true; break; } } if (!contain) remSkypeNames.append(currentSkypeNames[i]); } SkypeConversation::Ref newConversation; Conversation::TYPE type; m_conversation->GetPropType(type); // Pass the skypename string into addConsumers if (type == Conversation::DIALOG) { if (m_conversation->SpawnConference(addSkypeNames, newConversation)) printf("spawned conference from conversation\n"); else printf("error spawning conference from conversation\n"); } else { // Add new participants to the conference. if (m_conversation->AddConsumers(addSkypeNames)) printf("added participants to conversation\n"); else printf("error adding participants to conversation\n"); // Remove old participants from the conference. unsigned int remSize = remSkypeNames.size(); for (unsigned int i = 0; i < remSize; ++i) { SEString oid; remSkypeNames[i]->GetPropIdentity(oid); if (m_conversationMode == Chat) { if (!remSkypeNames[i]->Retire()) printf("error retiring participant form conversation\n"); } else { if (!remSkypeNames[i]->Hangup()) printf("error removing participant form conversation\n"); } } } }
std::string ConvManagerState::id() const { SEString identity; m_conversation->GetPropIdentity(identity); return std::string("ConvManagerState_") + identity.data(); }