Module Skype

Source Code for Module Skype

   1  # -*- coding: utf-8 -*- 
   2  # module Skype 
   3  import skypekit 
   4  import warnings 
   5  module_id2classes = {} 
6 7 -class ContactGroup(skypekit.Object):
8 """ 9 Collects and manages Contacts related by type, status, or some other arbitrary criteria. SkypeKit recognizes two distinct ContactGroup flavors - "hardwired" and "custom". SkypeKit both defines the criteria for and dynamically manages all "hardwired" ContactGroups. Individual users explicitly create and manage all "custom" ContactGroups. 10 11 "Hardwired" groups are primarily organizational tools, for example, they enable you to display a list of all Contacts awaiting authorization by you. "Custom" groups are also organizational tools, for example, they enable you to display a list of all Contacts in a particular geographical area or belonging to a particular professional association, social clubs, and so forth. Primarily, though, "custom" groups are functional tools that enable you to establish conference calls, group chats, and so forth. 12 13 "Hardwired" ContactGroups are defined for and available to all users. SkypeKit determines membership in a particular "hardwired" group dynamically whenever a user invokes Skype.GetHardwiredContactGroup for that group. Subsequent changes to a Contact's status might result in its being added to (for example, the Contact is now authorized) or removed from (for example, the Contact is now removed or blocked) one or more "hardwired" groups. 14 15 SkypeKit fires OnChange events for all affected ContractGroup instances. Essentially all ContactGroup methods related to explicitly adding and removing members and conversations from the group return false, and CanAdd and CanRemove additionally return a false result. 16 17 "Custom" ContactGroups can be defined by a particular Skype user through the UI. Your UI should implement Creation, deletion and filtering contact list by custom contact groups, as well as adding and removing contacts in those groups. 18 19 A Contact can belong to multiple non-mutually exclusive "hardwired" groups at the same time, for example, an authorized contact is typically in your "buddy" group, but a Contact cannot belong to CONTACTS_AUTHORIZED_BY_ME if they are awaiting authorization. Similarly, a Contact can belong to multiple "custom" groups and mutual exclusivity is typically not an issue. 20 21 """ 22 event_handlers = {} 23 propid2label = {}
24 - def _sk_init_(self, object_id, transport):
25 """ actual constructor """ 26 skypekit.Object._sk_init_(self, object_id, transport)
27 - def __str__(self):
28 return "ContactGroup %s" % (self.object_id, )
29 @staticmethod
30 - def propid(propname):
31 """ convert a property name to the enum of the property """ 32 return getattr(ContactGroup, "P_"+propname.upper())
33 module_id = 10
34 - def OnPropertyChange(self, property_name):
35 """ notifies from a property change """ 36 37 pass
38 TYPE = { 39 1 :'ALL_KNOWN_CONTACTS', 40 2 :'ALL_BUDDIES', 41 3 :'SKYPE_BUDDIES', 42 4 :'SKYPEOUT_BUDDIES', 43 5 :'ONLINE_BUDDIES', 44 6 :'UNKNOWN_OR_PENDINGAUTH_BUDDIES', 45 7 :'RECENTLY_CONTACTED_CONTACTS', 46 8 :'CONTACTS_WAITING_MY_AUTHORIZATION', 47 9 :'CONTACTS_AUTHORIZED_BY_ME', 48 10:'CONTACTS_BLOCKED_BY_ME', 49 11:'UNGROUPED_BUDDIES', 50 12:'CUSTOM_GROUP', 51 13:'PROPOSED_SHARED_GROUP', 52 14:'SHARED_GROUP', 53 15:'EXTERNAL_CONTACTS', 54 'ALL_KNOWN_CONTACTS' : 1, 55 'ALL_BUDDIES' : 2, 56 'SKYPE_BUDDIES' : 3, 57 'SKYPEOUT_BUDDIES' : 4, 58 'ONLINE_BUDDIES' : 5, 59 'UNKNOWN_OR_PENDINGAUTH_BUDDIES' : 6, 60 'RECENTLY_CONTACTED_CONTACTS' : 7, 61 'CONTACTS_WAITING_MY_AUTHORIZATION' : 8, 62 'CONTACTS_AUTHORIZED_BY_ME' : 9, 63 'CONTACTS_BLOCKED_BY_ME' :10, 64 'UNGROUPED_BUDDIES' :11, 65 'CUSTOM_GROUP' :12, 66 'PROPOSED_SHARED_GROUP' :13, 67 'SHARED_GROUP' :14, 68 'EXTERNAL_CONTACTS' :15 69 } 70 """ 71 The list of all possible ContactGroup types. A value of this type can be passed to Skype class GetHardwiredContactGroup to retrieve the relevant ContactGroup object. 72 73 - ALL_KNOWN_CONTACTS - The superset of all "hardwired" contact groups. 74 75 - ALL_BUDDIES - The set of all authorized contacts, that is, contacts that were last the target of Contact::SetBuddyStatus(false) plus all SkypeOut contacts. 76 77 - SKYPE_BUDDIES - The set of all authorized Skype contacts (Contact:_SKYPENAME is non-null). 78 Note that this excludes Skype contacts that have either never been the target of Contact::SetBuddyStatus(true) or were last the target of Contactact::SetBuddyStatus(false). 79 80 - SKYPEOUT_BUDDIES - The set of all SkypeOut contacts (Contact:_PSTNNUMBER is non-null). PSTN contacts can be added to the contact list by retrieving a new contact object with Skype::GetContact, passing in the phone number as string, and then either using Contact::SetBuddyStatus(true) or adding the contact to the SKYPEOUT_BUDDIES group with ContactGroup::AddContact. 81 82 - ONLINE_BUDDIES - The subset of ALL_BUDDIES that are currently online, including those currently marked as DO_NOT_DISTURBED and AWAY. 83 84 - UNKNOWN_OR_PENDINGAUTH_BUDDIES - The set of all contacts whose Contact:_TYPE reflects UNRECOGNIZED OR have not authorized the local user yet. 85 86 - RECENTLY_CONTACTED_CONTACTS - This filter returns top 10 most recently contacted contacts, based on Contact::P_LASTUSED_TIMESTAMP property values. This is not configurable. Note that the P_LASTUSED_TIMESTAMP property does not propagate between different Skype instances - thus this filter only works in context of the local database. Recent contacts that were in touch with the user on some other Skype installation will not show up in this filter. 87 88 - CONTACTS_WAITING_MY_AUTHORIZATION - Contacts to whose authorization request the user has not responded yet. The UI should enable the user to accept, decline the authorization request and in case of decline, optionally block further incoming communication from the contact. See: Contact::SetBuddyStatus, Contact::SetBlocked and Contact::IgnoreAuthRequest for more information. 89 90 - CONTACTS_AUTHORIZED_BY_ME - All contacts authorized by the user. 91 92 - CONTACTS_BLOCKED_BY_ME - Group of contacts the user has blocked from further incoming communications. If the UI enables contact blocking, it should also provide interface for the user to unblock the blocked contacts. Note that a contact can simultaneously be in both CONTACTS_BLOCKED_BY_ME and CONTACTS_AUTHORIZED_BY_ME groups. 93 94 - UNGROUPED_BUDDIES - The set of all "buddies" that are not also a member of a custom group. 95 96 - CUSTOM_GROUP - A custom group defined by user. 97 98 - PROPOSED_SHARED_GROUP - The shared contact group functionality is no longer supported. This contact group type can be ignored. 99 100 - SHARED_GROUP - The shared contact group functionality is no longer supported. This contact group type can be ignored. 101 102 - EXTERNAL_CONTACTS - The set of all contacts that were originally imported from an external address book. 103 104 """ 105
106 - def _sk_get_type(self):
107 """ 108 ContactGroup::TYPE 109 """ 110 return skypekit.enumof(ContactGroup.TYPE, self._sk_property("ZG\233\001]\012", 155, True))
111 type = property(_sk_get_type) 112 propid2label[155] = "type" 113 P_TYPE = 155
114 - def _sk_get_custom_group_id(self):
115 """ 116 unique 32-bit ID for custom groups 117 """ 118 return self._sk_property("ZG\232\001]\012", 154, True)
119 custom_group_id = property(_sk_get_custom_group_id) 120 propid2label[154] = "custom_group_id" 121 P_CUSTOM_GROUP_ID = 154
122 - def _sk_get_given_displayname(self):
123 """ 124 change via ContactGroup::GiveDisplayname() 125 """ 126 return self._sk_property("ZG\227\001]\012", 151, True)
127 given_displayname = property(_sk_get_given_displayname) 128 propid2label[151] = "given_displayname" 129 P_GIVEN_DISPLAYNAME = 151
130 - def _sk_get_nrofcontacts(self):
131 """ 132 Number of contacts in the group. NB! The value of this property does not get updated until 5 seconds after account login. During these initial 5 seconds, the value of this property remains 0. The reason for this 5 second delay is to reduce the flurry of property update traffic that occurs during the CBL synchronization phase, following successful login. Note that if you absolutely need to have this value immediately after login, you can still get it by retrieving the contact list with ContactGroup::GetContacts method and examining its size. 133 134 """ 135 return self._sk_property("ZG\230\001]\012", 152, True)
136 nrofcontacts = property(_sk_get_nrofcontacts) 137 propid2label[152] = "nrofcontacts" 138 P_NROFCONTACTS = 152
140 """ 141 number of contacts online in the group 142 """ 143 return self._sk_property("ZG\231\001]\012", 153, True)
144 nrofcontacts_online = property(_sk_get_nrofcontacts_online) 145 propid2label[153] = "nrofcontacts_online" 146 P_NROFCONTACTS_ONLINE = 153 147
148 - def GiveDisplayName( 149 self, 150 name 151 ):
152 """ 153 Setter for ContactGroup class GIVEN_DISPLAYNAME property. 154 155 156 B{Arguments:} 157 - B{name} 158 """ 159 l_request = skypekit.XCallRequest("ZR\012\001", 10, 1) 160 l_request.add_parm('O', 0, self) 161 l_request.add_parm('S', 1, name) 162 self.transport.xcall(l_request)
163 - def Delete(self):
164 """ 165 Removes the contact group. This is synced across instances logged in with the same account - which can take several minutes for the sync to happen. 166 167 168 B{Return values:} 169 - B{result} 170 """ 171 l_request = skypekit.XCallRequest("ZR\012\002", 10, 2) 172 l_request.add_parm('O', 0, self) 173 l_response = self.transport.xcall(l_request) 174 l_result = l_response.get(1, False) 175 return l_result
176 - def GetConversations(self):
177 """ 178 Returns list of conversations in the ContactGroup. 179 180 181 B{Return values:} 182 - B{conversations} 183 """ 184 l_request = skypekit.XCallRequest("ZR\012\003", 10, 3) 185 l_request.add_parm('O', 0, self) 186 l_response = self.transport.xcall(l_request) 187 l_result = [module_id2classes[18](oid, self.transport) for oid in l_response.get(1, [])] 188 return l_result
189 - def CanAddConversation( 190 self, 191 conversation = 0 192 ):
193 """ 194 Checks if the current user can add given conversation to the ContactGroup. Returns false for most of the hardwired contact groups for example. 195 196 197 B{Arguments:} 198 - B{conversation} - Conversation to be checked. 199 200 201 B{Return values:} 202 - B{result} - Returns true if Conversation can be added to this ContactGroup. 203 204 """ 205 l_request = skypekit.XCallRequest("ZR\012\004", 10, 4) 206 l_request.add_parm('O', 0, self) 207 l_request.add_parm('O', 1, conversation) 208 l_response = self.transport.xcall(l_request) 209 l_result = l_response.get(1, False) 210 return l_result
211 - def AddConversation( 212 self, 213 conversation 214 ):
215 """ 216 Adds given conversation to the ContactGroup. 217 218 219 B{Arguments:} 220 - B{conversation} 221 """ 222 l_request = skypekit.XCallRequest("ZR\012\005", 10, 5) 223 l_request.add_parm('O', 0, self) 224 l_request.add_parm('O', 1, conversation) 225 self.transport.xcall(l_request)
226 - def CanRemoveConversation(self):
227 """ 228 Checks if the current user can remove given conversation from the ContactGroup. Again, returns false for most hardwired contact groups. 229 230 231 B{Return values:} 232 - B{result} - true if RemoveConversation(contact) works on this group 233 """ 234 l_request = skypekit.XCallRequest("ZR\012\006", 10, 6) 235 l_request.add_parm('O', 0, self) 236 l_response = self.transport.xcall(l_request) 237 l_result = l_response.get(1, False) 238 return l_result
239 - def RemoveConversation( 240 self, 241 conversation 242 ):
243 """ 244 Removes given conversation from the ContactGroup. 245 246 247 B{Arguments:} 248 - B{conversation} 249 """ 250 l_request = skypekit.XCallRequest("ZR\012\007", 10, 7) 251 l_request.add_parm('O', 0, self) 252 l_request.add_parm('O', 1, conversation) 253 self.transport.xcall(l_request)
254 - def OnChangeConversation( 255 self, 256 conversation 257 ):
258 """ 259 conversation added or removed from this group 260 261 B{Return values:} 262 - B{conversation} 263 """ 264 pass
265 event_handlers[1] = "_sk_on_change_conversation"
266 - def _sk_on_change_conversation(self, parms):
267 """ internal event dispatcher for OnChangeConversation """ 268 l_cleanparms = module_id2classes[18](parms.get(1), self.transport) 269 self.OnChangeConversation(l_cleanparms)
270 - def GetContacts(self):
271 """ 272 Retrieves contact list. 273 274 275 B{Return values:} 276 - B{contacts} 277 """ 278 l_request = skypekit.XCallRequest("ZR\012\010", 10, 8) 279 l_request.add_parm('O', 0, self) 280 l_response = self.transport.xcall(l_request) 281 l_result = [module_id2classes[2](oid, self.transport) for oid in l_response.get(1, [])] 282 return l_result
283 - def CanAddContact( 284 self, 285 contact = 0 286 ):
287 """ 288 Checks if the current user can add given contact to the ContactGroup. 289 290 291 B{Arguments:} 292 - B{contact} - Contact to be checked. 293 294 295 B{Return values:} 296 - B{result} - returns true if AddContact(contact) works on this group. 297 298 """ 299 l_request = skypekit.XCallRequest("ZR\012\011", 10, 9) 300 l_request.add_parm('O', 0, self) 301 l_request.add_parm('O', 1, contact) 302 l_response = self.transport.xcall(l_request) 303 l_result = l_response.get(1, False) 304 return l_result
305 - def AddContact( 306 self, 307 contact 308 ):
309 """ 310 Adds contact to a contact group. This only works for non-hardwired contact groups. 311 312 313 B{Arguments:} 314 - B{contact} 315 """ 316 l_request = skypekit.XCallRequest("ZR\012\012", 10, 10) 317 l_request.add_parm('O', 0, self) 318 l_request.add_parm('O', 1, contact) 319 self.transport.xcall(l_request)
320 - def CanRemoveContact(self):
321 """ 322 Checks if the current user can remove given contact from the ContactGroup. 323 324 325 B{Return values:} 326 - B{result} - true if RemoveContact(contact) works on this group 327 """ 328 l_request = skypekit.XCallRequest("ZR\012\013", 10, 11) 329 l_request.add_parm('O', 0, self) 330 l_response = self.transport.xcall(l_request) 331 l_result = l_response.get(1, False) 332 return l_result
333 - def RemoveContact( 334 self, 335 contact 336 ):
337 """ 338 Removes contact from the ContactGroup. 339 340 341 B{Arguments:} 342 - B{contact} 343 """ 344 l_request = skypekit.XCallRequest("ZR\012\014", 10, 12) 345 l_request.add_parm('O', 0, self) 346 l_request.add_parm('O', 1, contact) 347 self.transport.xcall(l_request)
348 - def OnChange( 349 self, 350 contact 351 ):
352 """ 353 A contact has been added or removed to this ContactGroup. 354 NB! On rare occasions, the ContectRef argument to this callback can be NULL. You should always check whether the reference is valid, before accessing methods or properties. 355 356 357 B{Return values:} 358 - B{contact} 359 """ 360 pass
361 event_handlers[2] = "_sk_on_change"
362 - def _sk_on_change(self, parms):
363 """ internal event dispatcher for OnChange """ 364 l_cleanparms = module_id2classes[2](parms.get(1), self.transport) 365 self.OnChange(l_cleanparms)
366 module_id2classes[10] = ContactGroup
367 368 -class Contact(skypekit.Object):
369 """ 370 Address book entry. Encapsulates methods like GetIdentity, GetAvatar, SendAuthRequest, OpenConversation etc. Single contact can have additional phone numbers attached to it (ASSIGNED_PHONE1 .. ASSIGNED_PHONE3). Note that in the context of a conversation, Contacts are represented by Participant objects. Contact member functions all return a Boolean indicating the success (true) or failure (false) of processing the request itself (transport, runtime availability, and so forth)?not the success or failure of its associated functionality. For example, Contact::IsMemberOf returns true if it was able to make a determination, and its result parameter reflects whether this Contact is a member of the target group. Similarly, Contact::IsMemberOf returns false if it was unable to make a determination, and the value of its result parameter is undefined. 371 372 """ 373 event_handlers = {} 374 propid2label = {}
375 - def _sk_init_(self, object_id, transport):
376 """ actual constructor """ 377 skypekit.Object._sk_init_(self, object_id, transport)
378 - def __str__(self):
379 return "Contact %s" % (self.object_id, )
380 @staticmethod
381 - def propid(propname):
382 """ convert a property name to the enum of the property """ 383 return getattr(Contact, "P_"+propname.upper())
384 module_id = 2
385 - def OnPropertyChange(self, property_name):
386 """ notifies from a property change """ 387 388 pass
389 TYPE = {0:'UNRECOGNIZED', 'UNRECOGNIZED':0, 1:'SKYPE', 'SKYPE':1, 2:'PSTN', 'PSTN':2, 3:'EMERGENCY_PSTN', 'EMERGENCY_PSTN':3, 4:'FREE_PSTN', 'FREE_PSTN':4, 5:'UNDISCLOSED_PSTN', 'UNDISCLOSED_PSTN':5, 6:'EXTERNAL', 'EXTERNAL':6} 390 """ 391 Same as with CAPABILITY, enumerator is used by both Contact and Account objects. 392 393 - UNRECOGNIZED - Contact/account has no pre-identified type. This type is reported by default for SkypeKit clients. 394 395 - SKYPE - Normal Skype contact. 396 397 - PSTN - Normal PSTN contact. 398 399 - EMERGENCY_PSTN - Emergency number (i.e. 911). 400 401 - FREE_PSTN 402 - UNDISCLOSED_PSTN - Undisclosed PSTN number. 403 404 - EXTERNAL - This type is currently used by Windows desktop clients for contacts imported from Outlook. 405 406 """ 407 AUTHLEVEL = {0:'NONE', 'NONE':0, 1:'AUTHORIZED_BY_ME', 'AUTHORIZED_BY_ME':1, 2:'BLOCKED_BY_ME', 'BLOCKED_BY_ME':2} 408 """ 409 Describes the recognized relational states between a local account and a remote contact. 410 411 - NONE - Authorization request is either ignored or pending. In this state several functionalities may be blocked, depending on settings. For example, accounts may only allow seeing online presence to be viewable or only receive calls from authorized contacts. 412 413 - AUTHORIZED_BY_ME - Contact has been authorized by the local account. 414 415 - BLOCKED_BY_ME - Contact has been blocked by the local account. This prevents incoming calls, chat messages, additional authorization requests etc. 416 417 """ 418 AVAILABILITY = { 419 0 :'UNKNOWN', 420 8 :'PENDINGAUTH', 421 9 :'BLOCKED', 422 11:'BLOCKED_SKYPEOUT', 423 10:'SKYPEOUT', 424 1 :'OFFLINE', 425 12:'OFFLINE_BUT_VM_ABLE', 426 13:'OFFLINE_BUT_CF_ABLE', 427 2 :'ONLINE', 428 3 :'AWAY', 429 4 :'NOT_AVAILABLE', 430 5 :'DO_NOT_DISTURB', 431 7 :'SKYPE_ME', 432 6 :'INVISIBLE', 433 14:'CONNECTING', 434 15:'ONLINE_FROM_MOBILE', 435 16:'AWAY_FROM_MOBILE', 436 17:'NOT_AVAILABLE_FROM_MOBILE', 437 18:'DO_NOT_DISTURB_FROM_MOBILE', 438 20:'SKYPE_ME_FROM_MOBILE', 439 'UNKNOWN' : 0, 440 'PENDINGAUTH' : 8, 441 'BLOCKED' : 9, 442 'BLOCKED_SKYPEOUT' :11, 443 'SKYPEOUT' :10, 444 'OFFLINE' : 1, 445 'OFFLINE_BUT_VM_ABLE' :12, 446 'OFFLINE_BUT_CF_ABLE' :13, 447 'ONLINE' : 2, 448 'AWAY' : 3, 449 'NOT_AVAILABLE' : 4, 450 'DO_NOT_DISTURB' : 5, 451 'SKYPE_ME' : 7, 452 'INVISIBLE' : 6, 453 'CONNECTING' :14, 454 'ONLINE_FROM_MOBILE' :15, 455 'AWAY_FROM_MOBILE' :16, 456 'NOT_AVAILABLE_FROM_MOBILE' :17, 457 'DO_NOT_DISTURB_FROM_MOBILE' :18, 458 'SKYPE_ME_FROM_MOBILE' :20 459 } 460 """ 461 Describes the superset list of possible Account and Contact online statuses. In case of Account they apply to local user, in case of Contact they apply to remote contacts. 462 463 - UNKNOWN - Contact online status cannot be determined. This availability state should not normally reach the SkypeKit UI level. 464 465 - PENDINGAUTH - Seeing Contact online status is blocked because authorization between contact and local account has not taken place. 466 467 - BLOCKED - Remote contact has been blocked by local account. This applies to online accounts. 468 469 - BLOCKED_SKYPEOUT - Remote SkypeOut contact has been blocked by local account. 470 471 - SKYPEOUT - Contact does not have an online status because he is a PSTN contact. 472 473 - OFFLINE - Contact appears to be offline. 474 475 - OFFLINE_BUT_VM_ABLE - Contact appears to be offline but has voicemail enabled. 476 477 - OFFLINE_BUT_CF_ABLE - Contact appears to be offline but has enabled call forwarding, so calls may actually get through to him. 478 479 - ONLINE - Contact / Account is online 480 481 - AWAY - Contact / Account is online but away from keyboard. This can be either turned on manually or by automatic timer. In Windows desktop client, the timer can be configured with minute precision. 482 483 - NOT_AVAILABLE - This online status is marked as deprecated. If a remote contact indicates its status as NOT_AVAILABLE, the UI should handle this as equivalent of AWAY status. 484 485 - DO_NOT_DISTURB - Contact / Account is online but does not wish to be disturbed. This status supersedes AWAY status when the account is DO_NOT_DISTURB the AWAY timer should not modify the status. 486 487 - SKYPE_ME - This online status is marked as deprecated. If a remote contact indicates its status as SKYPE_ME, the UI should handle this as equivalent of ONLINE status. 488 489 - INVISIBLE - Account status is set to INVISIBLE. This status in not applicable to remote Contacts. When the remote contact has set his availability to INVISIBLE, he will appear as OFFLINE to others. 490 491 - CONNECTING - only possible for local user/account 492 - ONLINE_FROM_MOBILE 493 - AWAY_FROM_MOBILE - *_FROM_MOBILE only possible for remote user 494 - NOT_AVAILABLE_FROM_MOBILE 495 - DO_NOT_DISTURB_FROM_MOBILE 496 - SKYPE_ME_FROM_MOBILE 497 """ 498 EXTRA_AUTHREQ_FIELDS = {1:'SEND_VERIFIED_EMAIL', 'SEND_VERIFIED_EMAIL':1, 2:'SEND_VERIFIED_COMPANY', 'SEND_VERIFIED_COMPANY':2} 499 """ 500 - SEND_VERIFIED_EMAIL - send verified e-mail blob with this auth request 501 - SEND_VERIFIED_COMPANY - send verified company blob with this auth request 502 """ 503 CAPABILITY = { 504 0 :'CAPABILITY_VOICEMAIL', 505 1 :'CAPABILITY_SKYPEOUT', 506 2 :'CAPABILITY_SKYPEIN', 507 3 :'CAPABILITY_CAN_BE_SENT_VM', 508 4 :'CAPABILITY_CALL_FORWARD', 509 5 :'CAPABILITY_VIDEO', 510 6 :'CAPABILITY_TEXT', 511 7 :'CAPABILITY_SERVICE_PROVIDER', 512 8 :'CAPABILITY_LARGE_CONFERENCE', 513 9 :'CAPABILITY_COMMERCIAL_CONTACT', 514 10:'CAPABILITY_PSTN_TRANSFER', 515 11:'CAPABILITY_TEXT_EVER', 516 12:'CAPABILITY_VOICE_EVER', 517 13:'CAPABILITY_MOBILE_DEVICE', 518 14:'CAPABILITY_PUBLIC_CONTACT', 519 'CAPABILITY_VOICEMAIL' : 0, 520 'CAPABILITY_SKYPEOUT' : 1, 521 'CAPABILITY_SKYPEIN' : 2, 522 'CAPABILITY_CAN_BE_SENT_VM' : 3, 523 'CAPABILITY_CALL_FORWARD' : 4, 524 'CAPABILITY_VIDEO' : 5, 525 'CAPABILITY_TEXT' : 6, 526 'CAPABILITY_SERVICE_PROVIDER' : 7, 527 'CAPABILITY_LARGE_CONFERENCE' : 8, 528 'CAPABILITY_COMMERCIAL_CONTACT' : 9, 529 'CAPABILITY_PSTN_TRANSFER' :10, 530 'CAPABILITY_TEXT_EVER' :11, 531 'CAPABILITY_VOICE_EVER' :12, 532 'CAPABILITY_MOBILE_DEVICE' :13, 533 'CAPABILITY_PUBLIC_CONTACT' :14 534 } 535 """ 536 This enumerator is used by both Contact and Account objects. Thus the items here can have slightly different meaning, depending on which context you will examine their values. In case of Contact, the values apply to a user - across all the instances that user has logged in with Skype. In case of Account, the capability is that of a local, currently logged in instance of Skype client. 537 538 The values that CAPABILITY items can have are also dependant on class context. In context of Contact, a capability can be CAPABILITY_MIXED. Which in case of CAPABILITY_VIDEO, for example, would mean that the remote use has logged in with different clients, some of which support video calls and some of which don't. In context of Account - there are no mixed result. Currently logged in Skype instance either supports video or it doesn't. 539 540 - CAPABILITY_VOICEMAIL - For Account object, this is the same as CAPABILITY_CAN_BE_SENT_VM - it indicates that the currently logged in Skype instance supports voicemails. For Contact objects, it means that their remote system supports sending voicemails - there is no technical method for Skype to detect whether they are capable of receiving voicemails, so the assumption is that they can. 541 542 - CAPABILITY_SKYPEOUT - Indicates that the contact/account has SkypeOut and is thus capable of making PSTN calls. 543 544 - CAPABILITY_SKYPEIN - Indicates that the contact/account has SkypeIn and is thus capable of answering PSTN calls. 545 546 - CAPABILITY_CAN_BE_SENT_VM - For contacts, this is a combination of CAPABILITY_VOICEMAIL for local account (local Skype client supports sending voicemails) and CAPABILITY_VOICEMAIL of the Contact - if the contact supports sending voicemails then hopefully they can also receive them. 547 548 - CAPABILITY_CALL_FORWARD - Indicates that Account/Contact supports call forwarding. 549 550 - CAPABILITY_VIDEO - Indicates that Account/Contact supports call video calls. 551 552 - CAPABILITY_TEXT - In context of Contact, this indicates that the user is noticed running at least one Skype implementation that supports text messaging. Basically, it applies to a user. When applied to Account, the meaning is slightly different. In that case it indicates that currently running Skype implementation supports chat messaging. So, for Account objects, this is a node (rather than user) capability. 553 554 - CAPABILITY_SERVICE_PROVIDER - Indicates that the contact/account is flagged as SkypePrime service provider. This is linked to Account class SERVICE_PROVIDER_INFO property. 555 556 - CAPABILITY_LARGE_CONFERENCE - This is a legacy item, from the old times when conference calls with more than 5 people were limited to SkypePro accounts. In other words, this item is no longer relevant and will likely be removed at some point in future. 557 558 - CAPABILITY_COMMERCIAL_CONTACT 559 - CAPABILITY_PSTN_TRANSFER - Indicates that Account/Contact supports call transfers to PSTN numbers. 560 561 - CAPABILITY_TEXT_EVER - Indicates that the user has had his chat capability removed by Skype. Basically, this means that the user is reported as spammer too many times. This applies for both Contact and Account objects - which means your client can check locally, if the currently logged in user has been marked as a spammer. 562 563 - CAPABILITY_VOICE_EVER - Indicates that the user (Account or Contact) has had his voice call capability removed by Skype. 564 565 - CAPABILITY_MOBILE_DEVICE - Indicates that the instance of Skype client Account/Contact is or in Contact's case has at least occasionally been flagged as a mobile device. 566 567 - CAPABILITY_PUBLIC_CONTACT 568 """ 569 CAPABILITYSTATUS = {0:'NO_CAPABILITY', 'NO_CAPABILITY':0, 1:'CAPABILITY_MIXED', 'CAPABILITY_MIXED':1, 2:'CAPABILITY_EXISTS', 'CAPABILITY_EXISTS':2} 570 """ 571 List of possible states of each of the Contact class CAPABILITY items. 572 573 - NO_CAPABILITY - Contact does not have the capability 574 575 - CAPABILITY_MIXED - Contact has occasionally logged in with Skype client that supports the capability. For example, a contact may have Skype client on several machines, only some of which have webcam - in which case CAPABILITY_VIDEO would have its value set as CAPABILITY_MIXED. 576 577 - CAPABILITY_EXISTS - Contact has the capability 578 579 """ 580
581 - def _sk_get_type(self):
582 return skypekit.enumof(Contact.TYPE, self._sk_property("ZG\312\001]\002", 202, True))
583 type = property(_sk_get_type) 584 propid2label[202] = "type" 585 P_TYPE = 202
586 - def _sk_get_skypename(self):
587 """ 588 defined if it is a SKYPE contact 589 """ 590 return self._sk_property("ZG\004]\002", 4, True)
591 skypename = property(_sk_get_skypename) 592 propid2label[4] = "skypename" 593 P_SKYPENAME = 4
594 - def _sk_get_pstnnumber(self):
595 return self._sk_property("ZG\006]\002", 6, True)
596 pstnnumber = property(_sk_get_pstnnumber) 597 propid2label[6] = "pstnnumber" 598 P_PSTNNUMBER = 6
599 - def _sk_get_fullname(self):
600 return self._sk_property("ZG\005]\002", 5, True)
601 fullname = property(_sk_get_fullname) 602 propid2label[5] = "fullname" 603 P_FULLNAME = 5
604 - def _sk_get_birthday(self):
605 """ 606 integer of YYYYMMDD format 607 """ 608 return self._sk_property("ZG\007]\002", 7, True)
609 birthday = property(_sk_get_birthday) 610 propid2label[7] = "birthday" 611 P_BIRTHDAY = 7
612 - def _sk_get_gender(self):
613 """ 614 1-male, 2-female 615 """ 616 return self._sk_property("ZG\010]\002", 8, True)
617 gender = property(_sk_get_gender) 618 propid2label[8] = "gender" 619 P_GENDER = 8
620 - def _sk_get_languages(self):
621 """ 622 ISO language code list, space separated 623 """ 624 return self._sk_property("ZG\011]\002", 9, True)
625 languages = property(_sk_get_languages) 626 propid2label[9] = "languages" 627 P_LANGUAGES = 9
628 - def _sk_get_country(self):
629 """ 630 ISO country code 631 """ 632 return self._sk_property("ZG\012]\002", 10, True)
633 country = property(_sk_get_country) 634 propid2label[10] = "country" 635 P_COUNTRY = 10
636 - def _sk_get_province(self):
637 return self._sk_property("ZG\013]\002", 11, True)
638 province = property(_sk_get_province) 639 propid2label[11] = "province" 640 P_PROVINCE = 11
641 - def _sk_get_city(self):
642 return self._sk_property("ZG\014]\002", 12, True)
643 city = property(_sk_get_city) 644 propid2label[12] = "city" 645 P_CITY = 12
646 - def _sk_get_phone_home(self):
647 """ 648 This corresponds to the Account::P_PHONE_HOME property. The value is set by the remote user in Account profile. As Contact property, this is read-only. 649 650 """ 651 return self._sk_property("ZG\015]\002", 13, True)
652 phone_home = property(_sk_get_phone_home) 653 propid2label[13] = "phone_home" 654 P_PHONE_HOME = 13
655 - def _sk_get_phone_office(self):
656 """ 657 This corresponds to the Account::P_PHONE_OFFICE property. The value is set by the remote user in Account profile. As Contact property, this is read-only. If the Contact has not populated his Account profile with sufficient phone numbers, the UI should implement locally adding additional phone numbers to Contact P_ASSIGNED_PHONE1 .. P_ASSIGNED_PHONE3 properties (and corresponding labels). See Contact::SetPhoneNumber method for more information. 658 659 """ 660 return self._sk_property("ZG\016]\002", 14, True)
661 phone_office = property(_sk_get_phone_office) 662 propid2label[14] = "phone_office" 663 P_PHONE_OFFICE = 14
664 - def _sk_get_phone_mobile(self):
665 """ 666 This corresponds to the Account::P_PHONE_MOBILE property. The value is set by the remote user in Account profile. As Contact property, this is read-only. 667 668 """ 669 return self._sk_property("ZG\017]\002", 15, True)
670 phone_mobile = property(_sk_get_phone_mobile) 671 propid2label[15] = "phone_mobile" 672 P_PHONE_MOBILE = 15
673 - def _sk_get_emails(self):
674 """ 675 will be hashed before advertising/querying, space separated 676 """ 677 return self._sk_property("ZG\020]\002", 16, True)
678 emails = property(_sk_get_emails) 679 propid2label[16] = "emails" 680 P_EMAILS = 16
681 - def _sk_get_homepage(self):
682 return self._sk_property("ZG\021]\002", 17, True)
683 homepage = property(_sk_get_homepage) 684 propid2label[17] = "homepage" 685 P_HOMEPAGE = 17
686 - def _sk_get_about(self):
687 """ 688 arbitrary introductory text 689 """ 690 return self._sk_property("ZG\022]\002", 18, True)
691 about = property(_sk_get_about) 692 propid2label[18] = "about" 693 P_ABOUT = 18
694 - def _sk_get_avatar_image(self):
695 """ 696 Contact avatar pictures are in JPG format. The original size of avatar pictures are in no more than 96 x 96 pixels in size. However, as they can be smaller, scaling the pictures up too much to fit your UI can lead to distorted images. 697 698 """ 699 return self._sk_property("ZG%]\002", 37, False)
700 avatar_image = property(_sk_get_avatar_image) 701 propid2label[37] = "avatar_image" 702 P_AVATAR_IMAGE = 37
703 - def _sk_get_mood_text(self):
704 """ 705 Personal mood message (visible to authorized users only). 706 707 """ 708 return self._sk_property("ZG\032]\002", 26, True)
709 mood_text = property(_sk_get_mood_text) 710 propid2label[26] = "mood_text" 711 P_MOOD_TEXT = 26
712 - def _sk_get_rich_mood_text(self):
713 """ 714 XML version of personal mood text 715 """ 716 return self._sk_property("ZG\315\001]\002", 205, True)
717 rich_mood_text = property(_sk_get_rich_mood_text) 718 propid2label[205] = "rich_mood_text" 719 P_RICH_MOOD_TEXT = 205
720 - def _sk_get_timezone(self):
721 """ 722 24*3600+diff_to_UTC_in_seconds. NB! changes with DST 723 724 """ 725 return self._sk_property("ZG\033]\002", 27, True)
726 timezone = property(_sk_get_timezone) 727 propid2label[27] = "timezone" 728 P_TIMEZONE = 27
729 - def _sk_get_capabilities(self):
730 """ 731 binary tag that can be queried via Contact::HasCapability() 732 """ 733 return self._sk_property("ZG$]\002", 36, False)
734 capabilities = property(_sk_get_capabilities) 735 propid2label[36] = "capabilities" 736 P_CAPABILITIES = 36
737 - def _sk_get_profile_timestamp(self):
738 """ 739 UNIX timestamp of last profile change 740 """ 741 return self._sk_property("ZG\023]\002", 19, True)
742 profile_timestamp = property(_sk_get_profile_timestamp) 743 propid2label[19] = "profile_timestamp" 744 P_PROFILE_TIMESTAMP = 19
746 """ 747 count of this user's authorized contacts 748 749 """ 750 return self._sk_property("ZG\034]\002", 28, True)
751 nrof_authed_buddies = property(_sk_get_nrof_authed_buddies) 752 propid2label[28] = "nrof_authed_buddies" 753 P_NROF_AUTHED_BUDDIES = 28
754 - def _sk_get_ipcountry(self):
755 """ 756 ISO country code assigned by the IP 757 """ 758 return self._sk_property("ZG\035]\002", 29, True)
759 ipcountry = property(_sk_get_ipcountry) 760 propid2label[29] = "ipcountry" 761 P_IPCOUNTRY = 29
762 - def _sk_get_avatar_timestamp(self):
763 """ 764 UNIX timestamp of when current avatar was set 765 """ 766 return self._sk_property("ZG\266\001]\002", 182, False)
767 avatar_timestamp = property(_sk_get_avatar_timestamp) 768 propid2label[182] = "avatar_timestamp" 769 P_AVATAR_TIMESTAMP = 182
770 - def _sk_get_mood_timestamp(self):
771 """ 772 NOT SET FOR CONTACTS. For Account object, UNIX timestamp of when current mood was set 773 """ 774 return self._sk_property("ZG\267\001]\002", 183, True)
775 mood_timestamp = property(_sk_get_mood_timestamp) 776 propid2label[183] = "mood_timestamp" 777 P_MOOD_TIMESTAMP = 183
779 """ 780 set if the contact is waiting to be authorized. The value contains auth. request text 781 782 """ 783 return self._sk_property("ZG\024]\002", 20, True)
784 received_authrequest = property(_sk_get_received_authrequest) 785 propid2label[20] = "received_authrequest" 786 P_RECEIVED_AUTHREQUEST = 20
787 - def _sk_get_authreq_timestamp(self):
788 """ 789 timestamp of last received auth-request 790 """ 791 return self._sk_property("ZG\031]\002", 25, True)
792 authreq_timestamp = property(_sk_get_authreq_timestamp) 793 propid2label[25] = "authreq_timestamp" 794 P_AUTHREQ_TIMESTAMP = 25
796 """ 797 X timestamp of last successful ping to that user 798 """ 799 return self._sk_property("ZG#]\002", 35, False)
800 lastonline_timestamp = property(_sk_get_lastonline_timestamp) 801 propid2label[35] = "lastonline_timestamp" 802 P_LASTONLINE_TIMESTAMP = 35
803 - def _sk_get_availability(self):
804 """ 805 Contact::AVAILABILITY 806 """ 807 return skypekit.enumof(Contact.AVAILABILITY, self._sk_property("ZG\042]\002", 34, True))
808 availability = property(_sk_get_availability) 809 propid2label[34] = "availability" 810 P_AVAILABILITY = 34
811 - def _sk_get_displayname(self):
812 """ 813 always set (assigned by lib by looking at various fields) 814 """ 815 return self._sk_property("ZG\025]\002", 21, True)
816 displayname = property(_sk_get_displayname) 817 propid2label[21] = "displayname" 818 P_DISPLAYNAME = 21
819 - def _sk_get_refreshing(self):
820 """ 821 true if querying additional information from p2p or server 822 823 """ 824 return self._sk_property("ZG\026]\002", 22, True)
825 refreshing = property(_sk_get_refreshing) 826 propid2label[22] = "refreshing" 827 P_REFRESHING = 22
828 - def _sk_get_given_authlevel(self):
829 """ 830 Contact::AUTHLEVEL, change via Contact::GiveAuthlevel() 831 """ 832 return skypekit.enumof(Contact.AUTHLEVEL, self._sk_property("ZG\027]\002", 23, False))
833 given_authlevel = property(_sk_get_given_authlevel) 834 propid2label[23] = "given_authlevel" 835 P_GIVEN_AUTHLEVEL = 23
836 - def _sk_get_given_displayname(self):
837 """ 838 change via Contact::GiveDisplayname() 839 """ 840 return self._sk_property("ZG!]\002", 33, True)
841 given_displayname = property(_sk_get_given_displayname) 842 propid2label[33] = "given_displayname" 843 P_GIVEN_DISPLAYNAME = 33
844 - def _sk_get_assigned_comment(self):
845 """ 846 change via Contact::AssignComment() 847 """ 848 return self._sk_property("ZG\264\001]\002", 180, True)
849 assigned_comment = property(_sk_get_assigned_comment) 850 propid2label[180] = "assigned_comment" 851 P_ASSIGNED_COMMENT = 180
852 - def _sk_get_lastused_timestamp(self):
853 """ 854 UNIX timestamp of last outbound session (call, chat, FT, etc) 855 """ 856 return self._sk_property("ZG']\002", 39, True)
857 lastused_timestamp = property(_sk_get_lastused_timestamp) 858 propid2label[39] = "lastused_timestamp" 859 P_LASTUSED_TIMESTAMP = 39
860 - def _sk_get_authrequest_count(self):
861 """ 862 for contacts that have CONTACT_RECEIVED_AUTHREQUEST, how many times in a row they have requested it without positive answer 863 """ 864 return self._sk_property("ZG)]\002", 41, True)
865 authrequest_count = property(_sk_get_authrequest_count) 866 propid2label[41] = "authrequest_count" 867 P_AUTHREQUEST_COUNT = 41
868 - def _sk_get_assigned_phone1(self):
869 """ 870 Office phone no. of the contact. This property should NOT be used for SkypeOut contacts 871 872 """ 873 return self._sk_property("ZG\270\001]\002", 184, True)
874 assigned_phone1 = property(_sk_get_assigned_phone1) 875 propid2label[184] = "assigned_phone1" 876 P_ASSIGNED_PHONE1 = 184
878 """ 879 Value "1" in this property will be translated as "Office" by Skype Windows desktop client, according to UI language settings 880 881 """ 882 return self._sk_property("ZG\271\001]\002", 185, True)
883 assigned_phone1_label = property(_sk_get_assigned_phone1_label) 884 propid2label[185] = "assigned_phone1_label" 885 P_ASSIGNED_PHONE1_LABEL = 185
886 - def _sk_get_assigned_phone2(self):
887 """ 888 Mobile phone no. of the contact 889 890 """ 891 return self._sk_property("ZG\272\001]\002", 186, True)
892 assigned_phone2 = property(_sk_get_assigned_phone2) 893 propid2label[186] = "assigned_phone2" 894 P_ASSIGNED_PHONE2 = 186
896 """ 897 Value "2" in this property will be translated as "Mobile" by Skype Windows desktop client, according to UI language settings 898 899 """ 900 return self._sk_property("ZG\273\001]\002", 187, True)
901 assigned_phone2_label = property(_sk_get_assigned_phone2_label) 902 propid2label[187] = "assigned_phone2_label" 903 P_ASSIGNED_PHONE2_LABEL = 187
904 - def _sk_get_assigned_phone3(self):
905 """ 906 "Other phone no. of the contact 907 """ 908 return self._sk_property("ZG\274\001]\002", 188, True)
909 assigned_phone3 = property(_sk_get_assigned_phone3) 910 propid2label[188] = "assigned_phone3" 911 P_ASSIGNED_PHONE3 = 188
913 """ 914 Value "3" in this property will be translated as "Other" by Skype Windows desktop client, according to UI language settings 915 916 """ 917 return self._sk_property("ZG\275\001]\002", 189, True)
918 assigned_phone3_label = property(_sk_get_assigned_phone3_label) 919 propid2label[189] = "assigned_phone3_label" 920 P_ASSIGNED_PHONE3_LABEL = 189
921 - def _sk_get_popularity_ord(self):
922 """ 923 Contact's order by presence popularity 924 925 """ 926 return self._sk_property("ZG*]\002", 42, True)
927 popularity_ord = property(_sk_get_popularity_ord) 928 propid2label[42] = "popularity_ord" 929 P_POPULARITY_ORD = 42 930
931 - def GetIdentity(self):
932 """ 933 No description available. 934 935 B{Return values:} 936 - B{identity} - returns CONTACT_SKYPENAME or CONTACT_PSTNNUMBER value 937 """ 938 l_request = skypekit.XCallRequest("ZR\002\002", 2, 2) 939 l_request.add_parm('O', 0, self) 940 l_response = self.transport.xcall(l_request) 941 l_result = l_response.get(1, '') 942 return l_result
943 - def GetAvatar(self):
944 """ 945 Returns Conrtact's avatar image (JPG). 946 947 948 B{Return values:} 949 - B{present} - 950 - true: the Contact has a custom avatar image 951 - false: the Contact does not have a custom avatar image 952 953 - B{avatar} - The avatar image data (JPG). If present is false, this will be the Skype-assigned default avatar 954 955 """ 956 l_request = skypekit.XCallRequest("ZR\002\004", 2, 4) 957 l_request.add_parm('O', 0, self) 958 l_response = self.transport.xcall(l_request) 959 l_result = (l_response.get(1, False)), 960 l_result += (l_response.get(2, '')), 961 return l_result
962 - def GetVerifiedEmail(self):
963 """ 964 returns verified-by-Skype e-mail for this contact if exists and verifiable 965 966 B{Return values:} 967 - B{email} 968 """ 969 l_request = skypekit.XCallRequest("ZR\002\003", 2, 3) 970 l_request.add_parm('O', 0, self) 971 l_response = self.transport.xcall(l_request) 972 l_result = l_response.get(1, '') 973 return l_result
974 - def GetVerifiedCompany(self):
975 """ 976 returns verified-by-Skype company for this contact if exists and verifiable 977 978 B{Return values:} 979 - B{company} 980 """ 981 l_request = skypekit.XCallRequest("ZR\002\010", 2, 8) 982 l_request.add_parm('O', 0, self) 983 l_response = self.transport.xcall(l_request) 984 l_result = l_response.get(1, '') 985 return l_result
986 - def IsMemberOf( 987 self, 988 group 989 ):
990 """ 991 Checks whether the contact is member of a contact group given in group reference argument. 992 993 994 B{Arguments:} 995 - B{group} - The target contact group 996 997 998 B{Return values:} 999 - B{result} - 1000 - true: the Contact is a member of the target contact group 1001 - false: the Contact is not a member of the target contact group 1002 1003 """ 1004 l_request = skypekit.XCallRequest("ZR\002\006", 2, 6) 1005 l_request.add_parm('O', 0, self) 1006 l_request.add_parm('O', 1, group) 1007 l_response = self.transport.xcall(l_request) 1008 l_result = l_response.get(1, False) 1009 return l_result
1010 - def IsMemberOfHardwiredGroup( 1011 self, 1012 group_type 1013 ):
1014 """ 1015 Checks whether the contact is member of a pre-defined contact group given in the TYPE argument (type for this property comes from the ContactGroup class). 1016 1017 1018 B{Arguments:} 1019 - B{group_type} - The type designator of the target pre-defined contact group. For example, specify this parameter as ContactGroup::TYPE.RECENTLY_CONTACTED_CONTACTS to determine if you've had a recent conversation with this Contact. 1020 1021 1022 B{Return values:} 1023 - B{result} - 1024 - true: the Contact is a member of the target contact group 1025 - false: the Contact is not a member of the target contact group 1026 1027 """ 1028 l_request = skypekit.XCallRequest("ZR\002\007", 2, 7) 1029 l_request.add_parm('O', 0, self) 1030 l_request.add_parm('e', 1, ContactGroup.TYPE[group_type]) 1031 l_response = self.transport.xcall(l_request) 1032 l_result = l_response.get(1, False) 1033 return l_result
1034 - def SetBlocked( 1035 self, 1036 blocked, 1037 abuse = False 1038 ):
1039 """ 1040 Blocks or unblocks any further incoming communication attempts from this contact. 1041 1042 1043 B{Arguments:} 1044 - B{blocked} - 1045 - true: block this contact 1046 - false: unblock this contact 1047 1048 - B{abuse} - Optional parameter to report abuse by this Skype user when blocking this Contact. Note that you can specifiy this parameter as true only when blocking a Contact. Defaults to false if omitted. 1049 1050 """ 1051 l_request = skypekit.XCallRequest("ZR\002\026", 2, 22) 1052 l_request.add_parm('O', 0, self) 1053 l_request.add_parm('b', 1, blocked) 1054 l_request.add_parm('b', 2, abuse) 1055 self.transport.xcall(l_request)
1056 - def IgnoreAuthRequest(self):
1057 """ 1058 Rejects and removes a pending authorization request from this Contact. 1059 1060 """ 1061 l_request = skypekit.XCallRequest("ZR\002\025", 2, 21) 1062 l_request.add_parm('O', 0, self) 1063 self.transport.xcall(l_request)
1064 - def GiveDisplayName( 1065 self, 1066 name 1067 ):
1068 """ 1069 sets CONTACT_GIVEN_DISPLAYNAME. clears if size(name)==0 1070 1071 B{Arguments:} 1072 - B{name} 1073 """ 1074 l_request = skypekit.XCallRequest("ZR\002\012", 2, 10) 1075 l_request.add_parm('O', 0, self) 1076 l_request.add_parm('S', 1, name) 1077 self.transport.xcall(l_request)
1078 - def SetBuddyStatus( 1079 self, 1080 is_my_buddy, 1081 sync_auth = True 1082 ):
1083 """ 1084 Adds or removes this Contact from the ALL_BUDDIES hardwired group. 1085 1086 1087 B{Arguments:} 1088 - B{is_my_buddy} - 1089 - true: add this contact to the ALL_BUDDIES group 1090 - false: delete contact from the ALL_BUDDIES group 1091 1092 - B{sync_auth} - This argument is deprecated and should not be used. 1093 1094 """ 1095 l_request = skypekit.XCallRequest("ZR\002\014", 2, 12) 1096 l_request.add_parm('O', 0, self) 1097 l_request.add_parm('b', 1, is_my_buddy) 1098 l_request.add_parm('b', 2, sync_auth) 1099 self.transport.xcall(l_request)
1100 - def SendAuthRequest( 1101 self, 1102 message, 1103 extras_bitmask = 0 1104 ):
1105 """ 1106 Sends a contact authorization request to this user. 1107 1108 1109 B{Arguments:} 1110 - B{message} - Text that typically introduces the requesting user and details the reason for the authorization request. This text will be set as Message::P_BODY_XML property of the notification Message the remote user will receive upon getting the authortization request. While this can be the empty string, it cannot be null. 1111 1112 - B{extras_bitmask} - Indicates additional information to include with this authorization request: 1113 - 0 (zero): do not include any additional information 1114 - SEND_VERIFIED_EMAIL: include the requestor's verified e-mail address 1115 - SEND_VERIFIED_COMPANY: include verified information regarding the requestor's company 1116 - SEND_VERIFIED_EMAIL + SEND_VERIFIED_COMPANY: include both e-mail and company information 1117 1118 """ 1119 l_request = skypekit.XCallRequest("ZR\002\015", 2, 13) 1120 l_request.add_parm('O', 0, self) 1121 l_request.add_parm('S', 1, message) 1122 l_request.add_parm('u', 2, extras_bitmask) 1123 self.transport.xcall(l_request)
1124 - def HasAuthorizedMe(self):
1125 """ 1126 the contact has accepted my auth request 1127 1128 B{Return values:} 1129 - B{result} 1130 """ 1131 l_request = skypekit.XCallRequest("ZR\002\016", 2, 14) 1132 l_request.add_parm('O', 0, self) 1133 l_response = self.transport.xcall(l_request) 1134 l_result = l_response.get(1, False) 1135 return l_result
1136 - def SetPhoneNumber( 1137 self, 1138 num, 1139 label, 1140 number 1141 ):
1142 """ 1143 Sets the three P_ASSIGNED_PHONEx and P_ASSIGNED_PHONEx_LABEL properties, where x reflects the value of num. 1144 1145 The Skype Windows desktop client uses the following conventions when interpreting and assigning values to these properties. While your solution can assign arbitrary values to these properties, we strongly recommend using these conventions to ensure interoperability with the Skype Windows desktop client. Keep in mind that the "number" of these property pairs has no relationship to how the Skype Windows client interprets their label property value strings. For example, the Skype Windows client will interpret P_ASSIGNED_PHONE3_LABEL as "Home" if its value is the string "0". 1146 1147 Label strings: 1148 1149 Populate the label properties with string representations of the numbers "0" through "3", rather than descriptive strings like "Home", "Mobile", and so forth. The Skype desktop clients interpret the numeric string values as: 1150 - "0" (zero) - "Home" 1151 - "1" (one) - "Office" 1152 - "2" - "Mobile" 1153 - "3" - "Other" 1154 1155 Keep in mind that the "number" of a property pair has no relationship to its label string. For example, the Skype Windows client will interpret P_ASSIGNED_PHONE3_LABEL as "Home" if its value is the string "0". 1156 1157 Phone number strings: 1158 1159 The Skype Windows desktop client has distinct conventions for Skype Contacts and PSTN (SkypeOut) Contacts: any or all of the property pairs can be used for Skype Contacts; P_ASSIGNED_PHONE1 cannot be used for PSTN Contacts and P_ASSIGNED_PHONE1_LABEL has special meaning for PSTN Contacts. 1160 Specifically, the Skype desktop clients use P_ASSIGNED_PHONE1_LABEL as the label for a PSTN Contact's primary number (regardless of whether it's home, mobile, or office), and use P_PSTNNUMBER to hold the actual number. 1161 1162 1163 1164 B{Arguments:} 1165 - B{num} - The property pair being set, which must be in the range 0..3 1166 1167 - B{label} - The label text for the property being set 1168 1169 - B{number} - The phone number for the property being set 1170 1171 """ 1172 l_request = skypekit.XCallRequest("ZR\002\017", 2, 15) 1173 l_request.add_parm('O', 0, self) 1174 l_request.add_parm('u', 1, num) 1175 l_request.add_parm('S', 2, label) 1176 l_request.add_parm('S', 3, number) 1177 self.transport.xcall(l_request)
1178 - def OpenConversation(self):
1179 """ 1180 Retrieves a dialog conversation with the Contact. 1181 1182 1183 B{Return values:} 1184 - B{conversation} - Retrieved dialog. 1185 1186 """ 1187 l_request = skypekit.XCallRequest("ZR\002\021", 2, 17) 1188 l_request.add_parm('O', 0, self) 1189 l_response = self.transport.xcall(l_request) 1190 l_result = module_id2classes[18](l_response.get(1), self.transport) 1191 return l_result
1192 - def HasCapability( 1193 self, 1194 capability, 1195 query_server = False 1196 ):
1197 """ 1198 Retrieves a Contact::Capability value. Sets P_REFRESHING to true while querying from server. This method is functionally the same as Contact::GetCapabilityStatus except that it returns a bool value rather than Contact::CAPABILITYSTATUS 1199 1200 1201 B{Arguments:} 1202 - B{capability} - The target capability 1203 1204 - B{query_server} - 1205 - true: obtains the data from the p2p network/server, and sets P_REFRESHING to true for the duration 1206 - false: obtains the data from the local client 1207 1208 1209 B{Return values:} 1210 - B{result} - 1211 - true: the Contact has the target capability through at least one of the Skype clients they have logged into. Corresponds to CAPABILITY_MIXED and CAPABILITY_EXISTS 1212 - false: the Contact does not have the target capability. Corresponds to NO_CAPABILITY 1213 1214 """ 1215 l_request = skypekit.XCallRequest("ZR\002\022", 2, 18) 1216 l_request.add_parm('O', 0, self) 1217 l_request.add_parm('e', 1, Contact.CAPABILITY[capability]) 1218 l_request.add_parm('b', 2, query_server) 1219 l_response = self.transport.xcall(l_request) 1220 l_result = l_response.get(1, False) 1221 return l_result
1222 - def GetCapabilityStatus( 1223 self, 1224 capability, 1225 query_server = False 1226 ):
1227 """ 1228 Retrieves a Contact::Capability value. Sets P_REFRESHING to true while querying from server. 1229 1230 1231 B{Arguments:} 1232 - B{capability} - The target capability, see Contact::Capability enumerator. 1233 1234 - B{query_server} - 1235 - true: obtains the data from the p2p network/server, and sets P_REFRESHING to true for the duration 1236 - false: obtains the data from the local client 1237 1238 1239 B{Return values:} 1240 - B{status} - Status of the target capability. 1241 1242 """ 1243 l_request = skypekit.XCallRequest("ZR\002\023", 2, 19) 1244 l_request.add_parm('O', 0, self) 1245 l_request.add_parm('e', 1, Contact.CAPABILITY[capability]) 1246 l_request.add_parm('b', 2, query_server) 1247 l_response = self.transport.xcall(l_request) 1248 l_result = skypekit.enumof(Contact.CAPABILITYSTATUS, l_response.get(1)) 1249 return l_result
1250 - def RefreshProfile(self):
1251 """ 1252 Refreshes all properties, capabilities, and statuses associated with this Contact from p2p/CBL, and sets P_REFRESHING to true for the duration. 1253 1254 """ 1255 l_request = skypekit.XCallRequest("ZR\002\024", 2, 20) 1256 l_request.add_parm('O', 0, self) 1257 self.transport.xcall(l_request)
1258 - def mget_profile(self):
1259 """ get multiple properties from self """ 1260 self.multiget("ZG\004,\006,\005,\032,\020,\015,\016,\017,\007,\010,\011,\012,\013,\014,\021,\022,\033]\002")
1261 module_id2classes[2] = Contact
1262 1263 -class ContactSearch(skypekit.Object):
1264 """ 1265 This class encapsulates functionality for looking up contacts on the Skype network. Contacts can be searched by portion of their name, e-mail address, language preferences, etc. 1266 1267 Contact search is asynchronous. ContactSearch::Submit is a non-blocking function that initiates the search. Upon finding a matching contact, ContactSearch::OnNewResult event gets fired, that gives you the reference to the discovered contact. You can get up to 100 matching contacts per search. Note that you will need to keep a live reference of the ContactSearch object while the search is doing its work. 1268 1269 So, to perform a contact search: 1270 - create a contact search object 1271 - specify search terms and conditions 1272 - submit search 1273 - in ContactSearch::OnNewResult callback, update your UI 1274 - in ContactSearch::OnChange, check for terminal values of P_CONTACT_SEARCH_STATUS and update the UI accordingly. 1275 1276 When the search has done its job, the ContactSearch::P_CONTACT_SEARCH_STATUS property will go to one of the terminal values. 1277 1278 The terminal values are: 1279 - FINISHED - the search has stopped. Note that this does not mean any matches were actually found. 1280 - FAILED - the search has failed. 1281 - EXTENDABLE - this state should be considered the same as FINISHED. The feature of extending long search results is about to be deprecated. It is still possible for search objects to occasionally reach that state, so it should be handled in the UI (as FINISHED), but the extending feature itself should not be implemented in your UI. 1282 1283 There are three methods to create the ContactSearch objects. 1284 1285 A) Skype::CreateIdentitySearch 1286 1287 This method takes a string argument and looks for exact matches against Contact::P_SKYPENAME property. So for example, identity search for "echo" will return 0 results and search for "echo123" will return exactly one. 1288 1289 Identity in this case means skypename - contact search does not work with PSTN type contacts. However, it does work for SKYPE type contacts that have supplied P_PHONE_HOME, P_PHONE_OFFICE or P_PHONE_MOBILE values in their account data. To search for those, you will need to use complex search (see below). 1290 1291 Note that you should always check for boolean return value of the CreateIdentitySearch method. If the user submits a string that is not a valid skypename, the method will return false and the ContactSearchRef argument will return as NULL. 1292 1293 B) Skype::CreateBasicContactSearch 1294 1295 This method takes a string argument and looks for non-exact matches against both P_SKYPENAME and P_FULLNAME properties of the contact. If you intend to implement a simple, one-input search feature - this is the best method for you. The non-exact matching operates similarly to the SQL LIKE condition. 1296 1297 C) Skype::CreateContactSearch 1298 1299 This method enables you to implement advanced contact search, matching against multiple seach criteria. It takes no input arguments and expects search criteria to be added to the already constructed search object. 1300 1301 Criteria can be added with ContactSearch::AddStrTerm and ContactSearch::AddIntTerm methods. 1302 1303 These methods take Contact class porperty ID, condition, and the match pattern as inputs. 1304 1305 Only the following Contact properties can be used for search: 1306 - P_SKYPENAME 1307 - P_FULLNAME 1308 - P_BIRTHDAY (uint) 1309 - P_GENDER (uint: 1-male, 2-female) 1310 - P_LANGUAGES 1311 - P_COUNTRY 1312 - P_PROVINCE 1313 - P_CITY 1314 - P_PHONE_HOME 1315 - P_PHONE_OFFICE 1316 - P_PHONE_MOBILE 1317 - P_EMAILS 1318 - P_HOMEPAGE 1319 - P_ABOUT 1320 1321 String searches are case insensitive, i.e. search for echo123 also matches ECHO123 1322 1323 When adding multiple criteria, default behaviour is that the criterions are additive. I.e. a term skypename == "joe" followed by term country == "us" will result in intersection between all joes and everybody in US. 1324 1325 You can explicitly add an "OR" instead of "AND" between conditions, using the AddOr method. 1326 1327 By default, AND criteria are grouped together, before OR's, so that: 1328 1329 AddTerm(condition1) 1330 AddTerm(condition2) 1331 AddOr() 1332 AddTerm(condition3) 1333 AddTerm(condition4) 1334 1335 will result in the following logical statement: 1336 (condition1 AND condition2) OR (condition3 AND condition4) 1337 1338 However, you can add "global" critera, by using the add_to_subs argument of the AddXX methods. 1339 1340 AddTerm(condition1) 1341 AddTerm(condition2) 1342 AddOr() 1343 AddTerm(condition3) 1344 AddTerm(condition4, add_to_subs=true) 1345 1346 which would result in: 1347 (condition1 AND condition2 AND condition4) OR (condition3 AND condition4) 1348 1349 1350 Every one of the contact properties can only be used once, per search. For example, you cannot create a search for two different P_FULLNAME patterns. The &valid argument will still return tue if you do this, but the last criteria for any given property will override all previous ones. So, a search like this: 1351 1352 cs->AddStrTerm(Contact::P_FULLNAME, ContactSearch::EQ, "John Smith", isValid); 1353 cs->AddOr(); 1354 cs->AddStrTerm(Contact::P_FULLNAME, ContactSearch::EQ, "Ivan Sidorov", isValid); 1355 1356 will only return matches for "Ivan Sidorov" and none for "John Smith". 1357 1358 Some of the contact properties are automatically combined for purposes of search. 1359 1360 A search for P_SKYPENAME also returns matches from the P_FULLNAME property and vice versa. 1361 1362 So that this: 1363 cs->AddStrTerm(Contact::P_SKYPENAME, ContactSearch::EQ, "john.smith", isValid); 1364 1365 ..and this: 1366 cs->AddStrTerm(Contact::P_FULLNAME, ContactSearch::EQ, "John Smith", isValid); 1367 1368 ..and this: 1369 cs->AddStrTerm(Contact::P_SKYPENAME, ContactSearch::EQ, "john.smith", isValid); 1370 cs->AddOr(); 1371 cs->AddStrTerm(Contact::P_FULLNAME, ContactSearch::EQ, "John Smith", isValid); 1372 1373 ..all search from both the P_FULLNAME and P_SKYPENAME fields. 1374 1375 1376 Before using ContactGroup::Submit to start the search, you should always check whether the search criteria ended up being valid. This you can do with ContactSearch::IsValid method. 1377 1378 As you probably noticed, each of the AddXX methods also return a validity check boolean. However, it is a better practice to do the overall check as well, even if all the individual search criteria ended up looking Ok. 1379 1380 For example, lets take a search for contact's e-mail. This can be done with two different methods. Firstly we can use the ContactSearch::AddEmailTerm method. This method will actually validate whether the input is a valid e-mail address: 1381 1382 cs->AddEmailTerm ("test@test@test", isValid); 1383 will return the isValid argument as false. 1384 1385 However, you can also add the e-mail search criterion as a simple string, like this: 1386 1387 cs->AddStrTerm(Contact::P_EMAILS, ContactSearch::EQ, "test@test@test@", isValid); 1388 in which case the isValid will return true. 1389 1390 However, if you then check entire search object with: 1391 1392 cs->IsValid(isValid); 1393 1394 the isValid will correctly return false. 1395 1396 """ 1397 event_handlers = {} 1398 propid2label = {}
1399 - def _sk_init_(self, object_id, transport):
1400 """ actual constructor """ 1401 skypekit.Object._sk_init_(self, object_id, transport)
1402 - def __str__(self):
1403 return "ContactSearch %s" % (self.object_id, )
1404 @staticmethod
1405 - def propid(propname):
1406 """ convert a property name to the enum of the property """ 1407 return getattr(ContactSearch, "P_"+propname.upper())
1408 module_id = 1
1409 - def OnPropertyChange(self, property_name):
1410 """ notifies from a property change """ 1411 1412 pass
1413 STATUS = {1:'CONSTRUCTION', 'CONSTRUCTION':1, 2:'PENDING', 'PENDING':2, 3:'EXTENDABLE', 'EXTENDABLE':3, 4:'FINISHED', 'FINISHED':4, 5:'FAILED', 'FAILED':5} 1414 """ 1415 Possible values for the ContactSearch.P_STATUS property. 1416 1417 - CONSTRUCTION - Transient state, obtained after submission and actually initiating the search on the network. 1418 1419 - PENDING - Waiting for results to show up. This is a transient state. 1420 1421 - EXTENDABLE - Enough matches are found. No more OnNewResult events will fire. The feature of extending long search results is about to be deprecated. It is still possible for search objects to occasionally reach that state, so it should be handled in the UI (as FINISHED), but the extending feature itself should not be implemented in your UI. 1422 1423 - FINISHED - The search is finished. No more matches are expected. This is a terminal state. 1424 1425 - FAILED - ContactSearch failed. Better check if the search terms made any sense, with ContactSearch::IsValid. This is a terminal state. 1426 1427 """ 1428 CONDITION = { 1429 0:'EQ', 1430 1:'GT', 1431 2:'GE', 1432 3:'LT', 1433 4:'LE', 1434 5:'PREFIX_EQ', 1435 6:'PREFIX_GE', 1436 7:'PREFIX_LE', 1437 8:'CONTAINS_WORDS', 1438 9:'CONTAINS_WORD_PREFIXES', 1439 'EQ' :0, 1440 'GT' :1, 1441 'GE' :2, 1442 'LT' :3, 1443 'LE' :4, 1444 'PREFIX_EQ' :5, 1445 'PREFIX_GE' :6, 1446 'PREFIX_LE' :7, 1447 'CONTAINS_WORDS' :8, 1448 'CONTAINS_WORD_PREFIXES' :9 1449 } 1450 """ 1451 List of available matching conditions that can be used in AddTerm methods. 1452 1453 - EQ - Equals 1454 1455 - GT - Is greater than 1456 1457 - GE - Is greater or equal. 1458 1459 - LT - Is less than 1460 1461 - LE - Less or equal 1462 1463 - PREFIX_EQ - Start of a word macthes exactly (string properties only). 1464 1465 - PREFIX_GE - Start of a word is greater or equal (string properties only). 1466 1467 - PREFIX_LE - Start of a word is less or equal (string properties only). 1468 1469 - CONTAINS_WORDS - Contains the word (string properties only). 1470 1471 - CONTAINS_WORD_PREFIXES - One of the words starts with searched value (string properties only). 1472 1473 """ 1474
1476 return skypekit.enumof(ContactSearch.STATUS, self._sk_property("ZG\310\001]\001", 200, True))
1477 contact_search_status = property(_sk_get_contact_search_status) 1478 propid2label[200] = "contact_search_status" 1479 P_CONTACT_SEARCH_STATUS = 200 1480
1481 - def AddMinAgeTerm( 1482 self, 1483 min_age_in_years, 1484 add_to_subs = False 1485 ):
1486 """ 1487 construct CONTACT_BIRTHDAY term based on current time 1488 1489 B{Arguments:} 1490 - B{min_age_in_years} 1491 - B{add_to_subs} 1492 1493 B{Return values:} 1494 - B{valid} 1495 """ 1496 l_request = skypekit.XCallRequest("ZR\001\001", 1, 1) 1497 l_request.add_parm('O', 0, self) 1498 l_request.add_parm('u', 1, min_age_in_years) 1499 l_request.add_parm('b', 2, add_to_subs) 1500 l_response = self.transport.xcall(l_request) 1501 l_result = l_response.get(1, False) 1502 return l_result
1503 - def AddMaxAgeTerm( 1504 self, 1505 max_age_in_years, 1506 add_to_subs = False 1507 ):
1508 """ 1509 construct CONTACT_BIRTHDAY term based on current time 1510 1511 B{Arguments:} 1512 - B{max_age_in_years} 1513 - B{add_to_subs} 1514 1515 B{Return values:} 1516 - B{valid} 1517 """ 1518 l_request = skypekit.XCallRequest("ZR\001\002", 1, 2) 1519 l_request.add_parm('O', 0, self) 1520 l_request.add_parm('u', 1, max_age_in_years) 1521 l_request.add_parm('b', 2, add_to_subs) 1522 l_response = self.transport.xcall(l_request) 1523 l_result = l_response.get(1, False) 1524 return l_result
1525 - def AddEmailTerm( 1526 self, 1527 email, 1528 add_to_subs = False 1529 ):
1530 """ 1531 Adds a search term against Contact::P_EMAILS property and pre-validates the value given in the email argument. 1532 1533 1534 B{Arguments:} 1535 - B{email} - e-mail addres to search for. 1536 1537 - B{add_to_subs} - This argument enables you to group conditions. See ContactSearch class details for more information. 1538 1539 1540 B{Return values:} 1541 - B{valid} - Returns false if the value in email property did not look like a valid email address. 1542 1543 """ 1544 l_request = skypekit.XCallRequest("ZR\001\003", 1, 3) 1545 l_request.add_parm('O', 0, self) 1546 l_request.add_parm('S', 1, email) 1547 l_request.add_parm('b', 2, add_to_subs) 1548 l_response = self.transport.xcall(l_request) 1549 l_result = l_response.get(1, False) 1550 return l_result
1551 - def AddLanguageTerm( 1552 self, 1553 language, 1554 add_to_subs = False 1555 ):
1556 """ 1557 No description available. 1558 1559 B{Arguments:} 1560 - B{language} 1561 - B{add_to_subs} 1562 1563 B{Return values:} 1564 - B{valid} 1565 """ 1566 l_request = skypekit.XCallRequest("ZR\001\004", 1, 4) 1567 l_request.add_parm('O', 0, self) 1568 l_request.add_parm('S', 1, language) 1569 l_request.add_parm('b', 2, add_to_subs) 1570 l_response = self.transport.xcall(l_request) 1571 l_result = l_response.get(1, False) 1572 return l_result
1573 - def AddStrTerm( 1574 self, 1575 prop, 1576 cond, 1577 value, 1578 add_to_subs = False 1579 ):
1580 """ 1581 Adds a string search term to a custom contact search object. 1582 1583 1584 B{Arguments:} 1585 - B{prop} - Following Contact class string propkeys can be used for Contact search: 1586 - Contact::P_SKYPENAME 1587 - Contact::P_FULLNAME 1588 - Contact::P_LANGUAGES 1589 - Contact::P_COUNTRY 1590 - Contact::P_PROVINCE 1591 - Contact::P_CITY 1592 - Contact::P_PHONE_HOME 1593 - Contact::P_PHONE_OFFICE 1594 - Contact::P_PHONE_MOBILE 1595 - Contact::P_EMAILS 1596 - Contact::P_HOMEPAGE 1597 - Contact::P_ABOUT 1598 Note that while Contact::P_EMAILS is technically a string and can be used in this method, it is recommended that you use ContactSearch.AddEmailTerm method instead. 1599 1600 - B{cond} - Search condition (ContactSearch::CONDITION) 1601 1602 - B{value} - Value to match against. 1603 1604 - B{add_to_subs} - This argument enables you to group conditions. See ContactSearch class details for more information. 1605 1606 1607 B{Return values:} 1608 - B{valid} - Returns true if the ContactSearch term-set remains valid after adding this term. 1609 1610 """ 1611 l_request = skypekit.XCallRequest("ZR\001\005", 1, 5) 1612 l_request.add_parm('O', 0, self) 1613 l_request.add_parm('e', 1, prop) 1614 l_request.add_parm('e', 2, ContactSearch.CONDITION[cond]) 1615 l_request.add_parm('S', 3, value) 1616 l_request.add_parm('b', 4, add_to_subs) 1617 l_response = self.transport.xcall(l_request) 1618 l_result = l_response.get(1, False) 1619 return l_result
1620 - def AddIntTerm( 1621 self, 1622 prop, 1623 cond, 1624 value, 1625 add_to_subs = False 1626 ):
1627 """ 1628 Adds a search term to a custom contact search object. For now, there are only two searchable Contact properties that are integers, so this can oly be used for Contact::P_BIRTHDAY and Contact::P_GENDER. 1629 1630 1631 B{Arguments:} 1632 - B{prop} - Propkey to search for. Either Contact::P_BIRTHDAY or Contact::P_GENDER 1633 1634 - B{cond} - Search condition (ContactSearch::CONDITION) 1635 1636 - B{value} - Value to match against. 1637 1638 - B{add_to_subs} - This argument enables you to group conditions. See ContactSearch class details for more information. 1639 1640 1641 B{Return values:} 1642 - B{valid} - Returns true if the ContactSearch term-set remains valid after adding this term. 1643 1644 """ 1645 l_request = skypekit.XCallRequest("ZR\001\006", 1, 6) 1646 l_request.add_parm('O', 0, self) 1647 l_request.add_parm('e', 1, prop) 1648 l_request.add_parm('e', 2, ContactSearch.CONDITION[cond]) 1649 l_request.add_parm('u', 3, value) 1650 l_request.add_parm('b', 4, add_to_subs) 1651 l_response = self.transport.xcall(l_request) 1652 l_result = l_response.get(1, False) 1653 return l_result
1654 - def AddOr(self):
1655 """ 1656 used to group terms (AddTerm(1), AddTerm(2), Or(), AddTerm(3), AddTerm(4), etc) 1657 """ 1658 l_request = skypekit.XCallRequest("ZR\001\007", 1, 7) 1659 l_request.add_parm('O', 0, self) 1660 self.transport.xcall(l_request)
1661 - def IsValid(self):
1662 """ 1663 checks that terms list is non-empty and does not contain unsupported keys 1664 1665 B{Return values:} 1666 - B{result} 1667 """ 1668 l_request = skypekit.XCallRequest("ZR\001\010", 1, 8) 1669 l_request.add_parm('O', 0, self) 1670 l_response = self.transport.xcall(l_request) 1671 l_result = l_response.get(1, False) 1672 return l_result
1673 - def Submit(self):
1674 """ 1675 launch search 1676 """ 1677 l_request = skypekit.XCallRequest("ZR\001\011", 1, 9) 1678 l_request.add_parm('O', 0, self) 1679 self.transport.xcall(l_request)
1680 - def Extend(self):
1681 """ 1682 extend if search is EXTENDABLE 1683 """ 1684 l_request = skypekit.XCallRequest("ZR\001\012", 1, 10) 1685 l_request.add_parm('O', 0, self) 1686 self.transport.xcall(l_request)
1687 - def Release(self):
1688 """ 1689 releases results that are not referenced from elsewhere 1690 """ 1691 l_request = skypekit.XCallRequest("ZR\001\014", 1, 12) 1692 l_request.add_parm('O', 0, self) 1693 self.transport.xcall(l_request)
1694 - def GetResults( 1695 self, 1696 from_ = 0, 1697 count = skypekit.MAX_UINT 1698 ):
1699 """ 1700 result list is dynamically updated 1701 1702 B{Arguments:} 1703 - B{from_} 1704 - B{count} 1705 1706 B{Return values:} 1707 - B{contacts} 1708 """ 1709 l_request = skypekit.XCallRequest("ZR\001\013", 1, 11) 1710 l_request.add_parm('O', 0, self) 1711 l_request.add_parm('u', 1, from_) 1712 l_request.add_parm('u', 2, count) 1713 l_response = self.transport.xcall(l_request) 1714 l_result = [module_id2classes[2](oid, self.transport) for oid in l_response.get(1, [])] 1715 return l_result
1716 - def OnNewResult( 1717 self, 1718 contact, 1719 rank_value 1720 ):
1721 """ 1722 This callback is fired when a new matching contact has been found during the search. 1723 1724 1725 B{Return values:} 1726 - B{contact} 1727 - B{rank_value} 1728 """ 1729 pass
1730 event_handlers[1] = "_sk_on_new_result"
1731 - def _sk_on_new_result(self, parms):
1732 """ internal event dispatcher for OnNewResult """ 1733 l_cleanparms = (module_id2classes[2](parms.get(1), self.transport)), 1734 l_cleanparms += (parms.get(2, 0)), 1735 self.OnNewResult(*l_cleanparms)
1736 module_id2classes[1] = ContactSearch
1737 1738 -class Participant(skypekit.Object):
1739 """ 1740 Conversation participant class. Instances of this class represent contacts when in the context of conversations. Amongst others, this class has a Ring method for requesting live status with the target contact. This class also holds typing indicator property and access rights for the contact in context of public conversations. 1741 1742 """ 1743 event_handlers = {} 1744 propid2label = {}
1745 - def _sk_init_(self, object_id, transport):
1746 """ actual constructor """ 1747 skypekit.Object._sk_init_(self, object_id, transport)
1748 - def __str__(self):
1749 return "Participant %s" % (self.object_id, )
1750 @staticmethod
1751 - def propid(propname):
1752 """ convert a property name to the enum of the property """ 1753 return getattr(Participant, "P_"+propname.upper())
1754 module_id = 19
1755 - def OnPropertyChange(self, property_name):
1756 """ notifies from a property change """ 1757 1758 pass
1759 RANK = {1:'CREATOR', 'CREATOR':1, 2:'ADMIN', 'ADMIN':2, 3:'SPEAKER', 'SPEAKER':3, 4:'WRITER', 'WRITER':4, 5:'SPECTATOR', 'SPECTATOR':5, 6:'APPLICANT', 'APPLICANT':6, 7:'RETIRED', 'RETIRED':7, 8:'OUTLAW', 'OUTLAW':8} 1760 """ 1761 Recognized values for the P_RANK property. The P_RANK controls participant's privileges in the conversation. See Participant::CanSetRankTo and Participant::SetRankTo methods. 1762 1763 - CREATOR - Creator of the chat. There can be only one participant with this type per conversation. Other participants cannot be promoted to Creator rank. 1764 1765 - ADMIN - Participant who has administrator privileges 1766 1767 - SPEAKER - Participant who can speak and write 1768 1769 - WRITER - Participant who can write but not speak 1770 1771 - SPECTATOR - Participant who can read but not write/speak 1772 1773 - APPLICANT - Participant who is applying to join the conversation. Member cannot be demoted to applicants once they have been accepted. 1774 1775 - RETIRED - Participant who has eft or has been kicked from the conversation 1776 1777 - OUTLAW - Participant who has been banned from the chat 1778 1779 """ 1780 TEXT_STATUS = {0:'TEXT_UNKNOWN', 'TEXT_UNKNOWN':0, 1:'TEXT_NA', 'TEXT_NA':1, 2:'READING', 'READING':2, 3:'WRITING', 'WRITING':3, 4:'WRITING_AS_ANGRY', 'WRITING_AS_ANGRY':4, 5:'WRITING_AS_CAT', 'WRITING_AS_CAT':5} 1781 """ 1782 Recognized values for the P_TEXT_STATUS property. The P_TEXT_STATUS property has two uses. Firstly, you can use it to implement typing indicators in your UI, to notify the local user that an incoming chat message from this Participant is imminent. 1783 1784 To set the P_TEXT_STATUS value, so that remote client UIs can display the local user's typing indicator in their UI, use Conversation::SetMyTextStatusTo method. 1785 1786 Transmission of P_TEXT_STATUS updates to remote participants of conversations is controlled via SETUPKEY_DISABLE_CHAT_ACTIVITY_INDICATION setup key. 1787 1788 Secondly, the TEXT_NA value enables you to detect participants who are running clients with no chat capability. 1789 1790 - TEXT_UNKNOWN - Fallback state in case the text status is not (yet) deternmined. 1791 1792 - TEXT_NA - Text status is not applicable as the participant is using a Skype client that does not support chat (for example: voice-only USB phones). 1793 1794 - READING - Participant is currently not typing. 1795 1796 - WRITING - Participant is currently typing. 1797 1798 - WRITING_AS_ANGRY - This state should be set when following two conditions are true: 1799 - interval between keypresses are less than 20 ms; 1800 - at least one of the keys adjacent to current key are pressed down. 1801 1802 - WRITING_AS_CAT - The "Cat on keyboard detection" algorthm in Skype is implemented in the UI level, and as such is not present in the SkypeKit API. Should you wish to implement similar algorthm in your own UI, you can get the basic logic from the PawSense FAQ - http://www.bitboost.com/pawsense/pawsense-faq.html 1803 1804 """ 1805 VOICE_STATUS = { 1806 0:'VOICE_UNKNOWN', 1807 1:'VOICE_NA', 1808 2:'VOICE_AVAILABLE', 1809 3:'VOICE_CONNECTING', 1810 4:'RINGING', 1811 5:'EARLY_MEDIA', 1812 6:'LISTENING', 1813 7:'SPEAKING', 1814 8:'VOICE_ON_HOLD', 1815 9:'VOICE_STOPPED', 1816 'VOICE_UNKNOWN' :0, 1817 'VOICE_NA' :1, 1818 'VOICE_AVAILABLE' :2, 1819 'VOICE_CONNECTING' :3, 1820 'RINGING' :4, 1821 'EARLY_MEDIA' :5, 1822 'LISTENING' :6, 1823 'SPEAKING' :7, 1824 'VOICE_ON_HOLD' :8, 1825 'VOICE_STOPPED' :9 1826 } 1827 """ 1828 Recognized values for the P_VOICE_STATUS property. 1829 1830 - VOICE_UNKNOWN - Participant voice status is not (yet) determined. 1831 1832 - VOICE_NA - Participant is using a Skype client with no audio capability. 1833 1834 - VOICE_AVAILABLE - Participant is using a Skype client that supports audio. 1835 1836 - VOICE_CONNECTING - Participant is in process of joining current live session. This is a transitional state. 1837 1838 - RINGING - Participant has been invited to join the live session but has not yet accepted. 1839 1840 - EARLY_MEDIA - Participant is in process of joining current live session. This is another transitional state. 1841 1842 - LISTENING - Participant has joined the current live session but is currently not transmitting audio. 1843 1844 - SPEAKING - Participant has joined the current live session and is transmitting audio. The UI can either use this state to display appropriate "speaking" notification, or alternatively use Participant::P_SOUND_LEVEL if you want your speaking indicator to also reflect audio volume coming from the Participant. 1845 1846 - VOICE_ON_HOLD - Participant has joined the current live session but the audio is currently on hold. 1847 1848 - VOICE_STOPPED - Participant will be placed in this state for some seconds after live session has finished. This is another transitional state. 1849 1850 """ 1851 VIDEO_STATUS = {0:'VIDEO_UNKNOWN', 'VIDEO_UNKNOWN':0, 1:'VIDEO_NA', 'VIDEO_NA':1, 2:'VIDEO_AVAILABLE', 'VIDEO_AVAILABLE':2, 3:'VIDEO_CONNECTING', 'VIDEO_CONNECTING':3, 4:'STREAMING', 'STREAMING':4, 5:'VIDEO_ON_HOLD', 'VIDEO_ON_HOLD':5} 1852 """ 1853 Recognized values for the P_VIDEO_STATUS property. This property applies to Participant's video send capability, not capability to receive video. 1854 1855 - VIDEO_UNKNOWN - Video status is not (yet) determined. 1856 1857 - VIDEO_NA - Indicates that this Participant does not have video available.. 1858 1859 - VIDEO_AVAILABLE - Indicates that video is available for this participant. When the Participant::P_VIDEO_STATUS obtains this state, it is possible to retrieve the Video object, using Participant::GetVideo method. Further operations, such as starting or stopping the video send/receive will then go through the Video object. 1860 1861 - VIDEO_CONNECTING - Transitional state indicating that the Participant is attempting to initiate video send. 1862 1863 - STREAMING - Indicates that the participant is currently sending video. 1864 1865 - VIDEO_ON_HOLD - Indicates that the participant video send is currently paused. 1866 1867 """ 1868 DTMF = { 1869 0 :'DTMF_0', 1870 1 :'DTMF_1', 1871 2 :'DTMF_2', 1872 3 :'DTMF_3', 1873 4 :'DTMF_4', 1874 5 :'DTMF_5', 1875 6 :'DTMF_6', 1876 7 :'DTMF_7', 1877 8 :'DTMF_8', 1878 9 :'DTMF_9', 1879 10:'DTMF_STAR', 1880 11:'DTMF_POUND', 1881 'DTMF_0' : 0, 1882 'DTMF_1' : 1, 1883 'DTMF_2' : 2, 1884 'DTMF_3' : 3, 1885 'DTMF_4' : 4, 1886 'DTMF_5' : 5, 1887 'DTMF_6' : 6, 1888 'DTMF_7' : 7, 1889 'DTMF_8' : 8, 1890 'DTMF_9' : 9, 1891 'DTMF_STAR' :10, 1892 'DTMF_POUND' :11 1893 } 1894 """ 1895 - DTMF_0 1896 - DTMF_1 1897 - DTMF_2 1898 - DTMF_3 1899 - DTMF_4 1900 - DTMF_5 1901 - DTMF_6 1902 - DTMF_7 1903 - DTMF_8 1904 - DTMF_9 1905 - DTMF_STAR 1906 - DTMF_POUND 1907 """ 1908
1909 - def _sk_get_convo_id(self):
1910 """ 1911 [ALL] ID of corresponding conversation. Here and below, [ALL] tag indicates that the property has meaning and is set in context of all participants in the conversation. [OTHERS] tag has meaning only for participants who are not the local user. 1912 1913 """ 1914 return module_id2classes[18](self._sk_property("ZG\242\007]\023", 930, True), self.transport)
1915 convo_id = property(_sk_get_convo_id) 1916 propid2label[930] = "convo_id" 1917 P_CONVO_ID = 930
1918 - def _sk_get_identity(self):
1919 """ 1920 [ALL] skypename OR pstn_number OR namespace:identity 1921 """ 1922 return self._sk_property("ZG\243\007]\023", 931, True)
1923 identity = property(_sk_get_identity) 1924 propid2label[931] = "identity" 1925 P_IDENTITY = 931
1926 - def _sk_get_rank(self):
1927 """ 1928 [ALL] Participant::RANK 1929 """ 1930 return skypekit.enumof(Participant.RANK, self._sk_property("ZG\244\007]\023", 932, True))
1931 rank = property(_sk_get_rank) 1932 propid2label[932] = "rank" 1933 P_RANK = 932
1934 - def _sk_get_requested_rank(self):
1935 """ 1936 Not set (should be: requested Participant::RANK, higher than the current one) 1937 """ 1938 return skypekit.enumof(Participant.RANK, self._sk_property("ZG\245\007]\023", 933, True))
1939 requested_rank = property(_sk_get_requested_rank) 1940 propid2label[933] = "requested_rank" 1941 P_REQUESTED_RANK = 933
1942 - def _sk_get_text_status(self):
1943 """ 1944 [ALL] the typing indicator 1945 """ 1946 return skypekit.enumof(Participant.TEXT_STATUS, self._sk_property("ZG\246\007]\023", 934, True))
1947 text_status = property(_sk_get_text_status) 1948 propid2label[934] = "text_status" 1949 P_TEXT_STATUS = 934
1950 - def _sk_get_voice_status(self):
1951 """ 1952 [ALL] voice status 1953 """ 1954 return skypekit.enumof(Participant.VOICE_STATUS, self._sk_property("ZG\247\007]\023", 935, True))
1955 voice_status = property(_sk_get_voice_status) 1956 propid2label[935] = "voice_status" 1957 P_VOICE_STATUS = 935
1958 - def _sk_get_video_status(self):
1959 """ 1960 [ALL] video status 1961 """ 1962 return skypekit.enumof(Participant.VIDEO_STATUS, self._sk_property("ZG\250\007]\023", 936, True))
1963 video_status = property(_sk_get_video_status) 1964 propid2label[936] = "video_status" 1965 P_VIDEO_STATUS = 936
1966 - def _sk_get_live_identity(self):
1967 """ 1968 [ALL] identity that was used to establish current live session with that participant (can be different from participant identity) 1969 """ 1970 return self._sk_property("ZG\257\007]\023", 943, False)
1971 live_identity = property(_sk_get_live_identity) 1972 propid2label[943] = "live_identity" 1973 P_LIVE_IDENTITY = 943
1974 - def _sk_get_live_price_for_me(self):
1975 """ 1976 [OTHERS] 'price_per_minute_float currency' - eg '0.01 EUR'. Note that this property obtains value only after the participant goes into live state. It cannot be used to display call rates before the call starts. 1977 1978 """ 1979 return self._sk_property("ZG\252\007]\023", 938, True)
1980 live_price_for_me = property(_sk_get_live_price_for_me) 1981 propid2label[938] = "live_price_for_me" 1982 P_LIVE_PRICE_FOR_ME = 938
1984 """ 1985 [OTHERS] list of identities where the live session is being forwarded (if they are disclosed), space separated 1986 """ 1987 return self._sk_property("ZG\264\007]\023", 948, True)
1988 live_fwd_identities = property(_sk_get_live_fwd_identities) 1989 propid2label[948] = "live_fwd_identities" 1990 P_LIVE_FWD_IDENTITIES = 948
1992 """ 1993 [ALL] time of joining the live session 1994 """ 1995 return self._sk_property("ZG\253\007]\023", 939, True)
1996 live_start_timestamp = property(_sk_get_live_start_timestamp) 1997 propid2label[939] = "live_start_timestamp" 1998 P_LIVE_START_TIMESTAMP = 939
1999 - def _sk_get_sound_level(self):
2000 """ 2001 [ALL] current 'loudness' level when SPEAKING (0..10) 2002 """ 2003 return self._sk_property("ZG\255\007]\023", 941, True)
2004 sound_level = property(_sk_get_sound_level) 2005 propid2label[941] = "sound_level" 2006 P_SOUND_LEVEL = 941
2007 - def _sk_get_debuginfo(self):
2008 """ 2009 [OTHERS] call (audio and video) debug info 2010 """ 2011 return self._sk_property("ZG\256\007]\023", 942, False)
2012 debuginfo = property(_sk_get_debuginfo) 2013 propid2label[942] = "debuginfo" 2014 P_DEBUGINFO = 942
2015 - def _sk_get_last_voice_error(self):
2016 """ 2017 [OTHERS] DEPRECATED, use last_leavereason instead 2018 """ 2019 return self._sk_property("ZG\263\007]\023", 947, True)
2020 last_voice_error = property(_sk_get_last_voice_error) 2021 propid2label[947] = "last_voice_error" 2022 P_LAST_VOICE_ERROR = 947
2023 - def _sk_get_quality_problems(self):
2024 """ 2025 [ALL] space separated tokens values: CPU_INUSE CPU_SLOW CPU_HIGH HIGH_ECHO HIGH_NOISE MUTED_INPUT LOW_INPUT MUTED_INPUT_ACTIVITY FW_STRONG FW_BAD NOT_UDP CALL_BW_LOW RECORD_ERROR + values in video debug info 2026 """ 2027 return self._sk_property("ZG\265\007]\023", 949, True)
2028 quality_problems = property(_sk_get_quality_problems) 2029 propid2label[949] = "quality_problems" 2030 P_QUALITY_PROBLEMS = 949
2031 - def _sk_get_live_type(self):
2032 """ 2033 [ALL] participant type during livesession as specified in IDENTITYTYPE 2034 """ 2035 return skypekit.enumof(Skype.IDENTITYTYPE, self._sk_property("ZG\266\007]\023", 950, True))
2036 live_type = property(_sk_get_live_type) 2037 propid2label[950] = "live_type" 2038 P_LIVE_TYPE = 950
2039 - def _sk_get_live_country(self):
2040 """ 2041 [OTHERS] participant livesession country code - used for emergency calls only atm 2042 """ 2043 return self._sk_property("ZG\267\007]\023", 951, False)
2044 live_country = property(_sk_get_live_country) 2045 propid2label[951] = "live_country" 2046 P_LIVE_COUNTRY = 951
2047 - def _sk_get_transferred_by(self):
2048 """ 2049 [OTHERS] Transferor identity (transferee side) 2050 2051 """ 2052 return self._sk_property("ZG\270\007]\023", 952, True)
2053 transferred_by = property(_sk_get_transferred_by) 2054 propid2label[952] = "transferred_by" 2055 P_TRANSFERRED_BY = 952
2056 - def _sk_get_transferred_to(self):
2057 """ 2058 [OTHERS] Identity of recipient of transfer (transferor side, caller side) 2059 2060 """ 2061 return self._sk_property("ZG\271\007]\023", 953, True)
2062 transferred_to = property(_sk_get_transferred_to) 2063 propid2label[953] = "transferred_to" 2064 P_TRANSFERRED_TO = 953
2065 - def _sk_get_adder(self):
2066 """ 2067 [ALL] Identity of the user who added this participant to the conversation, type: Sid::String 2068 2069 """ 2070 return self._sk_property("ZG\272\007]\023", 954, True)
2071 adder = property(_sk_get_adder) 2072 propid2label[954] = "adder" 2073 P_ADDER = 954
2074 - def _sk_get_last_leavereason(self):
2075 """ 2076 [OTHERS] last reason for leaving conversation or live session. provides an enum alternative to last_voice_error as well as the reason this participant RETIRED, if so 2077 """ 2078 return skypekit.enumof(Skype.LEAVE_REASON, self._sk_property("ZG\273\007]\023", 955, True))
2079 last_leavereason = property(_sk_get_last_leavereason) 2080 propid2label[955] = "last_leavereason" 2081 P_LAST_LEAVEREASON = 955 2082
2083 - def CanSetRankTo( 2084 self, 2085 rank 2086 ):
2087 """ 2088 Checks whether the current user can set this Participant's conversation privileges to the specified RANK. This enables you to gray out or disable in your UI all the unavailable options for Participant::SetRankTo method. 2089 2090 2091 B{Arguments:} 2092 - B{rank} - Participant::RANK value to check for. 2093 2094 2095 B{Return values:} 2096 - B{result} - Returns true if local user can set participant's rank to the value given in rank argument. 2097 2098 """ 2099 l_request = skypekit.XCallRequest("ZR\023\001", 19, 1) 2100 l_request.add_parm('O', 0, self) 2101 l_request.add_parm('e', 1, Participant.RANK[rank]) 2102 l_response = self.transport.xcall(l_request) 2103 l_result = l_response.get(1, False) 2104 return l_result
2105 - def SetRankTo( 2106 self, 2107 rank 2108 ):
2109 """ 2110 Sets Participant's conversation privileges to the given RANK 2111 2112 2113 B{Arguments:} 2114 - B{rank} - Target Participant::RANK value. 2115 2116 """ 2117 l_request = skypekit.XCallRequest("ZR\023\002", 19, 2) 2118 l_request.add_parm('O', 0, self) 2119 l_request.add_parm('e', 1, Participant.RANK[rank]) 2120 self.transport.xcall(l_request)
2121 - def Ring( 2122 self, 2123 identity_to_use = "", 2124 video_call = False, 2125 nrof_redials = 0, 2126 redial_period = 0, 2127 auto_start_vm = False, 2128 origin = "" 2129 ):
2130 """ 2131 Initiates live conversation attempt with Participant. 2132 2133 2134 B{Arguments:} 2135 - B{identity_to_use} - Ring an alternate identity, such as a PSTN number. 2136 2137 - B{video_call} - Enable video. 2138 2139 - B{nrof_redials} - Unused. 2140 2141 - B{redial_period} - Unused. 2142 2143 - B{auto_start_vm} - Unused. On dialog, if falling on VM, greeting and recording will be automatically started. 2144 2145 - B{origin} - When call is initiated from web link, must contain the URI that was used 2146 """ 2147 l_request = skypekit.XCallRequest("ZR\023\003", 19, 3) 2148 l_request.add_parm('O', 0, self) 2149 l_request.add_parm('S', 1, identity_to_use) 2150 l_request.add_parm('b', 2, video_call) 2151 l_request.add_parm('u', 3, nrof_redials) 2152 l_request.add_parm('u', 4, redial_period) 2153 l_request.add_parm('b', 5, auto_start_vm) 2154 l_request.add_parm('S', 6, origin) 2155 self.transport.xcall(l_request)
2156 - def RingIt(self):
2157 """ 2158 Rings this participant, using P_LIVE_IDENTITY property if set. 2159 2160 """ 2161 l_request = skypekit.XCallRequest("ZR\023\010", 19, 8) 2162 l_request.add_parm('O', 0, self) 2163 self.transport.xcall(l_request)
2164 - def SetLiveIdentityToUse( 2165 self, 2166 identity_to_use = "" 2167 ):
2168 """ 2169 Sets LIVE_IDENTITY property, an alternate identity to use when ringing, such as a PSTN. 2170 2171 2172 B{Arguments:} 2173 - B{identity_to_use} - Empty string will reset it to default, i.e IDENTITY property value 2174 2175 """ 2176 l_request = skypekit.XCallRequest("ZR\023\007", 19, 7) 2177 l_request.add_parm('O', 0, self) 2178 l_request.add_parm('S', 1, identity_to_use) 2179 self.transport.xcall(l_request)
2180 - def GetVideo(self):
2181 """ 2182 Retrieves a reference to the Video object that corresponds to the Participant. It can be either local video - you can check if this participant's name (P_IDENTITY property) matches the name of the currently logged in account (P_SKYPENAME property) or incoming video from a remote participant. 2183 2184 Note that for GetVideo to be successful, the video has to be available for that participant. This can be checked for by examining Participant VIDEO_STATUS property - once it becomes VIDEO_AVAILABLE - you can use GetVideo to obtain the Video object. 2185 2186 2187 B{Return values:} 2188 - B{video} - Returns reference to a constructed video object. 2189 2190 """ 2191 l_request = skypekit.XCallRequest("ZR\023\004", 19, 4) 2192 l_request.add_parm('O', 0, self) 2193 l_response = self.transport.xcall(l_request) 2194 l_result = module_id2classes[11](l_response.get(1), self.transport) 2195 return l_result
2196 - def Hangup(self):
2197 """ 2198 Removes this participant from the current live session. Note that this does not remove the participant from conversation (for this, use Participant::Retire). It only removes participant from live state. 2199 2200 """ 2201 l_request = skypekit.XCallRequest("ZR\023\005", 19, 5) 2202 l_request.add_parm('O', 0, self) 2203 self.transport.xcall(l_request)
2204 - def Retire(self):
2205 """ 2206 Forcibly removes this participant from conversation. This method is for removing other people from conversations (for example: as administrative punishment for flooding conversation with spam messages). For local user to leave a conversation, use Conversation::RetireFrom instead. 2207 2208 """ 2209 l_request = skypekit.XCallRequest("ZR\023\006", 19, 6) 2210 l_request.add_parm('O', 0, self) 2211 self.transport.xcall(l_request)
2212 - def OnIncomingDTMF( 2213 self, 2214 dtmf 2215 ):
2216 """ 2217 This event gets fired on receiving a DTMF signal sent by Participant. Note that this event will only fire if the Participant is also using a Skype client. Skype audio library does not monitor incoming voice streams for dial tones. DTMF events are propagated to remote participants via data channel. Incoming DTMF tones transmitted from, for example, mobile phones, will not cause this event to fire. In case of incoming DTMF signals from Skype clients, DTMF tones are also inserted into the audio stream. You don't have to inject those into local audio playback yourself. 2218 2219 2220 B{Return values:} 2221 - B{dtmf} - Returns Participant::DTMF value. 2222 2223 """ 2224 pass
2225 event_handlers[1] = "_sk_on_incoming_dtmf"
2226 - def _sk_on_incoming_dtmf(self, parms):
2227 """ internal event dispatcher for OnIncomingDTMF """ 2228 l_cleanparms = Participant.DTMF[parms.get(1)] 2229 self.OnIncomingDTMF(l_cleanparms)
2230 module_id2classes[19] = Participant
2231 2232 -class Conversation(skypekit.Object):
2233 """ 2234 The Conversation class encapsulates all types of communication possible with Skype client. Instant messaging, calls, video calls, file transfers, SMS, screen sharing - all take place within the context of a Conversation. Contacts are represented in Conversation as Participant objects. This also applies to contacts of PSTN type. All events in a conversation are represented as Message objects. 2235 2236 """ 2237 event_handlers = {} 2238 propid2label = {}
2239 - def _sk_init_(self, object_id, transport):
2240 """ actual constructor """ 2241 skypekit.Object._sk_init_(self, object_id, transport)
2242 - def __str__(self):
2243 return "Conversation %s" % (self.object_id, )
2244 @staticmethod
2245 - def propid(propname):
2246 """ convert a property name to the enum of the property """ 2247 return getattr(Conversation, "P_"+propname.upper())
2248 module_id = 18
2249 - def OnPropertyChange(self, property_name):
2250 """ notifies from a property change """ 2251 2252 pass
2253 TYPE = {1:'DIALOG', 'DIALOG':1, 2:'CONFERENCE', 'CONFERENCE':2, 3:'TERMINATED_CONFERENCE', 'TERMINATED_CONFERENCE':3, 4:'LEGACY_VOICE_CONFERENCE', 'LEGACY_VOICE_CONFERENCE':4, 5:'LEGACY_SHAREDGROUP', 'LEGACY_SHAREDGROUP':5} 2254 """ 2255 - DIALOG - 1:1 conversations, there is a one dialog per identity 2256 - CONFERENCE - equivalent of a multichat 2257 - TERMINATED_CONFERENCE - a conference that has been terminated (disbanded chat) 2258 - LEGACY_VOICE_CONFERENCE - voice-only conference, when host is using a legacy non-conversation client 2259 - LEGACY_SHAREDGROUP - chat used for legacy shared groups, can be ignored 2260 """ 2261 MY_STATUS = { 2262 1 :'CONNECTING', 2263 2 :'RETRY_CONNECTING', 2264 3 :'DOWNLOADING_MESSAGES', 2265 4 :'QUEUED_TO_ENTER', 2266 5 :'APPLICANT', 2267 6 :'APPLICATION_DENIED', 2268 7 :'INVALID_ACCESS_TOKEN', 2269 8 :'CONSUMER', 2270 9 :'RETIRED_FORCEFULLY', 2271 10:'RETIRED_VOLUNTARILY', 2272 'CONNECTING' : 1, 2273 'RETRY_CONNECTING' : 2, 2274 'DOWNLOADING_MESSAGES' : 3, 2275 'QUEUED_TO_ENTER' : 4, 2276 'APPLICANT' : 5, 2277 'APPLICATION_DENIED' : 6, 2278 'INVALID_ACCESS_TOKEN' : 7, 2279 'CONSUMER' : 8, 2280 'RETIRED_FORCEFULLY' : 9, 2281 'RETIRED_VOLUNTARILY' :10 2282 } 2283 """ 2284 - CONNECTING - connecting to conference 2285 - RETRY_CONNECTING 2286 - DOWNLOADING_MESSAGES - unused 2287 - QUEUED_TO_ENTER - conference is full for now, being queued 2288 - APPLICANT - I'm applying to join the conference 2289 - APPLICATION_DENIED - My application to join the conference was denied 2290 - INVALID_ACCESS_TOKEN - The password I provided is incorrect 2291 - CONSUMER - I'm part of the conference, I can participate 2292 - RETIRED_FORCEFULLY - I was kicked from the conference 2293 - RETIRED_VOLUNTARILY - I left the conference 2294 """ 2295 LOCAL_LIVESTATUS = { 2296 0 :'NONE', 2297 1 :'STARTING', 2298 2 :'RINGING_FOR_ME', 2299 3 :'IM_LIVE', 2300 5 :'ON_HOLD_LOCALLY', 2301 6 :'ON_HOLD_REMOTELY', 2302 7 :'OTHERS_ARE_LIVE', 2303 11:'OTHERS_ARE_LIVE_FULL', 2304 8 :'PLAYING_VOICE_MESSAGE', 2305 9 :'RECORDING_VOICE_MESSAGE', 2306 10:'RECENTLY_LIVE', 2307 12:'TRANSFERRING', 2308 'NONE' : 0, 2309 'STARTING' : 1, 2310 'RINGING_FOR_ME' : 2, 2311 'IM_LIVE' : 3, 2312 'ON_HOLD_LOCALLY' : 5, 2313 'ON_HOLD_REMOTELY' : 6, 2314 'OTHERS_ARE_LIVE' : 7, 2315 'OTHERS_ARE_LIVE_FULL' :11, 2316 'PLAYING_VOICE_MESSAGE' : 8, 2317 'RECORDING_VOICE_MESSAGE' : 9, 2318 'RECENTLY_LIVE' :10, 2319 'TRANSFERRING' :12 2320 } 2321 """ 2322 - NONE - there isn't a live session 2323 - STARTING - trying to start or join a live session 2324 - RINGING_FOR_ME - there is a live session ringing 2325 - IM_LIVE - the conference is live for me 2326 - ON_HOLD_LOCALLY - I put the live session on hold 2327 - ON_HOLD_REMOTELY - the live session was put on hold by someone else 2328 - OTHERS_ARE_LIVE - there is a live session on-going, I'm not participating but I could join 2329 - OTHERS_ARE_LIVE_FULL - there is a live session on-going without me, but I can't join because it's full 2330 - PLAYING_VOICE_MESSAGE - playing a voicemail (dialog only) 2331 - RECORDING_VOICE_MESSAGE - recording a voicemail (dialog only) 2332 - RECENTLY_LIVE - a live session just finished, we stay in this state for RECENTLY_LIVE_TIMEOUT setup key 2333 - TRANSFERRING - call is being transferred 2334 """ 2335 ALLOWED_ACTIVITY = {1:'SET_META', 'SET_META':1, 2:'ADD_CONSUMERS', 'ADD_CONSUMERS':2, 4:'SPEAK', 'SPEAK':4, 8:'SPEAK_AND_WRITE', 'SPEAK_AND_WRITE':8} 2336 """ 2337 values for opt_admin_only_activities property 2338 - SET_META - allowed to set the CONVERSATION_META properties 2339 - ADD_CONSUMERS - allowed to add participants to the conference 2340 - SPEAK - allowed to speak, but not write 2341 - SPEAK_AND_WRITE - allowed to speak and write 2342 """ 2343 PARTICIPANTFILTER = {0:'ALL', 'ALL':0, 1:'CONSUMERS', 'CONSUMERS':1, 2:'APPLICANTS', 'APPLICANTS':2, 3:'CONSUMERS_AND_APPLICANTS', 'CONSUMERS_AND_APPLICANTS':3, 4:'MYSELF', 'MYSELF':4, 5:'OTHER_CONSUMERS', 'OTHER_CONSUMERS':5} 2344 """ 2345 - ALL - All participants (may included some that are RETIRED or OUTLAW, but not all of them) 2346 - CONSUMERS - Participants that can receive messages, including myself 2347 - APPLICANTS - Only people who are applying to join the conversation 2348 - CONSUMERS_AND_APPLICANTS - Consumers and applicants 2349 - MYSELF - Myself 2350 - OTHER_CONSUMERS - All consumers except myself 2351 """ 2352 LIST_TYPE = {0:'ALL_CONVERSATIONS', 'ALL_CONVERSATIONS':0, 1:'INBOX_CONVERSATIONS', 'INBOX_CONVERSATIONS':1, 2:'BOOKMARKED_CONVERSATIONS', 'BOOKMARKED_CONVERSATIONS':2, 3:'LIVE_CONVERSATIONS', 'LIVE_CONVERSATIONS':3, 5:'REALLY_ALL_CONVERSATIONS', 'REALLY_ALL_CONVERSATIONS':5} 2353 """ 2354 - ALL_CONVERSATIONS - bookmarked or in_inbox or live or with_meta_info or activity in last 30 days 2355 - INBOX_CONVERSATIONS - only last 6 months conversations are kept there 2356 - BOOKMARKED_CONVERSATIONS - is_bookmarked is set 2357 - LIVE_CONVERSATIONS - local_livestatus is different from NONE 2358 - REALLY_ALL_CONVERSATIONS - all conversations, without any of the limits of ALL_CONVERSATIONS 2359 """ 2360
2361 - def _sk_get_identity(self):
2362 """ 2363 contact identity in case of dialogs, chat name in case of conferences 2364 """ 2365 return self._sk_property("ZG\314\007]\022", 972, True)
2366 identity = property(_sk_get_identity) 2367 propid2label[972] = "identity" 2368 P_IDENTITY = 972
2369 - def _sk_get_type(self):
2370 """ 2371 type of the conversation 2372 """ 2373 return skypekit.enumof(Conversation.TYPE, self._sk_property("ZG\206\007]\022", 902, True))
2374 type = property(_sk_get_type) 2375 propid2label[902] = "type" 2376 P_TYPE = 902
2377 - def _sk_get_live_host(self):
2378 """ 2379 host of current live session. none => no session. myself in case of 1:1 calls 2380 """ 2381 return self._sk_property("ZG\226\007]\022", 918, True)
2382 live_host = property(_sk_get_live_host) 2383 propid2label[918] = "live_host" 2384 P_LIVE_HOST = 918
2386 """ 2387 moment when first participant other than host joined the current or last live session 2388 """ 2389 return self._sk_property("ZG\316\007]\022", 974, True)
2390 live_start_timestamp = property(_sk_get_live_start_timestamp) 2391 propid2label[974] = "live_start_timestamp" 2392 P_LIVE_START_TIMESTAMP = 974
2393 - def _sk_get_live_is_muted(self):
2394 """ 2395 if live session is muted 2396 """ 2397 return self._sk_property("ZG\344\007]\022", 996, True)
2398 live_is_muted = property(_sk_get_live_is_muted) 2399 propid2label[996] = "live_is_muted" 2400 P_LIVE_IS_MUTED = 996
2401 - def _sk_get_alert_string(self):
2402 """ 2403 '' everything matches, '=' nothing matches, '=string' string matches 2404 """ 2405 return self._sk_property("ZG\230\007]\022", 920, True)
2406 alert_string = property(_sk_get_alert_string) 2407 propid2label[920] = "alert_string" 2408 P_ALERT_STRING = 920
2409 - def _sk_get_is_bookmarked(self):
2410 """ 2411 if conversation is bookmarked/flagged 2412 """ 2413 return self._sk_property("ZG\231\007]\022", 921, True)
2414 is_bookmarked = property(_sk_get_is_bookmarked) 2415 propid2label[921] = "is_bookmarked" 2416 P_IS_BOOKMARKED = 921
2417 - def _sk_get_given_displayname(self):
2418 """ 2419 local name assigned via Rename 2420 """ 2421 return self._sk_property("ZG\235\007]\022", 925, True)
2422 given_displayname = property(_sk_get_given_displayname) 2423 propid2label[925] = "given_displayname" 2424 P_GIVEN_DISPLAYNAME = 925
2425 - def _sk_get_displayname(self):
2426 """ 2427 resulting display name of the conversation (based on given name, topic, participant list, etc) 2428 """ 2429 return self._sk_property("ZG\234\007]\022", 924, True)
2430 displayname = property(_sk_get_displayname) 2431 propid2label[924] = "displayname" 2432 P_DISPLAYNAME = 924
2433 - def _sk_get_local_livestatus(self):
2434 """ 2435 if the conversation is live and in which status it is then 2436 """ 2437 return skypekit.enumof(Conversation.LOCAL_LIVESTATUS, self._sk_property("ZG\237\007]\022", 927, True))
2438 local_livestatus = property(_sk_get_local_livestatus) 2439 propid2label[927] = "local_livestatus" 2440 P_LOCAL_LIVESTATUS = 927
2441 - def _sk_get_inbox_timestamp(self):
2442 """ 2443 timestamp to sort the conversations in inbox by. 0 means not in inbox 2444 """ 2445 return self._sk_property("ZG\240\007]\022", 928, True)
2446 inbox_timestamp = property(_sk_get_inbox_timestamp) 2447 propid2label[928] = "inbox_timestamp" 2448 P_INBOX_TIMESTAMP = 928
2449 - def _sk_get_inbox_message_id(self):
2450 """ 2451 ID of the message that caused INBOX_TIMESTAMP to be set 2452 """ 2453 return module_id2classes[9](self._sk_property("ZG\315\007]\022", 973, True), self.transport)
2454 inbox_message_id = property(_sk_get_inbox_message_id) 2455 propid2label[973] = "inbox_message_id" 2456 P_INBOX_MESSAGE_ID = 973
2458 """ 2459 number of messages in UNCONSUMED_SUPPRESSED consumption status 2460 """ 2461 return self._sk_property("ZG\317\007]\022", 975, True)
2462 unconsumed_suppressed_messages = property(_sk_get_unconsumed_suppressed_messages) 2463 propid2label[975] = "unconsumed_suppressed_messages" 2464 P_UNCONSUMED_SUPPRESSED_MESSAGES = 975
2466 """ 2467 number of messages in UNCONSUMED_NORMAL consumption status 2468 """ 2469 return self._sk_property("ZG\320\007]\022", 976, True)
2470 unconsumed_normal_messages = property(_sk_get_unconsumed_normal_messages) 2471 propid2label[976] = "unconsumed_normal_messages" 2472 P_UNCONSUMED_NORMAL_MESSAGES = 976
2474 """ 2475 DEPRECATED, not set anymore 2476 """ 2477 return self._sk_property("ZG\321\007]\022", 977, True)
2478 unconsumed_elevated_messages = property(_sk_get_unconsumed_elevated_messages) 2479 propid2label[977] = "unconsumed_elevated_messages" 2480 P_UNCONSUMED_ELEVATED_MESSAGES = 977
2482 """ 2483 if there are unconsumed voice or call messages in the conversation 2484 """ 2485 return self._sk_property("ZG\312\007]\022", 970, True)
2486 unconsumed_messages_voice = property(_sk_get_unconsumed_messages_voice) 2487 propid2label[970] = "unconsumed_messages_voice" 2488 P_UNCONSUMED_MESSAGES_VOICE = 970
2489 - def _sk_get_active_vm_id(self):
2490 """ 2491 ID of voice message that is being played or recorded in this conversation 2492 """ 2493 return module_id2classes[7](self._sk_property("ZG\313\007]\022", 971, True), self.transport)
2494 active_vm_id = property(_sk_get_active_vm_id) 2495 propid2label[971] = "active_vm_id" 2496 P_ACTIVE_VM_ID = 971
2498 """ 2499 consumption cutoff timestamp: messages after (but not including) this are considered unconsumed 2500 """ 2501 return self._sk_property("ZG\323\007]\022", 979, True)
2502 consumption_horizon = property(_sk_get_consumption_horizon) 2503 propid2label[979] = "consumption_horizon" 2504 P_CONSUMPTION_HORIZON = 979
2506 """ 2507 timestamp of last activity in conversation 2508 """ 2509 return self._sk_property("ZG\325\007]\022", 981, True)
2510 last_activity_timestamp = property(_sk_get_last_activity_timestamp) 2511 propid2label[981] = "last_activity_timestamp" 2512 P_LAST_ACTIVITY_TIMESTAMP = 981
2514 """ 2515 dialog this conference was spawned from 2516 """ 2517 return module_id2classes[18](self._sk_property("ZG\223\007]\022", 915, True), self.transport)
2518 spawned_from_convo_id = property(_sk_get_spawned_from_convo_id) 2519 propid2label[915] = "spawned_from_convo_id" 2520 P_SPAWNED_FROM_CONVO_ID = 915
2521 - def _sk_get_creator(self):
2522 """ 2523 identity of conversation creator (doesn't apply to dialogs) 2524 """ 2525 return self._sk_property("ZG\207\007]\022", 903, True)
2526 creator = property(_sk_get_creator) 2527 propid2label[903] = "creator" 2528 P_CREATOR = 903
2529 - def _sk_get_creation_timestamp(self):
2530 """ 2531 timestamp of creation, tells you how far you can retrieve messages 2532 """ 2533 return self._sk_property("ZG\210\007]\022", 904, True)
2534 creation_timestamp = property(_sk_get_creation_timestamp) 2535 propid2label[904] = "creation_timestamp" 2536 P_CREATION_TIMESTAMP = 904
2537 - def _sk_get_my_status(self):
2538 """ 2539 my status in this conversation (connecting, participating, retired, etc) (doesn't apply to dialogs) 2540 """ 2541 return skypekit.enumof(Conversation.MY_STATUS, self._sk_property("ZG\227\007]\022", 919, True))
2542 my_status = property(_sk_get_my_status) 2543 propid2label[919] = "my_status" 2544 P_MY_STATUS = 919
2546 """ 2547 if it's a public conversation (doesn't apply to dialogs) 2548 """ 2549 return self._sk_property("ZG\232\007]\022", 922, True)
2550 opt_joining_enabled = property(_sk_get_opt_joining_enabled) 2551 propid2label[922] = "opt_joining_enabled" 2552 P_OPT_JOINING_ENABLED = 922
2553 - def _sk_get_opt_entry_level_rank(self):
2554 """ 2555 rank that is auto-assigned at join (doesn't apply to dialogs) 2556 """ 2557 return skypekit.enumof(Participant.RANK, self._sk_property("ZG\212\007]\022", 906, True))
2558 opt_entry_level_rank = property(_sk_get_opt_entry_level_rank) 2559 propid2label[906] = "opt_entry_level_rank" 2560 P_OPT_ENTRY_LEVEL_RANK = 906
2562 """ 2563 if history visible to new consumers (doesn't apply to dialogs) 2564 """ 2565 return self._sk_property("ZG\213\007]\022", 907, True)
2566 opt_disclose_history = property(_sk_get_opt_disclose_history) 2567 propid2label[907] = "opt_disclose_history" 2568 P_OPT_DISCLOSE_HISTORY = 907
2570 """ 2571 activities that only ADMIN can do. Bitmap of ALLOWED_ACTIVITY values (doesn't apply to dialogs) 2572 """ 2573 return self._sk_property("ZG\215\007]\022", 909, True)
2574 opt_admin_only_activities = property(_sk_get_opt_admin_only_activities) 2575 propid2label[909] = "opt_admin_only_activities" 2576 P_OPT_ADMIN_ONLY_ACTIVITIES = 909
2577 - def _sk_get_passwordhint(self):
2578 """ 2579 public conversation password hint, use SetPassword to set (doesn't apply to dialogs) 2580 """ 2581 return self._sk_property("ZG\324\007]\022", 980, True)
2582 passwordhint = property(_sk_get_passwordhint) 2583 propid2label[980] = "passwordhint" 2584 P_PASSWORDHINT = 980
2585 - def _sk_get_meta_name(self):
2586 """ 2587 deprecated, not used 2588 """ 2589 return self._sk_property("ZG\216\007]\022", 910, True)
2590 meta_name = property(_sk_get_meta_name) 2591 propid2label[910] = "meta_name" 2592 P_META_NAME = 910
2593 - def _sk_get_meta_topic(self):
2594 """ 2595 conversation topic (doesn't apply to dialogs) 2596 """ 2597 return self._sk_property("ZG\217\007]\022", 911, True)
2598 meta_topic = property(_sk_get_meta_topic) 2599 propid2label[911] = "meta_topic" 2600 P_META_TOPIC = 911
2601 - def _sk_get_meta_guidelines(self):
2602 """ 2603 guidelines (doesn't apply to dialogs) 2604 """ 2605 return self._sk_property("ZG\221\007]\022", 913, True)
2606 meta_guidelines = property(_sk_get_meta_guidelines) 2607 propid2label[913] = "meta_guidelines" 2608 P_META_GUIDELINES = 913
2609 - def _sk_get_meta_picture(self):
2610 """ 2611 conversation picture, in jpeg format (doesn't apply to dialogs) 2612 """ 2613 return self._sk_property("ZG\222\007]\022", 914, True)
2614 meta_picture = property(_sk_get_meta_picture) 2615 propid2label[914] = "meta_picture" 2616 P_META_PICTURE = 914 2617 2618 SETUPKEY_ENABLE_BIRTHDAY_NOTIFICATION = "Lib/Conversation/EnableBirthday" 2619 SETUPKEY_INBOX_UPDATE_TIMEOUT = "Lib/Conversation/InboxUpdateTimeout" 2620 SETUPKEY_RECENTLY_LIVE_TIMEOUT = "Lib/Conversation/RecentlyLiveTimeout" 2621 SETUPKEY_DISABLE_CHAT = "Lib/Chat/DisableChat" 2622 SETUPKEY_DISABLE_CHAT_HISTORY = "Lib/Message/DisableHistory" 2623 SETUPKEY_CHAT_HISTORY_DAYS = "Lib/Chat/HistoryDays" 2624 SETUPKEY_CHATDB_LIMIT_KB = "Lib/Chat/ChatDBLimitKb" 2625 SETUPKEY_DISABLE_CHAT_ACTIVITY_INDICATION = "Lib/Chat/DisableActivityIndication" 2626 SETUPKEY_CALL_NOANSWER_TIMEOUT = "Lib/Call/NoAnswerTimeout" 2627 SETUPKEY_CALL_SEND_TO_VM = "Lib/Call/SendToVM" 2628 SETUPKEY_CALL_APPLY_CF = "Lib/Call/ApplyCF" 2629 SETUPKEY_CALL_EMERGENCY_COUNTRY = "Lib/Call/EmergencyCountry"
2630 - def SetOption( 2631 self, 2632 prop_key, 2633 value 2634 ):
2635 """ 2636 Setter method for Conversation option properties. Option properties are all Conversation properties starting with OPT_ prefix. 2637 2638 2639 B{Arguments:} 2640 - B{prop_key} - Conversation property key, for example: Conversation::OPT_JOINING_ENABLED 2641 2642 - B{value} - New value for the option property. 2643 2644 """ 2645 l_request = skypekit.XCallRequest("ZR\022\001", 18, 1) 2646 l_request.add_parm('O', 0, self) 2647 l_request.add_parm('e', 1, prop_key) 2648 l_request.add_parm('u', 2, value) 2649 self.transport.xcall(l_request)
2650 - def SetTopic( 2651 self, 2652 topic, 2653 is_xml = False 2654 ):
2655 """ 2656 Setter for Conversation class META_TOPIC. This topic will be set for remote participants as well. 2657 2658 2659 B{Arguments:} 2660 - B{topic} - New conversation topic. 2661 2662 - B{is_xml} - Notifies remote UIs that the new topic contains xml tags. 2663 2664 """ 2665 l_request = skypekit.XCallRequest("ZR\022\002", 18, 2) 2666 l_request.add_parm('O', 0, self) 2667 l_request.add_parm('S', 1, topic) 2668 l_request.add_parm('b', 2, is_xml) 2669 self.transport.xcall(l_request)
2670 - def SetGuidelines( 2671 self, 2672 guidelines, 2673 is_xml = False 2674 ):
2675 """ 2676 Setter for Conversation META_GUIDELINES. This property will be visible to remote participants of the conversation. 2677 2678 2679 B{Arguments:} 2680 - B{guidelines} - New value for the META_GUIDELINES property. 2681 2682 - B{is_xml} - Set true to notify remote UIs that the new guideline contains XML tags. 2683 2684 """ 2685 l_request = skypekit.XCallRequest("ZR\022\003", 18, 3) 2686 l_request.add_parm('O', 0, self) 2687 l_request.add_parm('S', 1, guidelines) 2688 l_request.add_parm('b', 2, is_xml) 2689 self.transport.xcall(l_request)
2690 - def SetPicture( 2691 self, 2692 jpeg 2693 ):
2694 """ 2695 Sets the conversation's avatar to the specified JPEG image, which is propagated to both local and remote participants. Before calling this method, you should use Skype::ValidateAvatar to verify that jpeg references a valid JPEG image. 2696 2697 2698 B{Arguments:} 2699 - B{jpeg} - Conversation avatar binary. 2700 2701 """ 2702 l_request = skypekit.XCallRequest("ZR\022\004", 18, 4) 2703 l_request.add_parm('O', 0, self) 2704 l_request.add_parm('B', 1, jpeg) 2705 self.transport.xcall(l_request)
2706 - def SpawnConference( 2707 self, 2708 identities_to_add 2709 ):
2710 """ 2711 When called from dialog conversation, this spawns a new conversation, with existing two dialog participants plus new contact identities given in the identitiesToAdd list. You do not need to add existing dialog participants to the string list. In fact, passing only the existing participants in the identities list will cause the method call to fail (return false), the same as if the list was empty. This method will also return false if the original conversation was not a dialog (contained more than two participants). Also note that this method always creates a new Conversation - even if a conversation with exactly the same participant list existed before. 2712 2713 2714 B{Arguments:} 2715 - B{identities_to_add} - String list of additional participant identities. You do not need to add existing two participants from the original dialog to this list. 2716 2717 2718 B{Return values:} 2719 - B{conference} - Returns the resulting conversation or 0 if the method call failed. 2720 2721 """ 2722 l_request = skypekit.XCallRequest("ZR\022\006", 18, 6) 2723 l_request.add_parm('O', 0, self) 2724 l_request.add_parm('S', 1, identities_to_add) 2725 l_response = self.transport.xcall(l_request) 2726 l_result = module_id2classes[18](l_response.get(1), self.transport) 2727 return l_result
2728 - def AddConsumers( 2729 self, 2730 identities 2731 ):
2732 """ 2733 Takes one or more Contact identities and creates corresponding Participant objects within the context of this Conversation, which must be of type CONFERENCE. If you have an existing dialog conversation, use SpawnConference instead. 2734 2735 2736 B{Arguments:} 2737 - B{identities} - Contact identities to be added to the Conversation. 2738 2739 """ 2740 l_request = skypekit.XCallRequest("ZR\022\007", 18, 7) 2741 l_request.add_parm('O', 0, self) 2742 l_request.add_parm('S', 1, identities) 2743 self.transport.xcall(l_request)
2744 - def Assimilate( 2745 self, 2746 other_conversation 2747 ):
2748 """ 2749 Merges two live conversations. For example, if the user already has a live conversation up - let's call it conversation A. Then a new incoming call occurs - another conversation obtains LOCAL_LIVESTATUS == Conversation::RINGING_FOR_ME, let's call it conversation B. The user wishes to pick up the new incoming call and add it to the existing one. For this you can first call B->JoinLiveSession and then merge two calls with A->Assimilate(B, A). The second argument will return the merged conversation. Note that there are actually three conversation objects involved: A (before merge), B and C (after the merge). Normally it would make sense to have the first conversation (A) as the second argument, so that it gets overwritten with the assimilation result. 2750 2751 2752 B{Arguments:} 2753 - B{other_conversation} - The new conversation to be merged with the one already in live state. 2754 2755 2756 B{Return values:} 2757 - B{conversation} - Returns a 3rd live conversation, result of merging two existing ones. 2758 2759 """ 2760 l_request = skypekit.XCallRequest("ZR\022\011", 18, 9) 2761 l_request.add_parm('O', 0, self) 2762 l_request.add_parm('O', 1, other_conversation) 2763 l_response = self.transport.xcall(l_request) 2764 l_result = module_id2classes[18](l_response.get(1), self.transport) 2765 return l_result
2766 - def JoinLiveSession( 2767 self, 2768 access_token = "" 2769 ):
2770 """ 2771 starts, answers or joins a live session (first one to join becomes LIVE_HOST) 2772 2773 B{Arguments:} 2774 - B{access_token} - if starting a live session, allows to set a custom access token 2775 """ 2776 l_request = skypekit.XCallRequest("ZR\022\012", 18, 10) 2777 l_request.add_parm('O', 0, self) 2778 l_request.add_parm('S', 1, access_token) 2779 self.transport.xcall(l_request)
2780 - def RingOthers( 2781 self, 2782 identities = [], 2783 video_call = False, 2784 origin = "" 2785 ):
2786 """ 2787 This is an alternative to calling Ring method for each Participant individually. This also works with dialogs (with identities containing only one item). 2788 2789 2790 B{Arguments:} 2791 - B{identities} - List of Participants to ring. Leaving the list empty will result in ringing all participants of at least speaker level. 2792 2793 - B{video_call} - If true, indicates that we want to do a video call (video still needs to be separately enabled) 2794 2795 - B{origin} - When call is initiated from web link, this argument must contain the URI that was used 2796 2797 """ 2798 l_request = skypekit.XCallRequest("ZR\022$", 18, 36) 2799 l_request.add_parm('O', 0, self) 2800 l_request.add_parm('S', 1, identities) 2801 l_request.add_parm('b', 2, video_call) 2802 l_request.add_parm('S', 3, origin) 2803 self.transport.xcall(l_request)
2804 - def MuteMyMicrophone(self):
2805 """ 2806 Sets VOICE_STATUS to LISTENING in the Participant instance associated with us, causing any input from our microphone to be ignored. This is a Conversation class method, rather than Participant class, because this only applies to local participant. 2807 2808 """ 2809 l_request = skypekit.XCallRequest("ZR\022\013", 18, 11) 2810 l_request.add_parm('O', 0, self) 2811 self.transport.xcall(l_request)
2812 - def UnmuteMyMicrophone(self):
2813 """ 2814 Sets VOICE_STATUS to SPEAKING in the Participant instance associated with us, causing any input from our microphone to be sent to the call host. This is a Conversation class method, rather than Participant class, because this only applies to local participant. 2815 2816 """ 2817 l_request = skypekit.XCallRequest("ZR\022\014", 18, 12) 2818 l_request.add_parm('O', 0, self) 2819 self.transport.xcall(l_request)
2820 - def HoldMyLiveSession(self):
2821 """ 2822 Puts the conversation on hold - Conversation LOCAL_LIVESTATUS changes to ON_HOLD_LOCALLY and to ON_HOLD_REMOTELY for remote participants. 2823 2824 """ 2825 l_request = skypekit.XCallRequest("ZR\022\015", 18, 13) 2826 l_request.add_parm('O', 0, self) 2827 self.transport.xcall(l_request)
2828 - def ResumeMyLiveSession(self):
2829 """ 2830 Resumes call from local hold. 2831 2832 """ 2833 l_request = skypekit.XCallRequest("ZR\022\016", 18, 14) 2834 l_request.add_parm('O', 0, self) 2835 self.transport.xcall(l_request)
2836 - def LeaveLiveSession( 2837 self, 2838 post_voice_autoresponse = False 2839 ):
2840 """ 2841 Hang up or refuse to answer an incoming call. Set postVoiceAutoresponse to true to enable a caller to leave a voicemail message. 2842 2843 2844 B{Arguments:} 2845 - B{post_voice_autoresponse} 2846 """ 2847 l_request = skypekit.XCallRequest("ZR\022\017", 18, 15) 2848 l_request.add_parm('O', 0, self) 2849 l_request.add_parm('b', 1, post_voice_autoresponse) 2850 self.transport.xcall(l_request)
2851 - def StartVoiceMessage(self):
2852 """ 2853 Begin recording a voice mail for this conversation's remote participant. Applies to conversations of type DIALOG only. 2854 2855 """ 2856 l_request = skypekit.XCallRequest("ZR\022-", 18, 45) 2857 l_request.add_parm('O', 0, self) 2858 self.transport.xcall(l_request)
2859 - def TransferLiveSession( 2860 self, 2861 identities, 2862 transfer_topic = "" 2863 ):
2864 """ 2865 This method is for doing call transfers. NB! Call transfers only work in one-on-one conversations (dialogs). Before attempting call transfer, you should check availability of transfer recipients with Conversation class CanTransferLiveSession method. If the current conversation has a live session up, that session (call) will be transferred to targets specified in the identities list. Note that identities is a string list - all identities in that list will get incoming calls. The first one of them to pick up the call - wins, and rest of the transfer targets will stop ringing. 2866 2867 Let's take a closer look how this works in practice. We have three call participants involved in the process, and two separate conversations. Let there be three callers: Caller A (call originator), Caller B (transferor) and Caller C (recipient of transfer). 2868 2869 - Caller A - calls Caller B; Caller B picks up the call - live conversation C1 is now up with A and B in it. 2870 - After awhile, Caller B initiates call transfers to Caller C (and optionally to Callers D, E, F.. ). LOCAL_LIVESTATUS of C1 will get set to TRANSFERRING for both A and B. 2871 - Caller C picks up the call. Conversation C1 will go off live status. For Caller B, conversation C1 LOCAL_LIVESTATUS will change to RECENTLY_LIVE. Another live conversation - C2 gets spawned, with Caller A and Caller C in it. For caller C, participant object representing caller A will have TRANSFERRED_BY property set to identity of caller A. For Caller B (in now no longer live conversation C1), participant object representing caller A gets its TRANSFERRED_TO property set to identity of caller C. 2872 2873 2874 B{Arguments:} 2875 - B{identities} - String list of transfer target identities. As soon as first one in this list picks up the call, others will stop ringing. 2876 2877 - B{transfer_topic} - Optional conversation topic. This value will get set as META_TOPIC property of the conversation at the transferee end. Note that this is the only case where META_TOPIC field is used in context of dialog conversations. Thus assumption that remote UI will display topic field in case of dialogs may not be 100% correct. 2878 2879 """ 2880 l_request = skypekit.XCallRequest("ZR\022(", 18, 40) 2881 l_request.add_parm('O', 0, self) 2882 l_request.add_parm('S', 1, identities) 2883 l_request.add_parm('S', 2, transfer_topic) 2884 self.transport.xcall(l_request)
2885 - def CanTransferLiveSession( 2886 self, 2887 identity 2888 ):
2889 """ 2890 Checks if the identity is available for receiving a transferred live session. If you are going to attempt to go for multiple transfer targets, you should use this check for all the target identities. 2891 2892 2893 B{Arguments:} 2894 - B{identity} - Target identity. 2895 2896 2897 B{Return values:} 2898 - B{result} - Returns true if call transfer to given target is possible. 2899 2900 """ 2901 l_request = skypekit.XCallRequest("ZR\022.", 18, 46) 2902 l_request.add_parm('O', 0, self) 2903 l_request.add_parm('S', 1, identity) 2904 l_response = self.transport.xcall(l_request) 2905 l_result = l_response.get(1, False) 2906 return l_result
2907 - def SendDTMF( 2908 self, 2909 dtmf, 2910 length_in_ms = 260 2911 ):
2912 """ 2913 Sends DTMF tone to a live conversation. 2914 2915 2916 B{Arguments:} 2917 - B{dtmf} - Outgoing dtmf tone, possible values come from Participant::DTMF enumerator. 2918 2919 - B{length_in_ms} - Duration in milliseconds. Defaults to 260 ms. Note that the DTMF tone can be also cancelled with Conversation::StopSendDTMF method. 2920 2921 """ 2922 l_request = skypekit.XCallRequest("ZR\022\020", 18, 16) 2923 l_request.add_parm('O', 0, self) 2924 l_request.add_parm('e', 1, Participant.DTMF[dtmf]) 2925 l_request.add_parm('u', 2, length_in_ms) 2926 self.transport.xcall(l_request)
2927 - def StopSendDTMF(self):
2928 """ 2929 Stops the current DTMF tone being played into conversation. For example, use this method to cancel DTMF signals started with Conversation::SendDTMF before the duration given in lengthInMS runs out. 2930 2931 """ 2932 l_request = skypekit.XCallRequest("ZR\022\060", 18, 48) 2933 l_request.add_parm('O', 0, self) 2934 self.transport.xcall(l_request)
2935 - def SetMyTextStatusTo( 2936 self, 2937 status 2938 ):
2939 """ 2940 Sets local user typing indicator in the Conversation. Remote Participants can display these in their UI. 2941 2942 2943 B{Arguments:} 2944 - B{status} - Typing indicator status value - Participant::TEXT_STATUS 2945 2946 """ 2947 l_request = skypekit.XCallRequest("ZR\022\022", 18, 18) 2948 l_request.add_parm('O', 0, self) 2949 l_request.add_parm('e', 1, Participant.TEXT_STATUS[status]) 2950 self.transport.xcall(l_request)
2951 - def PostText( 2952 self, 2953 text, 2954 is_xml = False 2955 ):
2956 """ 2957 Posts the specified text the conversation, and populates message with a reference to the corresponding Message object (if no error occurred during execution). The isXML argument can be used if the client UI has already taken care of converting message text to xml (for example, your UI might enable users to use bold tags in text messages.) 2958 2959 2960 B{Arguments:} 2961 - B{text} - Text value of the outgoing message (gets set as BODY_XML property of the Message object). 2962 2963 - B{is_xml} - For cases where the text argument was already encoded as xml message. 2964 2965 2966 B{Return values:} 2967 - B{message} - Returns the Message object created as a result of this method (if successful). 2968 2969 """ 2970 l_request = skypekit.XCallRequest("ZR\022\023", 18, 19) 2971 l_request.add_parm('O', 0, self) 2972 l_request.add_parm('S', 1, text) 2973 l_request.add_parm('b', 2, is_xml) 2974 l_response = self.transport.xcall(l_request) 2975 l_result = module_id2classes[9](l_response.get(1), self.transport) 2976 return l_result
2977 - def PostContacts( 2978 self, 2979 contacts 2980 ):
2981 """ 2982 Takes a list of Contacts as an argument and posts the list into the Conversation. The purpose of this feature is to enable sharing contacts between users, without resorting to contact search. Instead, if user A has contacts B and C, he can post contact C into chat with contact B. At this point, Contact B can add contact C to his contact list. From remote side, the posted contacts will appear as messages with type Message::POSTED_CONTACTS appearing in the conversation. The UI should allow adding these contacts from messages with this type into the contact list. 2983 2984 The list of posted contacts can be retrieved with the Message::GetContacts method. 2985 2986 Additionally, the UI then can parse the posted Contact data out of the Message::P_BODY_XML property. The list of contacts is wrapped between <contacts ..> </contacts> tags. Each contact item in the xml has following format: 2987 - t - contact type. "s" - skype contact; "p" - phone number; 2988 - s - skypename, present only in skypename contacts (t="s") 2989 - p - phone number, present only in phone number contacts (t="p") 2990 - f - contact's full name, if available 2991 - d - contact's display name, if available 2992 2993 Note that only the type (t) field is mandatory. Depending on type, either skypename (s) or phone number (p) fields are always present. Full name and display name fields are optional. 2994 2995 Example BODY_XML with skypname contact: 2996 :: 2997 <contacts alt="alt text"><c t="s" s="skypename" f="full name"/></contacts> 2998 2999 3000 Example BODY_XML with PSTN contact: 3001 :: 3002 <contacts alt="alt text"><c t="p" p="+37212345678" d="Some PSTN number"/></contacts> 3003 3004 3005 Example BODY_XML with multiple contacts: 3006 :: 3007 <contacts alt="alt text"><c t="p" p="+37212345678" d="Some PSTN number"/><c t="s" s="someskypename"/></contacts> 3008 3009 3010 3011 B{Arguments:} 3012 - B{contacts} - List of Contact objects, to be posted in the conversation. 3013 3014 """ 3015 l_request = skypekit.XCallRequest("ZR\022\024", 18, 20) 3016 l_request.add_parm('O', 0, self) 3017 l_request.add_parm('O', 1, contacts) 3018 self.transport.xcall(l_request)
3019 - def PostFiles( 3020 self, 3021 paths, 3022 body 3023 ):
3024 """ 3025 Takes a list of fully-qualified filenames and initiates corresponding file transfers in the conversation. From the remote side, incoming file transfers will appear as a conversation message with type POSTED_FILES. Once such a message is detected, the list of file transfer objects can be retrieved with Message::GetTransfers. At that point, remote participants will need to accept or decline those transfers. 3026 3027 3028 B{Arguments:} 3029 - B{paths} - list of fully-qualified filenames to be transferred 3030 3031 - B{body} - Optional BODY_XML property for POSTED_FILES type messages that show up in remote UI. 3032 3033 3034 B{Return values:} 3035 - B{error_code} - Error code, possible values come from the TRANSFER_SENDFILE_ERROR enumerator. This will be set for the first failed fail. The failed file is identified in the error_file return argument. 3036 3037 - B{error_file} - Filename of the file that triggered error. 3038 3039 """ 3040 l_request = skypekit.XCallRequest("ZR\022\025", 18, 21) 3041 l_request.add_parm('O', 0, self) 3042 l_request.add_parm('f', 1, paths) 3043 l_request.add_parm('S', 2, body) 3044 l_response = self.transport.xcall(l_request) 3045 l_result = (skypekit.enumof(Skype.TRANSFER_SENDFILE_ERROR, l_response.get(1))), 3046 l_result += (l_response.get(2, '')), 3047 return l_result
3048 - def PostVoiceMessage( 3049 self, 3050 voicemail, 3051 body 3052 ):
3053 """ 3054 Stops the active voicemail recording and sends it (dialog only) 3055 3056 B{Arguments:} 3057 - B{voicemail} - This argument is deprecated as of SDK version 3.2. Instead of manually constructing Voicemail object, you can call Conversation::StartVoiceMessage method to start recording a voicemail in context of a dialog. PostVoiceMessage will stop recording this voicemail and post it in the dialog. If instead of sending Voicemail, the user decides to cancel it, you should use Conversation::LeaveLiveSession method (Voicemail::Cancel is deprecated). 3058 3059 - B{body} - Optional text message that remote UI can display in conversation, to notify the user of a new voicemail. 3060 3061 """ 3062 l_request = skypekit.XCallRequest("ZR\022\026", 18, 22) 3063 l_request.add_parm('O', 0, self) 3064 l_request.add_parm('O', 1, voicemail) 3065 l_request.add_parm('S', 2, body) 3066 self.transport.xcall(l_request)
3067 - def PostSMS( 3068 self, 3069 sms, 3070 body = "" 3071 ):
3072 """ 3073 Takes an SMS instance created by Skype::CreateOutgoingSms and posts it in the conversation. Note that you will need to set both Sms body text (Sms::SetBody) and recipient list (Sms::SetTargets) before you can post the object. 3074 3075 3076 B{Arguments:} 3077 - B{sms} - SMS object. 3078 3079 - B{body} - This argument is currently ignored. The message text needs to be set with Sms::SetBody method, prior to passing the Sms object to this method 3080 3081 """ 3082 l_request = skypekit.XCallRequest("ZR\022\027", 18, 23) 3083 l_request.add_parm('O', 0, self) 3084 l_request.add_parm('O', 1, sms) 3085 l_request.add_parm('S', 2, body) 3086 self.transport.xcall(l_request)
3087 - def GetJoinBlob(self):
3088 """ 3089 Retrieves a binary join blob for joining public conversations, which are always of type CONFERENCE. If called for a dialog, the blob argument will contain the empty string. The best way to create a Public Chat is to first create a fresh conversation with Skype class CreateConference, then minimally apply the public chat options OPT_JOINING_ENABLED and OPT_ENTRY_LEVEL_RANK - options, like this (C++): 3090 :: 3091 C->SetOption(Conversation::OPT_JOINING_ENABLED, true); 3092 3093 3094 When that is done, you can call GetJoinBlob to retrieve the blob string. Use the blob string to generate and post an HTML link whose href attribute looks like this: href="skype:?chat&blob=_BLOB_GOES_HERE" A person running Skype desktop client can click this link to join the conversation and have that conversation opened in his UI. Note that the conversation host (creator) needs to be online for new joiners-via-link to start participating in the Public Chat. 3095 3096 B{Return values:} 3097 - B{blob} - Returns the public conversation join blob. 3098 3099 """ 3100 l_request = skypekit.XCallRequest("ZR\022\030", 18, 24) 3101 l_request.add_parm('O', 0, self) 3102 l_response = self.transport.xcall(l_request) 3103 l_result = l_response.get(1, '') 3104 return l_result
3105 - def Join(self):
3106 """ 3107 Tries to join a public conversation (aka public chat). This method is only useful if you have used Skype::GetConversationByBlob method with alsoJoin argument set to false. 3108 3109 """ 3110 l_request = skypekit.XCallRequest("ZR\022\031", 18, 25) 3111 l_request.add_parm('O', 0, self) 3112 self.transport.xcall(l_request)
3113 - def EnterPassword( 3114 self, 3115 password 3116 ):
3117 """ 3118 Submits password for joining password-protected conversation. 3119 3120 3121 B{Arguments:} 3122 - B{password} - Password string. 3123 3124 """ 3125 l_request = skypekit.XCallRequest("ZR\022\032", 18, 26) 3126 l_request.add_parm('O', 0, self) 3127 l_request.add_parm('S', 1, password) 3128 self.transport.xcall(l_request)
3129 - def SetPassword( 3130 self, 3131 password, 3132 hint 3133 ):
3134 """ 3135 Sets password protection/new password for the conversation. 3136 3137 3138 B{Arguments:} 3139 - B{password} - New password. 3140 3141 - B{hint} - Password hint. 3142 3143 """ 3144 l_request = skypekit.XCallRequest("ZR\022\033", 18, 27) 3145 l_request.add_parm('O', 0, self) 3146 l_request.add_parm('S', 1, password) 3147 l_request.add_parm('S', 2, hint) 3148 self.transport.xcall(l_request)
3149 - def RetireFrom(self):
3150 """ 3151 Leaves the conference. Not applicable to dialogs. 3152 3153 """ 3154 l_request = skypekit.XCallRequest("ZR\022\034", 18, 28) 3155 l_request.add_parm('O', 0, self) 3156 self.transport.xcall(l_request)
3157 - def Delete(self):
3158 """ 3159 Deletes this conversation, which must be of type CONFERENCE - dialogs between local user and any of his contacts are always persistant. Note that this also removes corresponding Message and Participant objects. 3160 3161 """ 3162 l_request = skypekit.XCallRequest("ZR\022/", 18, 47) 3163 l_request.add_parm('O', 0, self) 3164 self.transport.xcall(l_request)
3165 - def RenameTo( 3166 self, 3167 name 3168 ):
3169 """ 3170 Changes the META_NAME property of the conversation. Note that unlike topic and guidelines, this rename is just local - remote participants can have their own private names for conversations. 3171 3172 3173 B{Arguments:} 3174 - B{name} - New name for the conversation. Passing an empty string in this argument causes the META_NAME to unset. 3175 3176 """ 3177 l_request = skypekit.XCallRequest("ZR\022\035", 18, 29) 3178 l_request.add_parm('O', 0, self) 3179 l_request.add_parm('S', 1, name) 3180 self.transport.xcall(l_request)
3181 - def SetBookmark( 3182 self, 3183 bookmark 3184 ):
3185 """ 3186 Setter for Conversation class IS_BOOKMARKED. 3187 3188 3189 B{Arguments:} 3190 - B{bookmark} - Set true to set the bookmark, false to remove the bookmark. 3191 3192 """ 3193 l_request = skypekit.XCallRequest("ZR\022\036", 18, 30) 3194 l_request.add_parm('O', 0, self) 3195 l_request.add_parm('b', 1, bookmark) 3196 self.transport.xcall(l_request)
3197 - def SetAlertString( 3198 self, 3199 alert_string 3200 ):
3201 """ 3202 Setter for Conversation class ALERT_STRING property. The main use of this property is checking bodies of incoming messages in the conversation for the alert string and producing notifications in UI for the user, when appropriate. 3203 3204 3205 B{Arguments:} 3206 - B{alert_string} - Substring to check in BODY_XML property of incoming messages. 3207 3208 """ 3209 l_request = skypekit.XCallRequest("ZR\022\037", 18, 31) 3210 l_request.add_parm('O', 0, self) 3211 l_request.add_parm('S', 1, alert_string) 3212 self.transport.xcall(l_request)
3213 - def RemoveFromInbox(self):
3214 """ 3215 Removes conversation from Inbox. 3216 3217 """ 3218 l_request = skypekit.XCallRequest("ZR\022 ", 18, 32) 3219 l_request.add_parm('O', 0, self) 3220 self.transport.xcall(l_request)
3221 - def AddToInbox( 3222 self, 3223 timestamp = 0 3224 ):
3225 """ 3226 Sets Conversation inbox_timestamp property. If the timestamp argument is left empty or is greater than conversation consumption horizon, then the conversation will be restored to the inbox. 3227 3228 3229 B{Arguments:} 3230 - B{timestamp} - If left empty or set to 0, the inbox_timestamp property is set to current time. 3231 3232 """ 3233 l_request = skypekit.XCallRequest("ZR\022!", 18, 33) 3234 l_request.add_parm('O', 0, self) 3235 l_request.add_parm('u', 1, timestamp) 3236 self.transport.xcall(l_request)
3237 - def SetConsumedHorizon( 3238 self, 3239 timestamp, 3240 also_unconsume = False 3241 ):
3242 """ 3243 This method can be used to set the consumption (read) status of messages in the conversation. It sets Message::CONSUMPTION_STATUS to Message::CONSUMED for all messages in the conversation, older than the given timestamp. If the second argument is set to true, it also modifies messages more recent than the timestamp, by marking them as unconsumed. 3244 3245 3246 B{Arguments:} 3247 - B{timestamp} - Consumption cutoff timestamp. Setting this to current time will mark all messages in the conversation as consumed. 3248 3249 - B{also_unconsume} - If set to true, this also marks messages newer than the cutoff timestamp as unconsumed. For example, setting timestamp to 0 and also_unconsumed to true, will unconsume all messages in the conversation. 3250 3251 """ 3252 l_request = skypekit.XCallRequest("ZR\022\042", 18, 34) 3253 l_request.add_parm('O', 0, self) 3254 l_request.add_parm('u', 1, timestamp) 3255 l_request.add_parm('b', 2, also_unconsume) 3256 self.transport.xcall(l_request)
3257 - def MarkUnread(self):
3258 """ 3259 sets consumption horizon to last inbox message id timestamp 3260 """ 3261 l_request = skypekit.XCallRequest("ZR\022#", 18, 35) 3262 l_request.add_parm('O', 0, self) 3263 self.transport.xcall(l_request)
3264 - def IsMemberOf( 3265 self, 3266 group 3267 ):
3268 """ 3269 Checks if the conversation is a member of the given ContactGroup 3270 3271 3272 B{Arguments:} 3273 - B{group} - ContactGroup 3274 3275 3276 B{Return values:} 3277 - B{result} - True if this conversation is a member of the ContactGroup specified by the group argument contains the conversation 3278 3279 """ 3280 l_request = skypekit.XCallRequest("ZR\022%", 18, 37) 3281 l_request.add_parm('O', 0, self) 3282 l_request.add_parm('O', 1, group) 3283 l_response = self.transport.xcall(l_request) 3284 l_result = l_response.get(1, False) 3285 return l_result
3286 - def GetParticipants( 3287 self, 3288 filter = "ALL" 3289 ):
3290 """ 3291 Retrieves the list of this conversation's current participants, which you can optionally request to be filtered. If no Participants pass the filter, an empty list will be returned (the method itself still returns true). 3292 3293 3294 B{Arguments:} 3295 - B{filter} - Conversation::PARTICIPANTFILTER - defaults to Conversation::ALL 3296 3297 3298 B{Return values:} 3299 - B{participants} - List of conversation Participant objects that passed the filter. 3300 3301 """ 3302 l_request = skypekit.XCallRequest("ZR\022&", 18, 38) 3303 l_request.add_parm('O', 0, self) 3304 l_request.add_parm('e', 1, Conversation.PARTICIPANTFILTER[filter]) 3305 l_response = self.transport.xcall(l_request) 3306 l_result = [module_id2classes[19](oid, self.transport) for oid in l_response.get(1, [])] 3307 return l_result
3308 - def GetLastMessages( 3309 self, 3310 require_timestamp = 0 3311 ):
3312 """ 3313 Returns recent messages. The messages are returned in two lists - new messages (unconsumed) and recent message history (context messages). The context message list contains messages that are already above the consumption horizon but are fairly recent, making it likely that displaying them in UI would be good default behaviour. 3314 3315 3316 B{Arguments:} 3317 - B{require_timestamp} - If set to a non-zero value, includes messages no earlier than this timestamp, if not, includes messages from the last 24 hours only 3318 3319 3320 B{Return values:} 3321 - B{context_messages} - Already consumed messages, provided for context 3322 - B{unconsumed_messages} - Unconsumed messages 3323 """ 3324 l_request = skypekit.XCallRequest("ZR\022'", 18, 39) 3325 l_request.add_parm('O', 0, self) 3326 l_request.add_parm('u', 1, require_timestamp) 3327 l_response = self.transport.xcall(l_request) 3328 l_result = ([module_id2classes[9](oid, self.transport) for oid in l_response.get(1, [])]), 3329 l_result += ([module_id2classes[9](oid, self.transport) for oid in l_response.get(2, [])]), 3330 return l_result
3331 - def FindMessage( 3332 self, 3333 text, 3334 from_timestamp_up = skypekit.MAX_UINT 3335 ):
3336 """ 3337 Finds the most recent Message object in the conversation that contains the substring specified by the text argument. If no matching messages are found, this method will return false. The search proceeds backwards in time, starting from the timestamp argument. To continue searching, you can start with timestamp=MAX_UINT, retrieve the TIMESTAMP property of the matching message, decrement it by one, and submit it as timestamp for the next FindMessage call. 3338 3339 3340 B{Arguments:} 3341 - B{text} - Substring to search for. 3342 3343 - B{from_timestamp_up} 3344 3345 B{Return values:} 3346 - B{message} - Returns matching message or 0 if there was no match. As the likelihood of this object being invalid is quite high, you should always check for method return value before you start calling methods of this object. 3347 3348 """ 3349 l_request = skypekit.XCallRequest("ZR\022)", 18, 41) 3350 l_request.add_parm('O', 0, self) 3351 l_request.add_parm('S', 1, text) 3352 l_request.add_parm('u', 2, from_timestamp_up) 3353 l_response = self.transport.xcall(l_request) 3354 l_result = module_id2classes[9](l_response.get(1), self.transport) 3355 return l_result
3356 - def OnParticipantListChange(self):
3357 """ 3358 This callback gets fired when participants join or leave the conversation. 3359 3360 """ 3361 pass
3362 - def _sk_on_participant_list_change(self, parms):
3363 """ internal event dispatcher for OnParticipantListChange """ 3364 self.OnParticipantListChange()
3365 event_handlers[1] = "_sk_on_participant_list_change"
3366 - def OnMessage( 3367 self, 3368 message 3369 ):
3370 """ 3371 Called for each message in currently loaded conversations 3372 3373 B{Return values:} 3374 - B{message} 3375 """ 3376 pass
3377 event_handlers[2] = "_sk_on_message"
3378 - def _sk_on_message(self, parms):
3379 """ internal event dispatcher for OnMessage """ 3380 l_cleanparms = module_id2classes[9](parms.get(1), self.transport) 3381 self.OnMessage(l_cleanparms)
3382 - def OnSpawnConference( 3383 self, 3384 spawned 3385 ):
3386 """ 3387 This callback gets fired when a new Conversation is created using SpawnConference. 3388 3389 3390 B{Return values:} 3391 - B{spawned} - Conversation object that got created. 3392 3393 """ 3394 pass
3395 event_handlers[3] = "_sk_on_spawn_conference"
3396 - def _sk_on_spawn_conference(self, parms):
3397 """ internal event dispatcher for OnSpawnConference """ 3398 l_cleanparms = module_id2classes[18](parms.get(1), self.transport) 3399 self.OnSpawnConference(l_cleanparms)
3400 module_id2classes[18] = Conversation
3401 3402 -class Message(skypekit.Object):
3403 """ 3404 Events in a conversation context are expressed as Messages. It is therefore useful to think of Message objects as events, rather than specifically text chat messages. 3405 3406 Message member functions all return a Boolean indicating the success (true) or failure (false) of processing the request itself (transport, runtime availability, and so forth) - not the success or failure of its associated functionality. For example, Message::Edit returns true if it was able to make a determination, and its result parameter reflects whether this Message can be edited. Similarly, Message::Edit returns false if it was unable to make a determination, and the value of its result parameter is undefined. 3407 3408 Message member functions that are specific to a Message TYPE return false if this Message is not of that type. For example, Message::GetVoiceMessage will return false if this Message's type is not POSTED_VOICE_MESSAGE. 3409 3410 The actual meaning of a Message can be determined by its P_TYPE property. The meanings of most other Message properties depend on the value of P_TYPE. For example, let's take P_BODY_XML property. 3411 3412 Following messages have a text entered by the user as a body. It may contain emoticons, URLs, etc. 3413 - POSTED_TEXT 3414 - POSTED_EMOTE 3415 - SET_METADATA 3416 - REQUESTED_AUTH 3417 3418 Following messages have a custom XML format for the body (see the specific section on these message types for details): 3419 - POSTED_CONTACTS 3420 - POSTED_VOICE_MESSAGE 3421 - POSTED_FILES 3422 - POSTED_SMS 3423 - STARTED_LIVESESSION and ENDED_LIVESESSION (same format) 3424 3425 Following messages do not use the body property: 3426 - SPAWNED_CONFERENCE 3427 - ADDED_CONSUMERS 3428 - ADDED_APPLICANTS 3429 - RETIRED_OTHERS 3430 - RETIRED 3431 - SET_RANK 3432 - HAS_BIRTHDAY 3433 - GRANTED_AUTH 3434 - BLOCKED 3435 3436 Messages such as POSTED_TEXT use a small subset of a HTML-like markup to control the visual representation of the text. This markup is used by POSTED_TEXT and POSTED_EMOTE, but also for the conversation topic (CONVERSATION_META_TOPIC property and the body of the SET_METADATA message) and for authorization requests. 3437 3438 Having chat messages in XML format means that all formatting is indicated by XML tags. This includes emoticons and URls. The big advantage is that it makes the parsing of the message by the UI much easier. The UI does not need to do emoticons or URL detection, this is already done and it only needs to look for the XML tags. 3439 3440 For text messages, it is possible for the UI to simply ignore (meaning strip) the XML and the message will be understandable fine, it will only have lost some formatting. 3441 3442 But it is obviously nicer to display at least the most commonly used tags. 3443 3444 To strip the XML: 3445 - if they have the alt="sometext" attribute set, return sometext as the output of that tag and ignore the rest of tag and all nested sub tags 3446 - if no alt="" attribute set, use tag content as output - <sometag>hereissomething</sometag> is output as hereissomething 3447 - if no alt="" and no tag content, ignore the tag altogether (return nothing) 3448 Skype for Windows supports displaying many XML tags, but only a sub-set is regularly used and should be supported by the UI for a good experience. These are the ones described here. 3449 Animated emoticons 3450 Emoticons are encoded with the "ss" tag. The element content is the plain text representation. It has a "type" attribute indicating the emoticons canonical name. Example: 3451 :: 3452 Hi <ss type="smile">:-)</ss> 3453 3454 3455 Flag emoticons 3456 Flag emoticons are little flags. They are encoded with the "flag" tag. The element contents is the plain text representation and it has a "country" attribute which is a 2-letter ISO-3166 country code. The user can enter a flag using "(flag:XX)", where XX is a valid ISO country code. Example: 3457 :: 3458 I am in <flag country="cc">CC</flag> 3459 3460 3461 Links 3462 If the library detects a URL, it will encode it using the html "a" tag, with the "href" attribute indicating the URL. The plain text representation is what the user originally typed. Example: 3463 :: 3464 I am in <a href="http://wwww.skype.com">www.skype.com</a> 3465 3466 3467 Alert matches 3468 When a conversation is configured to display only alerts if specific words are present in the message (see "/alertson [text to match]" command), if a message matches the alert, it will be marked with the <alertmatch> tag. This allows the UI to highlight the word matching. Example: 3469 :: 3470 Maybe <alertmatch>Vincent</alertmatch> knows the answer 3471 3472 3473 Bold, italic, etc 3474 Skype for Windows also supports displaying bold and italic text, using the "b" and "i" tags. 3475 3476 Encoding messages 3477 When sending a chat message via PostText(), there is the possibility to indicate if the library should do the XML encoding, or if the message has already been encoded. Usually, the UI can let library do the encoding. This is the case when the message does not contain any specific formatting. It may contain emoticons or URls, which will be detected by the library encoder and converted into XML tags. 3478 If the message has some more complex encoding, such as a quote or some bold text, it is up to the UI to encode the message. 3479 3480 """ 3481 event_handlers = {} 3482 propid2label = {}
3483 - def _sk_init_(self, object_id, transport):
3484 """ actual constructor """ 3485 skypekit.Object._sk_init_(self, object_id, transport)
3486 - def __str__(self):
3487 return "Message %s" % (self.object_id, )
3488 @staticmethod
3489 - def propid(propname):
3490 """ convert a property name to the enum of the property """ 3491 return getattr(Message, "P_"+propname.upper())
3492 module_id = 9
3493 - def OnPropertyChange(self, property_name):
3494 """ notifies from a property change """ 3495 3496 pass
3497 TYPE = { 3498 2 :'SET_METADATA', 3499 4 :'SPAWNED_CONFERENCE', 3500 10 :'ADDED_CONSUMERS', 3501 11 :'ADDED_APPLICANTS', 3502 12 :'RETIRED_OTHERS', 3503 13 :'RETIRED', 3504 21 :'SET_RANK', 3505 30 :'STARTED_LIVESESSION', 3506 39 :'ENDED_LIVESESSION', 3507 50 :'REQUESTED_AUTH', 3508 51 :'GRANTED_AUTH', 3509 53 :'BLOCKED', 3510 61 :'POSTED_TEXT', 3511 60 :'POSTED_EMOTE', 3512 63 :'POSTED_CONTACTS', 3513 64 :'POSTED_SMS', 3514 65 :'POSTED_ALERT', 3515 67 :'POSTED_VOICE_MESSAGE', 3516 68 :'POSTED_FILES', 3517 69 :'POSTED_INVOICE', 3518 110:'HAS_BIRTHDAY', 3519 'SET_METADATA' : 2, 3520 'SPAWNED_CONFERENCE' : 4, 3521 'ADDED_CONSUMERS' : 10, 3522 'ADDED_APPLICANTS' : 11, 3523 'RETIRED_OTHERS' : 12, 3524 'RETIRED' : 13, 3525 'SET_RANK' : 21, 3526 'STARTED_LIVESESSION' : 30, 3527 'ENDED_LIVESESSION' : 39, 3528 'REQUESTED_AUTH' : 50, 3529 'GRANTED_AUTH' : 51, 3530 'BLOCKED' : 53, 3531 'POSTED_TEXT' : 61, 3532 'POSTED_EMOTE' : 60, 3533 'POSTED_CONTACTS' : 63, 3534 'POSTED_SMS' : 64, 3535 'POSTED_ALERT' : 65, 3536 'POSTED_VOICE_MESSAGE' : 67, 3537 'POSTED_FILES' : 68, 3538 'POSTED_INVOICE' : 69, 3539 'HAS_BIRTHDAY' :110 3540 } 3541 """ 3542 The P_TYPE property determines the actual meaning of the Message object. Only Messages of POSTED_TEXT type contain actual text messages. The meaning and content of the rest of the message properties are largely dependant of the value of the Message::P_TYPE. 3543 3544 - SET_METADATA - Conference metadata were changed 3545 - SPAWNED_CONFERENCE - A conference was spawned from this dialog 3546 - ADDED_CONSUMERS - Some users were added to the conference 3547 - ADDED_APPLICANTS - Some users are applying to be added to the conference 3548 - RETIRED_OTHERS - User was kicked from the conference 3549 - RETIRED - User left the conference 3550 - SET_RANK - Changed the rank of a user in the Conversation (multichat administration) 3551 3552 - STARTED_LIVESESSION - A live session started 3553 - ENDED_LIVESESSION - A live session ended 3554 - REQUESTED_AUTH - User requested authorization 3555 - GRANTED_AUTH - User was granted authorization. Notification message that user is now an authorized contact (of the local user). 3556 3557 - BLOCKED - User was blocked 3558 - POSTED_TEXT - A text message 3559 - POSTED_EMOTE - An emote ('John Doe is laughing', cf /me chat command) 3560 - POSTED_CONTACTS - The message represents (a set of) contact card(s) posted in the conversation. One message can contain more than one contact cards. The contacts can be retrieved from the message by parsing them out from the P_BODY_XML property. For more information, see Conversation::PostContacts 3561 3562 - POSTED_SMS - The message represents an SMS object that was posted in the Conversation. See Conversation::PostSMS for more details. The Sms object itself can be retrieved from the Message with Message::GetSms The message BODY_XML contains a set of SMS properties, such as status, failurereason, targets, price and timestamp. 3563 3564 - POSTED_ALERT - Deprecated, never sent 3565 - POSTED_VOICE_MESSAGE - A voicemail 3566 - POSTED_FILES - The message represents a (list of) file transfers that were posted in the Conversation with Conversation::PostFiles. Transfer objects can be retrieved from the Message with Message::GetTransfers 3567 3568 - POSTED_INVOICE - Currently unused. 3569 3570 - HAS_BIRTHDAY - The message represents a Contact birthday notification. 3571 3572 """ 3573 SENDING_STATUS = {1:'SENDING', 'SENDING':1, 2:'SENT', 'SENT':2, 3:'FAILED_TO_SEND', 'FAILED_TO_SEND':3} 3574 """ 3575 - SENDING - Message has not been delivered to at least one of the participants 3576 3577 - SENT - Message has been delivered to at least one other participant 3578 3579 - FAILED_TO_SEND - Message could not be delivered (for SMS this reflects the actual SMS, not the chat message) 3580 3581 """ 3582 CONSUMPTION_STATUS = {0:'CONSUMED', 'CONSUMED':0, 1:'UNCONSUMED_SUPPRESSED', 'UNCONSUMED_SUPPRESSED':1, 2:'UNCONSUMED_NORMAL', 'UNCONSUMED_NORMAL':2, 3:'UNCONSUMED_ELEVATED', 'UNCONSUMED_ELEVATED':3} 3583 """ 3584 Indicates if a message has been consumed (meaning read) or not 3585 - CONSUMED - Message has been read. Note that this is a read-only property. Consumption status of individual messages can not be set selectively. Message consumption status is determined at the conversation level, based conversation consumption horizon and individual message timestamps. Conversation consumption horizon can be updated with Conversation::SetConsumedHorizon method. 3586 3587 - UNCONSUMED_SUPPRESSED - Do not notify the user that they have this unread message 3588 3589 - UNCONSUMED_NORMAL - Notify the user that they have this unread message 3590 3591 - UNCONSUMED_ELEVATED - This message consumption state is marked as DEPRECATED 3592 3593 """ 3594 SET_METADATA_KEY = {3640:'SET_META_NAME', 'SET_META_NAME':3640, 3644:'SET_META_TOPIC', 'SET_META_TOPIC':3644, 3652:'SET_META_GUIDELINES', 'SET_META_GUIDELINES':3652, 3658:'SET_META_PICTURE', 'SET_META_PICTURE':3658} 3595 """ 3596 For messages of type SET_METADATA that alert participants to changes to the associated Conversation's metadata, indicates which metadata property changed and its P_BODY_XML property contains the changed data. Your UI is expected to detect messages with PARAM_KEY set and to update its visual representation of Conversation accordingly. 3597 You can use the associated Conversation's properties and methods to obtain the updated metadata rather than parse the message body XML, for example, Conversation::P_META_PICTURE and Conversation::Conversation::GetPropMetaPicture. 3598 3599 - SET_META_NAME - Notification message that conversation name has changed. 3600 3601 - SET_META_TOPIC - Notification message that conversation topic has changed. 3602 3603 - SET_META_GUIDELINES - Notification message that conversation guidelines have changed. 3604 3605 - SET_META_PICTURE - Notification message that conversation picture has changed. 3606 3607 """ 3608 LEAVEREASON = {2:'USER_INCAPABLE', 'USER_INCAPABLE':2, 3:'ADDER_MUST_BE_FRIEND', 'ADDER_MUST_BE_FRIEND':3, 4:'ADDER_MUST_BE_AUTHORIZED', 'ADDER_MUST_BE_AUTHORIZED':4, 5:'DECLINE_ADD', 'DECLINE_ADD':5, 6:'UNSUBSCRIBE', 'UNSUBSCRIBE':6} 3609 """ 3610 Indicates the reason a user could not join or left a Conversation. SkypeKit automatically sets "could not join"-related values. "Left voluntarily"-related values are set as a result of explicit user actions. 3611 3612 - USER_INCAPABLE - User cannot chat (user is currently logged in with a client that has chat disabled - see Contact::CAPABILITY.CAPABILITY_TEXT) 3613 3614 - ADDER_MUST_BE_FRIEND - Attempt to add local user to a conversation by an unknown contact 3615 3616 - ADDER_MUST_BE_AUTHORIZED - Attempt to add local user to a conversation by an unauthorized contact 3617 3618 - DECLINE_ADD - Local user declined an "invitation" to join a chat 3619 3620 - UNSUBSCRIBE - User decided to end participation in an on-going multi-chat 3621 3622 """ 3623
3624 - def _sk_get_convo_id(self):
3625 """ 3626 DB ID of corresponding conversation 3627 """ 3628 return module_id2classes[18](self._sk_property("ZG\300\007]\011", 960, True), self.transport)
3629 convo_id = property(_sk_get_convo_id) 3630 propid2label[960] = "convo_id" 3631 P_CONVO_ID = 960
3632 - def _sk_get_convo_guid(self):
3633 """ 3634 GUID of the Conversation. The GUID is a "global ID" - these values are shared accross Skype client instances and accross all the participants of the conversation. 3635 3636 """ 3637 return self._sk_property("ZGx]\011", 120, True)
3638 convo_guid = property(_sk_get_convo_guid) 3639 propid2label[120] = "convo_guid" 3640 P_CONVO_GUID = 120
3641 - def _sk_get_author(self):
3642 """ 3643 Identity of the sender. While this is almost always the same as SKYPENAME property of the Contact, in some rare cases it can also be a phone number - for example, incoming voicemail notification Messages (message type = POSTED_VOICE_MESSAGE). 3644 3645 """ 3646 return self._sk_property("ZGz]\011", 122, True)
3647 author = property(_sk_get_author) 3648 propid2label[122] = "author" 3649 P_AUTHOR = 122
3650 - def _sk_get_author_displayname(self):
3651 """ 3652 displayname of the sender at the time of posting 3653 """ 3654 return self._sk_property("ZG{]\011", 123, True)
3655 author_displayname = property(_sk_get_author_displayname) 3656 propid2label[123] = "author_displayname" 3657 P_AUTHOR_DISPLAYNAME = 123
3658 - def _sk_get_guid(self):
3659 """ 3660 Unlike the message id, the GUID is the same on all instances and for all participants. 3661 3662 """ 3663 return self._sk_property("ZG\230\006]\011", 792, True)
3664 guid = property(_sk_get_guid) 3665 propid2label[792] = "guid" 3666 P_GUID = 792
3668 """ 3669 This property gets set when a conference is spawned from dialog Conversation. In that case recent message history from the original dialog is copied to the target conversation. For all the copied messages, the ORIGINALLY_MEANT_FOR property will be set to identity of the remote participant of the original dialog. 3670 3671 """ 3672 return self._sk_property("ZG\226\006]\011", 790, True)
3673 originally_meant_for = property(_sk_get_originally_meant_for) 3674 propid2label[790] = "originally_meant_for" 3675 P_ORIGINALLY_MEANT_FOR = 790
3676 - def _sk_get_timestamp(self):
3677 """ 3678 UNIX timestamp (sent time, adjusted for local clock) 3679 """ 3680 return self._sk_property("ZGy]\011", 121, True)
3681 timestamp = property(_sk_get_timestamp) 3682 propid2label[121] = "timestamp" 3683 P_TIMESTAMP = 121
3684 - def _sk_get_type(self):
3685 return skypekit.enumof(Message.TYPE, self._sk_property("ZG\301\007]\011", 961, True))
3686 type = property(_sk_get_type) 3687 propid2label[961] = "type" 3688 P_TYPE = 961
3689 - def _sk_get_sending_status(self):
3690 return skypekit.enumof(Message.SENDING_STATUS, self._sk_property("ZG\302\007]\011", 962, True))
3691 sending_status = property(_sk_get_sending_status) 3692 propid2label[962] = "sending_status" 3693 P_SENDING_STATUS = 962
3694 - def _sk_get_consumption_status(self):
3695 return skypekit.enumof(Message.CONSUMPTION_STATUS, self._sk_property("ZG\310\007]\011", 968, True))
3696 consumption_status = property(_sk_get_consumption_status) 3697 propid2label[968] = "consumption_status" 3698 P_CONSUMPTION_STATUS = 968
3699 - def _sk_get_edited_by(self):
3700 """ 3701 Identity of the author that last edited this message. NULL if message has not been edited 3702 3703 """ 3704 return self._sk_property("ZG\336\001]\011", 222, True)
3705 edited_by = property(_sk_get_edited_by) 3706 propid2label[222] = "edited_by" 3707 P_EDITED_BY = 222
3708 - def _sk_get_edit_timestamp(self):
3709 """ 3710 UNIX timestamp of last edit 3711 """ 3712 return self._sk_property("ZG\337\001]\011", 223, True)
3713 edit_timestamp = property(_sk_get_edit_timestamp) 3714 propid2label[223] = "edit_timestamp" 3715 P_EDIT_TIMESTAMP = 223
3716 - def _sk_get_param_key(self):
3717 """ 3718 Message type-specific parameter. See Message::SET_METADATA_KEY for more information. 3719 3720 """ 3721 return self._sk_property("ZG\303\007]\011", 963, True)
3722 param_key = property(_sk_get_param_key) 3723 propid2label[963] = "param_key" 3724 P_PARAM_KEY = 963
3725 - def _sk_get_param_value(self):
3726 """ 3727 Message type-specific parameter 3728 3729 """ 3730 return self._sk_property("ZG\304\007]\011", 964, True)
3731 param_value = property(_sk_get_param_value) 3732 propid2label[964] = "param_value" 3733 P_PARAM_VALUE = 964
3734 - def _sk_get_body_xml(self):
3735 """ 3736 Message type-specific parameter 3737 3738 """ 3739 return self._sk_property("ZG\177]\011", 127, True)
3740 body_xml = property(_sk_get_body_xml) 3741 propid2label[127] = "body_xml" 3742 P_BODY_XML = 127
3743 - def _sk_get_identities(self):
3744 """ 3745 Message type-specific parameter. Depending of Message type, this property contains: 3746 - STARTED_LIVESESSION - list of participants in the cal; 3747 - ENDED_LIVESESSION - list of participants in the call; 3748 - POSTED_SMS - list of recipients of the message; 3749 - SPAWNED_CONFERENCE - the list of identities that were added; 3750 - ADDED_CONSUMERS - the list of identities that were added; 3751 - RETIRED_OTHERS - the skypename of the participant who was kicked; 3752 - SET_RANK - the skypename of the participant whose rank was changed; 3753 - REQUESTED_AUTH - Message::P_AUTHOR and Message::P_IDENTITIES are set to the users receiving and requesting the authorization, depending if the message was received or sent; 3754 - GRANTED_AUTH - the skypename of the user we granted authorization; 3755 - BLOCKED - the skypename of the user who was blocked; 3756 - HAS_BIRTHDAY - skypename of current logged in user. 3757 3758 """ 3759 return self._sk_property("ZG}]\011", 125, True)
3760 identities = property(_sk_get_identities) 3761 propid2label[125] = "identities" 3762 P_IDENTITIES = 125
3763 - def _sk_get_reason(self):
3764 """ 3765 Message type-specific parameter. Possible values for STARTED/ENDED_LIVESESSION (only set for dialogs): 3766 - no_answer 3767 - manual 3768 - busy 3769 - connection_dropped 3770 - no_skypeout_subscription; 3771 - insufficient_funds 3772 - internet_connection_lost 3773 - skypeout_account_blocked 3774 - pstn_could_not_connect_to_skype_proxy 3775 - pstn_invalid_number 3776 - pstn_number_forbidden 3777 - pstn_call_timed_out 3778 - pstn_busy 3779 - pstn_call_terminated 3780 - pstn_network_error 3781 - number_unavailable 3782 - pstn_call_rejected 3783 - pstn_misc_error 3784 - internal_error 3785 - unable_to_connect 3786 - connection_dropped 3787 - recording_failed 3788 - playback_error 3789 - legacy_error 3790 - blocked_by_privacy_settings 3791 - error 3792 - transfer_failed 3793 - transfer_insufficient_funds 3794 - blocked_by_us 3795 - emergency_call_denied 3796 3797 This information is now available as an enum in LEAVEREASON 3798 3799 """ 3800 return self._sk_property("ZG\306\007]\011", 966, True)
3801 reason = property(_sk_get_reason) 3802 propid2label[966] = "reason" 3803 P_REASON = 966
3804 - def _sk_get_leavereason(self):
3805 """ 3806 Leave reason for message of the RETIRED type, and STARTED/ENDED_LIVESESSION. Use for STARTED/ENDED_LIVESESSION is to provide simpler, enum based handling and deprecates the reason property (only set for dialogs) 3807 """ 3808 return skypekit.enumof(Skype.LEAVE_REASON, self._sk_property("ZG~]\011", 126, True))
3809 leavereason = property(_sk_get_leavereason) 3810 propid2label[126] = "leavereason" 3811 P_LEAVEREASON = 126
3812 - def _sk_get_participant_count(self):
3813 """ 3814 Number of people who received this message (including local user) 3815 3816 """ 3817 return self._sk_property("ZG\326\007]\011", 982, True)
3818 participant_count = property(_sk_get_participant_count) 3819 propid2label[982] = "participant_count" 3820 P_PARTICIPANT_COUNT = 982 3821
3822 - def CanEdit(self):
3823 """ 3824 For Message types having a body, determines whether that body is editable by the user. 3825 3826 3827 B{Return values:} 3828 - B{result} 3829 """ 3830 l_request = skypekit.XCallRequest("ZR\011\001", 9, 1) 3831 l_request.add_parm('O', 0, self) 3832 l_response = self.transport.xcall(l_request) 3833 l_result = l_response.get(1, False) 3834 return l_result
3835 - def Edit( 3836 self, 3837 new_text, 3838 is_xml = False, 3839 undo = False 3840 ):
3841 """ 3842 For Message types that include a body and are editable: 3843 - alters BODY_XML of the message object 3844 - sets EDITED_BY and EDIT_TIMESTAMP properties 3845 - propagates the changes to remote users. 3846 3847 3848 B{Arguments:} 3849 - B{new_text} - New value of the message BODY_XML property. 3850 3851 - B{is_xml} - Specify isXML as true if the message body is formatted as XML; omit it or specify it as false if the message body is plain text. 3852 3853 - B{undo} - Reverts the message body to the original version. newText parameter is ignored when this is set 3854 """ 3855 l_request = skypekit.XCallRequest("ZR\011\002", 9, 2) 3856 l_request.add_parm('O', 0, self) 3857 l_request.add_parm('S', 1, new_text) 3858 l_request.add_parm('b', 2, is_xml) 3859 l_request.add_parm('b', 3, undo) 3860 self.transport.xcall(l_request)
3861 - def GetContacts(self):
3862 """ 3863 For messages of type POSTED_CONTACTS, parses the body XML and formats the data as a list of Contact instances. 3864 3865 3866 B{Return values:} 3867 - B{contacts} 3868 """ 3869 l_request = skypekit.XCallRequest("ZR\011\003", 9, 3) 3870 l_request.add_parm('O', 0, self) 3871 l_response = self.transport.xcall(l_request) 3872 l_result = [module_id2classes[2](oid, self.transport) for oid in l_response.get(1, [])] 3873 return l_result
3874 - def GetTransfers(self):
3875 """ 3876 For messages of type POSTED_FILES, parses the body XML and creates a list of Transfer instances. 3877 3878 3879 B{Return values:} 3880 - B{transfers} 3881 """ 3882 l_request = skypekit.XCallRequest("ZR\011\004", 9, 4) 3883 l_request.add_parm('O', 0, self) 3884 l_response = self.transport.xcall(l_request) 3885 l_result = [module_id2classes[6](oid, self.transport) for oid in l_response.get(1, [])] 3886 return l_result
3887 - def GetVoiceMessage(self):
3888 """ 3889 For messages of type POSTED_VOICE_MESSAGE, parses the body XML and creates a Voicemail instance. 3890 3891 3892 B{Return values:} 3893 - B{voicemail} 3894 """ 3895 l_request = skypekit.XCallRequest("ZR\011\005", 9, 5) 3896 l_request.add_parm('O', 0, self) 3897 l_response = self.transport.xcall(l_request) 3898 l_result = module_id2classes[7](l_response.get(1), self.transport) 3899 return l_result
3900 - def GetSMS(self):
3901 """ 3902 For messages of type POSTED_SMS, parses the body XML and creates an SMS instances 3903 3904 3905 B{Return values:} 3906 - B{sms} 3907 """ 3908 l_request = skypekit.XCallRequest("ZR\011\006", 9, 6) 3909 l_request.add_parm('O', 0, self) 3910 l_response = self.transport.xcall(l_request) 3911 l_result = module_id2classes[12](l_response.get(1), self.transport) 3912 return l_result
3913 - def DeleteLocally(self):
3914 """ 3915 Deletes this message from the local database. These deletions do not propagate to the other Skype instances that the user may have on other computers. Nor do they affect other participants that have the same message. This method is specifically from removing Message objects from the database - not for removing Messages from conversations. To remove a Message from a conversation, use Message::Edit method to replace the existing body text with an empty string. 3916 3917 """ 3918 l_request = skypekit.XCallRequest("ZR\011\010", 9, 8) 3919 l_request.add_parm('O', 0, self) 3920 self.transport.xcall(l_request)
3921 module_id2classes[9] = Message
3922 3923 -class Video(skypekit.Object):
3924 """ 3925 This class contains basic video control functionality for live conversations with video. Basically, Video objects represent specific Participant's video state in a live Conversation. The Video class can represent both local (outgoing) and remote (incoming) video streams. Note that as of SkypeKit SDK version 3.2, this class no longer handles video rendering in the UI. Currently available SkypeKit runtimes do not support multi-party video. The API however is designed with future compatibility in mind, so the Video class is attached to Participant class rather than Conversation class. Once multi-party video will become available for SkypeKit, the logic should go like this: 3926 3927 Let there be 4-way live conversation C and participants P1, P2, P3 and P4. P1 is the local user. Remote participants P2 and P3 are capable of sending video. Remote user P4 is not capable of sending video. You would then end up with 4 video objects: V1, V2, V3 and V0. 3928 3929 - C->P1->V1-> outgoing video stream 3930 - C->P2->V2-> incoming video stream 1 3931 - C->P3->V3-> incoming video stream 2 3932 - C->P4-> no video object as participant P4 does not advertise supporting video 3933 - V0-> local webcam preview - this is not attached to any particular conversation, however the corresponding video object can be retrieved with Skype::GetPreviewVideo method. 3934 3935 As getting from a live conversation to running video streams involves three classes, it can be somewhat less than obvious. The basic state transition logic goes like this: 3936 3937 You start out with a Conversation, that suddenly becomes live 3938 3939 CONVERSATION::LOCAL_LIVESTATUS = IM_LIVE 3940 At this point you have access to participant list of that conversation. The next step will be to catch Partcipant property changes for PARTICIPANT::VIDEO_STATUS to see if any of the people in conversation have Video available. Note that you should not make assumptions on when this availability happens. Remote users may switch their video on-off as they please. 3941 3942 PARTICIPANT::VIDEO_STATUS = VIDEO_AVAILABLE 3943 If you get to VIDEO_AVAILABLE (not necessarily for all Participants), you can retrieve Video object, with Participant::GetVideo method. 3944 3945 Now you will need to handle Video::STATUS property changes. In case of successful video call, the sequence of Video::STATUS and Participant::VIDEO_STATUS changes for each Participant and Video object should look like this: 3946 3947 - Video::STATUS = AVAILABLE 3948 - Video::STATUS = STARTING 3949 - Video::STATUS = CHECKING_SUBSCRIPTION 3950 - Video::STATUS = STARTING 3951 3952 Participant::VIDEO_STATUS = VIDEO_CONNECTING 3953 - Video::STATUS = RUNNING 3954 - Participant::VIDEO_STATUS = STREAMING 3955 Both Video::STATUS == RUNNING and Participant::VIDEO_STATUS == STREAMING are indicative that the video for that particular participant is up and running, and your UI should update itself accordingly. 3956 3957 NB! Note that it is not enough to check for Video::STATUS property updates. By the time you obtain the Video object in your client, it may already it may already have progressed to a further status. You should always check the status property immediately after obtaining the Video object. 3958 3959 """ 3960 event_handlers = {} 3961 propid2label = {}
3962 - def _sk_init_(self, object_id, transport):
3963 """ actual constructor """ 3964 skypekit.Object._sk_init_(self, object_id, transport)
3965 - def __str__(self):
3966 return "Video %s" % (self.object_id, )
3967 @staticmethod
3968 - def propid(propname):
3969 """ convert a property name to the enum of the property """ 3970 return getattr(Video, "P_"+propname.upper())
3971 module_id = 11
3972 - def OnPropertyChange(self, property_name):
3973 """ notifies from a property change """ 3974 3975 pass
3976 STATUS = { 3977 0 :'NOT_AVAILABLE', 3978 1 :'AVAILABLE', 3979 2 :'STARTING', 3980 3 :'REJECTED', 3981 4 :'RUNNING', 3982 5 :'STOPPING', 3983 6 :'PAUSED', 3984 7 :'NOT_STARTED', 3985 8 :'HINT_IS_VIDEOCALL_RECEIVED', 3986 9 :'UNKNOWN', 3987 10:'RENDERING', 3988 11:'CHECKING_SUBSCRIPTION', 3989 12:'SWITCHING_DEVICE', 3990 'NOT_AVAILABLE' : 0, 3991 'AVAILABLE' : 1, 3992 'STARTING' : 2, 3993 'REJECTED' : 3, 3994 'RUNNING' : 4, 3995 'STOPPING' : 5, 3996 'PAUSED' : 6, 3997 'NOT_STARTED' : 7, 3998 'HINT_IS_VIDEOCALL_RECEIVED' : 8, 3999 'UNKNOWN' : 9, 4000 'RENDERING' :10, 4001 'CHECKING_SUBSCRIPTION' :11, 4002 'SWITCHING_DEVICE' :12 4003 } 4004 """ 4005 - NOT_AVAILABLE 4006 - AVAILABLE 4007 - STARTING 4008 - REJECTED 4009 - RUNNING 4010 - STOPPING 4011 - PAUSED 4012 - NOT_STARTED 4013 - HINT_IS_VIDEOCALL_RECEIVED 4014 - UNKNOWN 4015 - RENDERING 4016 - CHECKING_SUBSCRIPTION 4017 - SWITCHING_DEVICE 4018 """ 4019 MEDIATYPE = {1:'MEDIA_SCREENSHARING', 'MEDIA_SCREENSHARING':1, 0:'MEDIA_VIDEO', 'MEDIA_VIDEO':0} 4020 """ 4021 - MEDIA_SCREENSHARING 4022 - MEDIA_VIDEO 4023 """ 4024 VIDEO_DEVICE_CAPABILITY = {0:'VIDEOCAP_HQ_CAPABLE', 'VIDEOCAP_HQ_CAPABLE':0, 1:'VIDEOCAP_HQ_CERTIFIED', 'VIDEOCAP_HQ_CERTIFIED':1, 2:'VIDEOCAP_REQ_DRIVERUPDATE', 'VIDEOCAP_REQ_DRIVERUPDATE':2, 3:'VIDEOCAP_USB_HIGHSPEED', 'VIDEOCAP_USB_HIGHSPEED':3} 4025 """ 4026 - VIDEOCAP_HQ_CAPABLE 4027 - VIDEOCAP_HQ_CERTIFIED 4028 - VIDEOCAP_REQ_DRIVERUPDATE 4029 - VIDEOCAP_USB_HIGHSPEED 4030 """ 4031
4032 - def _sk_get_status(self):
4033 """ 4034 Video::STATUS 4035 """ 4036 return skypekit.enumof(Video.STATUS, self._sk_property("ZG\202\001]\013", 130, True))
4037 status = property(_sk_get_status) 4038 propid2label[130] = "status" 4039 P_STATUS = 130
4040 - def _sk_get_error(self):
4041 """ 4042 'errorcode errortext' 4043 """ 4044 return self._sk_property("ZG\203\001]\013", 131, True)
4045 error = property(_sk_get_error) 4046 propid2label[131] = "error" 4047 P_ERROR = 131
4048 - def _sk_get_debuginfo(self):
4049 """ 4050 space-separated string of tokens 4051 """ 4052 return self._sk_property("ZG\204\001]\013", 132, True)
4053 debuginfo = property(_sk_get_debuginfo) 4054 propid2label[132] = "debuginfo" 4055 P_DEBUGINFO = 132
4056 - def _sk_get_dimensions(self):
4057 """ 4058 This property does not currently work, always containing an empty string. For desktop video, you can get the frame dimensions from the video frame buffers API instead - the buffer struct retrieved with ipc.getFrame() or ipc.getNewFrame() has width and height fields, which you can then use in your UI. With RTP video solutions, you already have the frame sizes in your videohost code. Communicating these to the UI process is currently up to you. 4059 4060 """ 4061 return self._sk_property("ZG\205\001]\013", 133, True)
4062 dimensions = property(_sk_get_dimensions) 4063 propid2label[133] = "dimensions" 4064 P_DIMENSIONS = 133
4065 - def _sk_get_media_type(self):
4066 """ 4067 Indicates whether the video object is streaming webcam video or screensharing session, values: MEDIA_SCREENSHARING, MEDIA_VIDEO 4068 4069 """ 4070 return skypekit.enumof(Video.MEDIATYPE, self._sk_property("ZG\206\001]\013", 134, True))
4071 media_type = property(_sk_get_media_type) 4072 propid2label[134] = "media_type" 4073 P_MEDIA_TYPE = 134
4074 - def _sk_get_convo_id(self):
4075 """ 4076 conference id to be able to identify remote/local video in the same call 4077 """ 4078 return module_id2classes[18](self._sk_property("ZG\320\010]\013", 1104, True), self.transport)
4079 convo_id = property(_sk_get_convo_id) 4080 propid2label[1104] = "convo_id" 4081 P_CONVO_ID = 1104
4082 - def _sk_get_device_path(self):
4083 """ 4084 device path used by video object 4085 """ 4086 return self._sk_property("ZG\321\010]\013", 1105, True)
4087 device_path = property(_sk_get_device_path) 4088 propid2label[1105] = "device_path" 4089 P_DEVICE_PATH = 1105 4090 4091 SETUPKEY_VIDEO_DEVICE = "Lib/Video/Device" 4092 SETUPKEY_VIDEO_DEVICE_PATH = "Lib/Video/DevicePath" 4093 SETUPKEY_VIDEO_AUTOSEND = "Lib/Video/AutoSend" 4094 SETUPKEY_VIDEO_DISABLE = "*Lib/Video/Disable" 4095 SETUPKEY_VIDEO_RECVPOLICY = "Lib/Video/RecvPolicy" 4096 SETUPKEY_VIDEO_ADVERTPOLICY = "Lib/Video/AdvertPolicy"
4097 - def SetScreen( 4098 self, 4099 windowh 4100 ):
4101 """ 4102 No description available. 4103 4104 B{Arguments:} 4105 - B{windowh} 4106 """ 4107 l_request = skypekit.XCallRequest("ZR\013\001", 11, 1) 4108 l_request.add_parm('O', 0, self) 4109 l_request.add_parm('u', 1, windowh) 4110 self.transport.xcall(l_request)
4111 - def Start(self):
4112 """ 4113 This method starts either video send or video receive, depending on whether the video object is sender or receiver. In case of desktop video, the receiver side needs to instantiate a renderer object and associate it with the receiveing video (Video::SetRemoteRendererId). 4114 4115 """ 4116 l_request = skypekit.XCallRequest("ZR\013\002", 11, 2) 4117 l_request.add_parm('O', 0, self) 4118 self.transport.xcall(l_request)
4119 - def Stop(self):
4120 """ 4121 This method stops either video send or video receive, depending on whether the video object is sender or receiver. In case of desktop video, the receiver side needs to dis-associate the video object from the renderer, by calling Video::SetRemoteRendererId(0). 4122 4123 """ 4124 l_request = skypekit.XCallRequest("ZR\013\003", 11, 3) 4125 l_request.add_parm('O', 0, self) 4126 self.transport.xcall(l_request)
4127 - def SubmitCaptureRequest(self):
4128 """ 4129 No description available. 4130 4131 B{Return values:} 4132 - B{ret} 4133 - B{request_id} 4134 """ 4135 l_request = skypekit.XCallRequest("ZR\013\013", 11, 11) 4136 l_request.add_parm('O', 0, self) 4137 l_response = self.transport.xcall(l_request) 4138 l_result = (l_response.get(1, False)), 4139 l_result += (l_response.get(2, 0)), 4140 return l_result
4141 - def OnCaptureRequestCompleted( 4142 self, 4143 request_id, 4144 is_successful, 4145 image, 4146 width, 4147 height 4148 ):
4149 """ 4150 No description available. 4151 4152 B{Return values:} 4153 - B{request_id} 4154 - B{is_successful} 4155 - B{image} 4156 - B{width} 4157 - B{height} 4158 """ 4159 pass
4160 event_handlers[2] = "_sk_on_capture_request_completed"
4161 - def _sk_on_capture_request_completed(self, parms):
4162 """ internal event dispatcher for OnCaptureRequestCompleted """ 4163 l_cleanparms = (parms.get(1, 0)), 4164 l_cleanparms += (parms.get(2, False)), 4165 l_cleanparms += (parms.get(3, '')), 4166 l_cleanparms += (parms.get(4, 0)), 4167 l_cleanparms += (parms.get(5, 0)), 4168 self.OnCaptureRequestCompleted(*l_cleanparms)
4169 - def SetScreenCaptureRectangle( 4170 self, 4171 x0, 4172 y0, 4173 width, 4174 height, 4175 monitor_number = 0, 4176 window_handle = 0 4177 ):
4178 """ 4179 This method has no known effect in current version. 4180 4181 4182 B{Arguments:} 4183 - B{x0} 4184 - B{y0} 4185 - B{width} 4186 - B{height} 4187 - B{monitor_number} 4188 - B{window_handle} 4189 """ 4190 l_request = skypekit.XCallRequest("ZR\013\005", 11, 5) 4191 l_request.add_parm('O', 0, self) 4192 l_request.add_parm('i', 1, x0) 4193 l_request.add_parm('i', 2, y0) 4194 l_request.add_parm('u', 3, width) 4195 l_request.add_parm('u', 4, height) 4196 l_request.add_parm('i', 5, monitor_number) 4197 l_request.add_parm('u', 6, window_handle) 4198 self.transport.xcall(l_request)
4199 - def SetRenderRectangle( 4200 self, 4201 x0, 4202 y0, 4203 width, 4204 height 4205 ):
4206 """ 4207 No description available. 4208 4209 B{Arguments:} 4210 - B{x0} 4211 - B{y0} 4212 - B{width} 4213 - B{height} 4214 """ 4215 l_request = skypekit.XCallRequest("ZR\013\006", 11, 6) 4216 l_request.add_parm('O', 0, self) 4217 l_request.add_parm('i', 1, x0) 4218 l_request.add_parm('i', 2, y0) 4219 l_request.add_parm('u', 3, width) 4220 l_request.add_parm('u', 4, height) 4221 self.transport.xcall(l_request)
4222 - def SetRemoteRendererId( 4223 self, 4224 id 4225 ):
4226 """ 4227 No description available. 4228 4229 B{Arguments:} 4230 - B{id} 4231 """ 4232 l_request = skypekit.XCallRequest("ZR\013\016", 11, 14) 4233 l_request.add_parm('O', 0, self) 4234 l_request.add_parm('u', 1, id) 4235 self.transport.xcall(l_request)
4236 - def SelectVideoSource( 4237 self, 4238 media_type, 4239 webcam_name = "", 4240 device_path = "", 4241 update_setup = False 4242 ):
4243 """ 4244 This method has no effect in current version. 4245 4246 4247 B{Arguments:} 4248 - B{media_type} 4249 - B{webcam_name} 4250 - B{device_path} 4251 - B{update_setup} 4252 """ 4253 l_request = skypekit.XCallRequest("ZR\013\007", 11, 7) 4254 l_request.add_parm('O', 0, self) 4255 l_request.add_parm('e', 1, Video.MEDIATYPE[media_type]) 4256 l_request.add_parm('S', 2, webcam_name) 4257 l_request.add_parm('S', 3, device_path) 4258 l_request.add_parm('b', 4, update_setup) 4259 self.transport.xcall(l_request)
4260 - def GetCurrentVideoDevice(self):
4261 """ 4262 No description available. 4263 4264 B{Return values:} 4265 - B{mediatype} 4266 - B{device_name} 4267 - B{device_path} 4268 """ 4269 l_request = skypekit.XCallRequest("ZR\013\012", 11, 10) 4270 l_request.add_parm('O', 0, self) 4271 l_response = self.transport.xcall(l_request) 4272 l_result = (skypekit.enumof(Video.MEDIATYPE, l_response.get(1))), 4273 l_result += (l_response.get(2, '')), 4274 l_result += (l_response.get(3, '')), 4275 return l_result
4276 module_id2classes[11] = Video
4277 4278 -class Voicemail(skypekit.Object):
4279 """ 4280 Wrapper class that includes voicemail-specific methods and properties. In the Skype Conversation API, Voicemail is actually something of a misnomer for what would be more accurately called Voice Message. 4281 4282 The traditional Voicemail use case involves recording a voice message when an incoming call does not get answered in a pre-determined amount of time. In the Skype Conversation API, voicemail does not depend on a call going unanswered - you can post a voice message asynchronously into any dialog conversation at any time. 4283 4284 In fact, a high-level action flow directing unanswered incoming live sessions to voicemail is not something provided by the Conversation API - implementation of this use case is largely up to your UI. 4285 4286 The fact that your UI must retrieve incoming Voicemails by monitoring changes to a Conversation instance's Messages illustrates this conceptual difference between traditional voicemail and voice messages. The message type Message::POSTED_VOICE_MESSAGE indicates that a Message instance should be handled as a voice message instead of by displaying its body text in the Conversation UI. Message::GetVoiceMessage enables you to retrieve the associated Voicemail instance; Voicemail::StartPlayback enables you to listen to the message audio. 4287 4288 To put it another way, the object chain goes like this: 4289 :: 4290 Contact->Conversation->Message->Voicemail 4291 4292 4293 There are three basic types of Voicemail objects: 4294 - INCOMING - received voice messages that can be retrieved from Message objects; 4295 - OUTGOING - outbound voice messages that can be created with Conversation::StartVoiceMessage; 4296 - GREETING - voice messages that represent auto-answer greetings, either recorded by the user (CUSTOM_GREETING) or included as part of SkypeKit (DEFAULT_GREETING). This is the audio that gets played back to sender of the voice message before he can start recording his voice message. 4297 4298 Before trying to send out a voicemail, you should ensure that target Contact has the capability to receive them. Use Contact::GetCapabilityStatus to check for Contact::CAPABILITY_CAN_BE_SENT_VM. 4299 4300 Recording and Sending a Voice Message 4301 4302 The first step is to obtain a dialog Conversation with the target Contact. In that conversation, you can initiate the outgoing voice message with Conversation::StartVoiceMessage 4303 4304 Note that this call does not return an actual Voicemail object. To catch when an object gets created, you will need to check Conversation::P_ACTIVE_VM_ID property updates. 4305 4306 After invoking Conversation::StartVoiceMessage, SkypeKit instantiates a Voicemail instance for the target Contact's greeting (with type CUSTOM_GREETING or DEFAULT_GREETING). At this point, the Conversation::P_ACTIVE_VM_ID property update fires, newVM contains a reference to the greeting, and playback of the greeting for the sender starts automatically. 4307 4308 Once the greeting playback finishes, SkypeKit instantiates a second Voicemail instance for the outgoing voice message. At this point, the Conversation::P_ACTIVE_VM_ID property update fires again, newVM now contains a reference to the outgoing message, and recording starts automatically. If you want to include notification and/or error handling for whether this message was sent successfully, you should make a copy of newVM now. 4309 4310 Once the user finishes (or abandons) recording of their message, they want to either send the message or to cancel it. To send the message, use Conversation::PostVoiceMessage; to cancel the message, use Conversation::LeaveLiveSession. 4311 4312 Both of these actions results in the Conversation::P_ACTIVE_VM_ID property update firing for a third time, setting the value to NULL. However, the Voicemail object will actually continue its existence past this point. Saving a reference to the message's Voicemail object when you start recording it enables you to keep receiving Voicemail property updates. This in turn enables your UI to check whether voice message send succeeded or failed. 4313 4314 The relevant terminal state Voicemail::P_STATUS property values are: 4315 - Voicemail::CANCELLED - recording and/or sending of this message was cancelled 4316 - Voicemail::UPLOADED - message sent 4317 - Voicemail::FAILED - message could not be sent 4318 4319 Receiving and Playing Back a Voice Message 4320 4321 On the remote side, the Voicemail appears as a Message object of type Message::POSTED_VOICE_MESSAGE. The message's author property contains the Skype Name of the Voicemail originator, and its BodyXml property contains the message length and title text in following format: 4322 4323 :: 4324 <voicemail alt="Sent voicemail to people in this conversation."><message length="5" ></message></voicemail> 4325 4326 4327 Receiver side UI can then retrieve the Voicemail object from the message with Message::GetVoiceMessage and 4328 start local playback with Message::StartPlayback. 4329 4330 """ 4331 event_handlers = {} 4332 propid2label = {}
4333 - def _sk_init_(self, object_id, transport):
4334 """ actual constructor """ 4335 skypekit.Object._sk_init_(self, object_id, transport)
4336 - def __str__(self):
4337 return "Voicemail %s" % (self.object_id, )
4338 @staticmethod
4339 - def propid(propname):
4340 """ convert a property name to the enum of the property """ 4341 return getattr(Voicemail, "P_"+propname.upper())
4342 module_id = 7
4343 - def OnPropertyChange(self, property_name):
4344 """ notifies from a property change """ 4345 4346 pass
4347 TYPE = {1:'INCOMING', 'INCOMING':1, 4:'DEFAULT_GREETING', 'DEFAULT_GREETING':4, 2:'CUSTOM_GREETING', 'CUSTOM_GREETING':2, 3:'OUTGOING', 'OUTGOING':3} 4348 """ 4349 - INCOMING 4350 - DEFAULT_GREETING 4351 - CUSTOM_GREETING 4352 - OUTGOING 4353 """ 4354 STATUS = { 4355 1 :'NOTDOWNLOADED', 4356 2 :'DOWNLOADING', 4357 3 :'UNPLAYED', 4358 4 :'BUFFERING', 4359 5 :'PLAYING', 4360 6 :'PLAYED', 4361 7 :'BLANK', 4362 8 :'RECORDING', 4363 9 :'RECORDED', 4364 10:'UPLOADING', 4365 11:'UPLOADED', 4366 12:'DELETING', 4367 13:'FAILED', 4368 14:'DELETING_FAILED', 4369 15:'CHECKING', 4370 16:'CANCELLED', 4371 'NOTDOWNLOADED' : 1, 4372 'DOWNLOADING' : 2, 4373 'UNPLAYED' : 3, 4374 'BUFFERING' : 4, 4375 'PLAYING' : 5, 4376 'PLAYED' : 6, 4377 'BLANK' : 7, 4378 'RECORDING' : 8, 4379 'RECORDED' : 9, 4380 'UPLOADING' :10, 4381 'UPLOADED' :11, 4382 'DELETING' :12, 4383 'FAILED' :13, 4384 'DELETING_FAILED' :14, 4385 'CHECKING' :15, 4386 'CANCELLED' :16 4387 } 4388 """ 4389 - NOTDOWNLOADED 4390 - DOWNLOADING 4391 - UNPLAYED 4392 - BUFFERING 4393 - PLAYING 4394 - PLAYED 4395 - BLANK 4396 - RECORDING 4397 - RECORDED 4398 - UPLOADING 4399 - UPLOADED 4400 - DELETING 4401 - FAILED 4402 - DELETING_FAILED 4403 - CHECKING 4404 - CANCELLED 4405 """ 4406 FAILUREREASON = { 4407 1 :'MISC_ERROR', 4408 2 :'CONNECT_ERROR', 4409 3 :'NO_VOICEMAIL_CAPABILITY', 4410 4 :'NO_SUCH_VOICEMAIL', 4411 5 :'FILE_READ_ERROR', 4412 6 :'FILE_WRITE_ERROR', 4413 7 :'RECORDING_ERROR', 4414 8 :'PLAYBACK_ERROR', 4415 9 :'NO_PERMISSION', 4416 10:'RECEIVER_DISABLED_VOICEMAIL', 4417 11:'SENDER_NOT_AUTHORIZED', 4418 12:'SENDER_BLOCKED', 4419 'MISC_ERROR' : 1, 4420 'CONNECT_ERROR' : 2, 4421 'NO_VOICEMAIL_CAPABILITY' : 3, 4422 'NO_SUCH_VOICEMAIL' : 4, 4423 'FILE_READ_ERROR' : 5, 4424 'FILE_WRITE_ERROR' : 6, 4425 'RECORDING_ERROR' : 7, 4426 'PLAYBACK_ERROR' : 8, 4427 'NO_PERMISSION' : 9, 4428 'RECEIVER_DISABLED_VOICEMAIL' :10, 4429 'SENDER_NOT_AUTHORIZED' :11, 4430 'SENDER_BLOCKED' :12 4431 } 4432 """ 4433 - MISC_ERROR 4434 - CONNECT_ERROR 4435 - NO_VOICEMAIL_CAPABILITY 4436 - NO_SUCH_VOICEMAIL 4437 - FILE_READ_ERROR 4438 - FILE_WRITE_ERROR 4439 - RECORDING_ERROR 4440 - PLAYBACK_ERROR 4441 - NO_PERMISSION 4442 - RECEIVER_DISABLED_VOICEMAIL - receiver turned off voicemail 4443 - SENDER_NOT_AUTHORIZED - receiver has not authorized you and privacy is not set to anyone 4444 - SENDER_BLOCKED - receiver blocked sender 4445 """ 4446
4447 - def _sk_get_type(self):
4448 return skypekit.enumof(Voicemail.TYPE, self._sk_property("ZGd]\007", 100, True))
4449 type = property(_sk_get_type) 4450 propid2label[100] = "type" 4451 P_TYPE = 100
4452 - def _sk_get_partner_handle(self):
4453 """ 4454 registered username of the other party 4455 """ 4456 return self._sk_property("ZGe]\007", 101, True)
4457 partner_handle = property(_sk_get_partner_handle) 4458 propid2label[101] = "partner_handle" 4459 P_PARTNER_HANDLE = 101
4460 - def _sk_get_partner_dispname(self):
4461 """ 4462 user's display name of the other party 4463 """ 4464 return self._sk_property("ZGf]\007", 102, True)
4465 partner_dispname = property(_sk_get_partner_dispname) 4466 propid2label[102] = "partner_dispname" 4467 P_PARTNER_DISPNAME = 102
4468 - def _sk_get_status(self):
4469 return skypekit.enumof(Voicemail.STATUS, self._sk_property("ZGg]\007", 103, True))
4470 status = property(_sk_get_status) 4471 propid2label[103] = "status" 4472 P_STATUS = 103
4473 - def _sk_get_failurereason(self):
4474 return skypekit.enumof(Voicemail.FAILUREREASON, self._sk_property("ZGh]\007", 104, True))
4475 failurereason = property(_sk_get_failurereason) 4476 propid2label[104] = "failurereason" 4477 P_FAILUREREASON = 104
4478 - def _sk_get_subject(self):
4479 """ 4480 DEPRECATED: subject line 4481 """ 4482 return self._sk_property("ZGi]\007", 105, True)
4483 subject = property(_sk_get_subject) 4484 propid2label[105] = "subject" 4485 P_SUBJECT = 105
4486 - def _sk_get_timestamp(self):
4487 """ 4488 timestamp of creation 4489 """ 4490 return self._sk_property("ZGj]\007", 106, True)
4491 timestamp = property(_sk_get_timestamp) 4492 propid2label[106] = "timestamp" 4493 P_TIMESTAMP = 106
4494 - def _sk_get_duration(self):
4495 """ 4496 duration in seconds 4497 """ 4498 return self._sk_property("ZGk]\007", 107, True)
4499 duration = property(_sk_get_duration) 4500 propid2label[107] = "duration" 4501 P_DURATION = 107
4502 - def _sk_get_allowed_duration(self):
4503 """ 4504 max allowed duration in seconds 4505 """ 4506 return self._sk_property("ZGl]\007", 108, True)
4507 allowed_duration = property(_sk_get_allowed_duration) 4508 propid2label[108] = "allowed_duration" 4509 P_ALLOWED_DURATION = 108
4510 - def _sk_get_playback_progress(self):
4511 """ 4512 VM playback progress in seconds 4513 """ 4514 return self._sk_property("ZGm]\007", 109, True)
4515 playback_progress = property(_sk_get_playback_progress) 4516 propid2label[109] = "playback_progress" 4517 P_PLAYBACK_PROGRESS = 109
4518 - def _sk_get_convo_id(self):
4519 """ 4520 CONVERSATION_ID of corresponding conversation 4521 """ 4522 return module_id2classes[18](self._sk_property("ZG\276\006]\007", 830, True), self.transport)
4523 convo_id = property(_sk_get_convo_id) 4524 propid2label[830] = "convo_id" 4525 P_CONVO_ID = 830
4526 - def _sk_get_chatmsg_guid(self):
4527 """ 4528 GUID of the message that the VM is tied to 4529 """ 4530 return self._sk_property("ZG\277\006]\007", 831, True)
4531 chatmsg_guid = property(_sk_get_chatmsg_guid) 4532 propid2label[831] = "chatmsg_guid" 4533 P_CHATMSG_GUID = 831 4534
4535 - def StartRecording(self):
4536 """ 4537 Start recording your own auto-answer greeting message (leave message after the beep...) only. Recording of outgoing Voicemail messages start automatically (using Conversation::StartVoiceMessage) after playback of the remote side greeting message has finished. 4538 4539 """ 4540 l_request = skypekit.XCallRequest("ZR\007\003", 7, 3) 4541 l_request.add_parm('O', 0, self) 4542 self.transport.xcall(l_request)
4543 - def StopRecording(self):
4544 """ 4545 Stop recording of your own auto-answer greeting message only. To stop recording of and send an outgoing Voicemail, use Conversation::PostVoiceMessage. 4546 4547 """ 4548 l_request = skypekit.XCallRequest("ZR\007\004", 7, 4) 4549 l_request.add_parm('O', 0, self) 4550 self.transport.xcall(l_request)
4551 - def StartPlayback(self):
4552 """ 4553 Initiates playback of a voice message 4554 4555 """ 4556 l_request = skypekit.XCallRequest("ZR\007\005", 7, 5) 4557 l_request.add_parm('O', 0, self) 4558 self.transport.xcall(l_request)
4559 - def StopPlayback(self):
4560 """ 4561 Terminates playback of a voice message 4562 4563 """ 4564 l_request = skypekit.XCallRequest("ZR\007\006", 7, 6) 4565 l_request.add_parm('O', 0, self) 4566 self.transport.xcall(l_request)
4567 - def Delete(self):
4568 """ 4569 first from server, and then the local copy 4570 """ 4571 l_request = skypekit.XCallRequest("ZR\007\007", 7, 7) 4572 l_request.add_parm('O', 0, self) 4573 self.transport.xcall(l_request)
4574 - def Cancel(self):
4575 """ 4576 Canceling recording of your own auto-answer greeting message. To stop recording of and cancel an outgoing Voicemail, use Conversation::LeaveLiveSession. 4577 4578 """ 4579 l_request = skypekit.XCallRequest("ZR\007\010", 7, 8) 4580 l_request.add_parm('O', 0, self) 4581 self.transport.xcall(l_request)
4582 - def CheckPermission(self):
4583 """ 4584 check if we can send voicemail (unauth,blocked,no priv etc cases). only OUTGOING 4585 4586 B{Return values:} 4587 - B{result} 4588 """ 4589 l_request = skypekit.XCallRequest("ZR\007\015", 7, 13) 4590 l_request.add_parm('O', 0, self) 4591 l_response = self.transport.xcall(l_request) 4592 l_result = l_response.get(1, False) 4593 return l_result
4594 module_id2classes[7] = Voicemail
4595 4596 -class Sms(skypekit.Object):
4597 """ 4598 Wrapper class that includes SMS-specific properties and methods, such as P_BODY and GetTargetPrice. Instantiate SMS instances using Skype::CreateOutgoingSms; post SMS messages to a Conversation using Conversation::PostSMS. 4599 4600 Each SMS can have multiple targets (normalized phone numbers). Note that in a Conversation context, every SMS instance has a corresponding Message instance. Once you've posted an SMS, you can retrieve its corresponding Message instance using Sms::GetPropChatmsgId. That Message instance's P_BODY_XML property contains the SMS message data, such as price, target phone number(s), failure codes, and so forth, which you can parsed out and display in the UI. To put it another way, the object chain goes like this: 4601 4602 :: 4603 Conversation->Message->SMS 4604 4605 4606 Note that SkypeKit SDK supports outgoing SMS messages only. SkypeKit clients, even when logged in with accounts that have SkypeIn numbers, cannot receive SMS messages. 4607 4608 """ 4609 event_handlers = {} 4610 propid2label = {}
4611 - def _sk_init_(self, object_id, transport):
4612 """ actual constructor """ 4613 skypekit.Object._sk_init_(self, object_id, transport)
4614 - def __str__(self):
4615 return "Sms %s" % (self.object_id, )
4616 @staticmethod
4617 - def propid(propname):
4618 """ convert a property name to the enum of the property """ 4619 return getattr(Sms, "P_"+propname.upper())
4620 module_id = 12
4621 - def OnPropertyChange(self, property_name):
4622 """ notifies from a property change """ 4623 4624 pass
4625 TYPE = {2:'OUTGOING', 'OUTGOING':2, 3:'CONFIRMATION_CODE_REQUEST', 'CONFIRMATION_CODE_REQUEST':3, 4:'CONFIRMATION_CODE_SUBMIT', 'CONFIRMATION_CODE_SUBMIT':4} 4626 """ 4627 - OUTGOING - a normal outgoing SMS message 4628 - CONFIRMATION_CODE_REQUEST - a message requesting a SMS confirmation code be sent to the number provided 4629 - CONFIRMATION_CODE_SUBMIT - a message returning the SMS confirmation code received as a result of a CONFIRMATION_CODE_REQUEST to authorize it 4630 """ 4631 STATUS = {3:'COMPOSING', 'COMPOSING':3, 4:'SENDING_TO_SERVER', 'SENDING_TO_SERVER':4, 5:'SENT_TO_SERVER', 'SENT_TO_SERVER':5, 6:'DELIVERED', 'DELIVERED':6, 7:'SOME_TARGETS_FAILED', 'SOME_TARGETS_FAILED':7, 8:'FAILED', 'FAILED':8} 4632 """ 4633 - COMPOSING 4634 - SENDING_TO_SERVER 4635 - SENT_TO_SERVER 4636 - DELIVERED 4637 - SOME_TARGETS_FAILED 4638 - FAILED 4639 """ 4640 FAILUREREASON = { 4641 1:'MISC_ERROR', 4642 2:'SERVER_CONNECT_FAILED', 4643 3:'NO_SMS_CAPABILITY', 4644 4:'INSUFFICIENT_FUNDS', 4645 5:'INVALID_CONFIRMATION_CODE', 4646 6:'USER_BLOCKED', 4647 7:'IP_BLOCKED', 4648 8:'NODE_BLOCKED', 4649 9:'NO_SENDERID_CAPABILITY', 4650 'MISC_ERROR' :1, 4651 'SERVER_CONNECT_FAILED' :2, 4652 'NO_SMS_CAPABILITY' :3, 4653 'INSUFFICIENT_FUNDS' :4, 4654 'INVALID_CONFIRMATION_CODE' :5, 4655 'USER_BLOCKED' :6, 4656 'IP_BLOCKED' :7, 4657 'NODE_BLOCKED' :8, 4658 'NO_SENDERID_CAPABILITY' :9 4659 } 4660 """ 4661 - MISC_ERROR 4662 - SERVER_CONNECT_FAILED 4663 - NO_SMS_CAPABILITY 4664 - INSUFFICIENT_FUNDS 4665 - INVALID_CONFIRMATION_CODE 4666 - USER_BLOCKED 4667 - IP_BLOCKED 4668 - NODE_BLOCKED 4669 - NO_SENDERID_CAPABILITY 4670 """ 4671 TARGETSTATUS = {1:'TARGET_ANALYZING', 'TARGET_ANALYZING':1, 2:'TARGET_UNDEFINED', 'TARGET_UNDEFINED':2, 3:'TARGET_ACCEPTABLE', 'TARGET_ACCEPTABLE':3, 4:'TARGET_NOT_ROUTABLE', 'TARGET_NOT_ROUTABLE':4, 5:'TARGET_DELIVERY_PENDING', 'TARGET_DELIVERY_PENDING':5, 6:'TARGET_DELIVERY_SUCCESSFUL', 'TARGET_DELIVERY_SUCCESSFUL':6, 7:'TARGET_DELIVERY_FAILED', 'TARGET_DELIVERY_FAILED':7} 4672 """ 4673 - TARGET_ANALYZING 4674 - TARGET_UNDEFINED 4675 - TARGET_ACCEPTABLE 4676 - TARGET_NOT_ROUTABLE 4677 - TARGET_DELIVERY_PENDING 4678 - TARGET_DELIVERY_SUCCESSFUL 4679 - TARGET_DELIVERY_FAILED 4680 """ 4681 SETBODYRESULT = {0:'BODY_INVALID', 'BODY_INVALID':0, 1:'BODY_TRUNCATED', 'BODY_TRUNCATED':1, 2:'BODY_OK', 'BODY_OK':2, 3:'BODY_LASTCHAR_IGNORED', 'BODY_LASTCHAR_IGNORED':3} 4682 """ 4683 - BODY_INVALID - body not set. message status wrong or invalid, or body not valid utf8 string 4684 - BODY_TRUNCATED - body too long. set, but truncated. charsUntilNextChunk contains maxChunks value 4685 - BODY_OK - body was set OK 4686 - BODY_LASTCHAR_IGNORED - last unicode char was ignored, as some of the text would be deleted due to conversion 4687 """ 4688 CONFIRM_TYPE = {1:'ID_SMS', 'ID_SMS':1, 2:'ID_MOBILE', 'ID_MOBILE':2, 3:'ID_SKYPEIN', 'ID_SKYPEIN':3} 4689 """ 4690 - ID_SMS - Confirm mobile number as SMS sender number 4691 - ID_MOBILE - Confirm mobile number as CLI for SkypeOut calls 4692 - ID_SKYPEIN - unused currently 4693 """ 4694
4695 - def _sk_get_type(self):
4696 return skypekit.enumof(Sms.TYPE, self._sk_property("ZG\276\001]\014", 190, True))
4697 type = property(_sk_get_type) 4698 propid2label[190] = "type" 4699 P_TYPE = 190
4700 - def _sk_get_status(self):
4701 return skypekit.enumof(Sms.STATUS, self._sk_property("ZG\277\001]\014", 191, True))
4702 status = property(_sk_get_status) 4703 propid2label[191] = "status" 4704 P_STATUS = 191
4705 - def _sk_get_failurereason(self):
4706 """ 4707 Set asynchronously and meaningful only after invoking Conversation::PostSMS and detecting Sms::STATUS of SOME_TARGETS_FAILED or FAILED. 4708 4709 """ 4710 return skypekit.enumof(Sms.FAILUREREASON, self._sk_property("ZG\300\001]\014", 192, True))
4711 failurereason = property(_sk_get_failurereason) 4712 propid2label[192] = "failurereason" 4713 P_FAILUREREASON = 192
4714 - def _sk_get_is_failed_unseen(self):
4715 """ 4716 set to 1 when status goes to FAILED. use MarkSeen() to clear 4717 """ 4718 return self._sk_property("ZG0]\014", 48, True)
4719 is_failed_unseen = property(_sk_get_is_failed_unseen) 4720 propid2label[48] = "is_failed_unseen" 4721 P_IS_FAILED_UNSEEN = 48
4722 - def _sk_get_timestamp(self):
4723 """ 4724 unix timestamp of message submission 4725 """ 4726 return self._sk_property("ZG\306\001]\014", 198, True)
4727 timestamp = property(_sk_get_timestamp) 4728 propid2label[198] = "timestamp" 4729 P_TIMESTAMP = 198
4730 - def _sk_get_price(self):
4731 """ 4732 The total price of sending this SMS message (sum of the individual prices to send to each recipient). Defaults to -1 on instantiation and incremented by the price for each recipient once that recipient's status reflects TARGET_ACCEPTABLE. Use Sms::GetTargetPrice to retrieve individual target prices. 4733 4734 A value of MAX_UINT indicates that SkypeKit is actively querying and/or updating the value. Note that P_PRICE is an integer value. Calculate the actual price (in units specified by P_PRICE_CURRENCY) using P_PRICE_PRECISION as: 4735 4736 :: 4737 actualPrice = price / 10^pricePrecision; 4738 4739 4740 """ 4741 return self._sk_property("ZG\301\001]\014", 193, True)
4742 price = property(_sk_get_price) 4743 propid2label[193] = "price" 4744 P_PRICE = 193
4745 - def _sk_get_price_precision(self):
4746 """ 4747 The decimal precision of the SMS price values, both individual and total. For example, a value of 2 indicates that you should divide the price (represented as an integer) by 100 (10^2) to obtain the actual price. 4748 4749 """ 4750 return self._sk_property("ZG1]\014", 49, True)
4751 price_precision = property(_sk_get_price_precision) 4752 propid2label[49] = "price_precision" 4753 P_PRICE_PRECISION = 49
4754 - def _sk_get_price_currency(self):
4755 """ 4756 should be same as account currency at the time of composing/sending 4757 """ 4758 return self._sk_property("ZG\302\001]\014", 194, True)
4759 price_currency = property(_sk_get_price_currency) 4760 propid2label[194] = "price_currency" 4761 P_PRICE_CURRENCY = 194
4762 - def _sk_get_reply_to_number(self):
4763 """ 4764 number that should receive the replies 4765 """ 4766 return self._sk_property("ZG\307\001]\014", 199, True)
4767 reply_to_number = property(_sk_get_reply_to_number) 4768 propid2label[199] = "reply_to_number" 4769 P_REPLY_TO_NUMBER = 199
4770 - def _sk_get_target_numbers(self):
4771 """ 4772 space-separated normalised pstn numbers 4773 """ 4774 return self._sk_property("ZG\303\001]\014", 195, True)
4775 target_numbers = property(_sk_get_target_numbers) 4776 propid2label[195] = "target_numbers" 4777 P_TARGET_NUMBERS = 195
4778 - def _sk_get_target_statuses(self):
4779 """ 4780 binary blob. track with OnPropertyChange(), access with GetTargetStatus(target) 4781 """ 4782 return self._sk_property("ZG\304\001]\014", 196, True)
4783 target_statuses = property(_sk_get_target_statuses) 4784 propid2label[196] = "target_statuses" 4785 P_TARGET_STATUSES = 196
4786 - def _sk_get_body(self):
4787 """ 4788 actual payload 4789 """ 4790 return self._sk_property("ZG\305\001]\014", 197, True)
4791 body = property(_sk_get_body) 4792 propid2label[197] = "body" 4793 P_BODY = 197
4794 - def _sk_get_chatmsg_id(self):
4795 """ 4796 reference to Message 4797 """ 4798 return module_id2classes[9](self._sk_property("ZG\310\006]\014", 840, True), self.transport)
4799 chatmsg_id = property(_sk_get_chatmsg_id) 4800 propid2label[840] = "chatmsg_id" 4801 P_CHATMSG_ID = 840 4802
4803 - def GetTargetStatus( 4804 self, 4805 target 4806 ):
4807 """ 4808 Retrieves the send status of this SMS to a particular recipient (P_TARGET_STATUSES) either prior to or after invoking Conversation::PostSMS. 4809 4810 4811 B{Arguments:} 4812 - B{target} - The normalized phone number of the target recipient. 4813 4814 4815 B{Return values:} 4816 - B{status} - The send status of the target recipient, for example, TARGET_ANALYZING, TARGET_DELIVERY_PENDING, TARGET_DELIVERY_SUCCESSFUL, TARGET_DELIVERY_FAILED, and so forth. TARGET_UNDEFINED implies that the specified target is not a recipient of this SMS. 4817 4818 """ 4819 l_request = skypekit.XCallRequest("ZR\014\004", 12, 4) 4820 l_request.add_parm('O', 0, self) 4821 l_request.add_parm('S', 1, target) 4822 l_response = self.transport.xcall(l_request) 4823 l_result = skypekit.enumof(Sms.TARGETSTATUS, l_response.get(1)) 4824 return l_result
4825 - def GetTargetPrice( 4826 self, 4827 target 4828 ):
4829 """ 4830 Retrieves the amount of Skype credit necessary to send the SMS to a particular recipient. Defaults to -1 on instantiation and set only when that recipient's status reflects TARGET_ACCEPTABLE. Use Sms::GetPropPrice to retrieve the total cost of this SMS. 4831 4832 Note that the target price is an integer value. Calculate the actual price (in units specified by P_PRICE_CURRENCY) using P_PRICE_PRECISION as: 4833 :: 4834 actualTargetPrice = targetPrice / 10^pricePrecision; 4835 4836 4837 4838 B{Arguments:} 4839 - B{target} - The normalized phone number of the target recipient. 4840 4841 4842 B{Return values:} 4843 - B{price} - The price of sending this SMS message to the target recipient. 4844 4845 """ 4846 l_request = skypekit.XCallRequest("ZR\014\015", 12, 13) 4847 l_request.add_parm('O', 0, self) 4848 l_request.add_parm('S', 1, target) 4849 l_response = self.transport.xcall(l_request) 4850 l_result = l_response.get(1, 0) 4851 return l_result
4852 - def SetTargets( 4853 self, 4854 numbers 4855 ):
4856 """ 4857 Sets the recipient(s) of this SMS. Note that each invocation replaces the target list and re-calculates all prices - they are not additive! 4858 4859 4860 B{Arguments:} 4861 - B{numbers} - Normalized phone number(s) of the intended recipient(s). 4862 4863 4864 B{Return values:} 4865 - B{success} - Set to true if the target list appears to contain valid, normalized telephone numbers. Note that this check is not very reliable. Actual target validity checking occurs asynchronously in the background, and manifests itself as a series of Sms::P_TARGET_STATUSES property change events. 4866 4867 """ 4868 l_request = skypekit.XCallRequest("ZR\014\006", 12, 6) 4869 l_request.add_parm('O', 0, self) 4870 l_request.add_parm('S', 1, numbers) 4871 l_response = self.transport.xcall(l_request) 4872 l_result = l_response.get(1, False) 4873 return l_result
4874 - def SetBody( 4875 self, 4876 text 4877 ):
4878 """ 4879 -The- method for setting the body text of this SMS. While Conversation::PostSMS does have a body argument, that argument is currently unused. 4880 4881 4882 B{Arguments:} 4883 - B{text} - Message body text. 4884 4885 4886 B{Return values:} 4887 - B{result} - Whether the Message body was successfully set and if not, why not. 4888 4889 - B{chunks} - The Message body as a list of individual chunks. 4890 4891 - B{chars_until_next_chunk} - Number of available characters until creation of the next chunk becomes necessary. 4892 4893 """ 4894 l_request = skypekit.XCallRequest("ZR\014\007", 12, 7) 4895 l_request.add_parm('O', 0, self) 4896 l_request.add_parm('S', 1, text) 4897 l_response = self.transport.xcall(l_request) 4898 l_result = (skypekit.enumof(Sms.SETBODYRESULT, l_response.get(1))), 4899 l_result += (l_response.get(2, [])), 4900 l_result += (l_response.get(3, 0)), 4901 return l_result
4902 - def GetBodyChunks(self):
4903 """ 4904 Retrieves string list of SMS text chunks in first argument, while the second argument contains the number of available characters until creation of the next chunk becomes necessary. 4905 4906 4907 B{Return values:} 4908 - B{text_chunks} - List of text chunk strings 4909 4910 - B{chars_until_next_chunk} - Number of available characters until creation of the next chunk becomes necessary. 4911 4912 """ 4913 l_request = skypekit.XCallRequest("ZR\014\010", 12, 8) 4914 l_request.add_parm('O', 0, self) 4915 l_response = self.transport.xcall(l_request) 4916 l_result = (l_response.get(1, [])), 4917 l_result += (l_response.get(2, 0)), 4918 return l_result
4919 module_id2classes[12] = Sms
4920 4921 -class Transfer(skypekit.Object):
4922 """ 4923 Transfer in this context refers to transferring (sending/receiving) files among Skype Contacts, not transferring a call to another Skype or PSTN Contact. This class includes file transfer-specific properties and methods, such as FILESIZE, BYTESPERSECOND, Pause and Resume. Recipients of these file transfers must explicitly accept (or decline) any incoming transfer. Transfer instances represent files being sent and received within a Conversation context. Each Transfer instance represents a single file transfer - if a conversation has multiple remote participants, a separate Transfer instance must be instantiated for each remote participant (a Transfer instance is not instantiated for the sender). 4924 4925 Transfer instances cannot be instantiated directly. Instead, you initiate a file transfer by invoking Conversation::PostFiles. This instantiates a Message instance of type POSTED_FILES, which is added to the Conversation for all the participants (including the sender). The Transfer instance is associated with 4926 this Message instance, and the Message::P_BODY_XML looks like this: 4927 4928 :: 4929 Some text<files alt=""><file size="2336020" index="0">test.zip</file></files> 4930 4931 4932 To put it another way, the object chain goes like this: 4933 :: 4934 Conversation->Message->Transfer 4935 4936 4937 The first part of the message (before the files section) comes from the Conversation::PostFiles body argument. For each file in the message, a file section is provided with three fields: 4938 - file size in bytes 4939 - index - more or less arbitrary order in which the transfers should be displayed in the UI 4940 - file name. 4941 4942 For practical purposes, the Message::P_BODY_XML property is not all that useful in this context. The Transfer instances, however, contain the state and progress feedback for your UI. You retrieve these Transfer instances using Message::GetTransfers method. Since the sender can post multiple files to 4943 a Conversation using the same Message, Message:GetTransfers retrieves a list of Transfer instances - one per file per recipient. 4944 4945 You can determine the direction of particular Transfer instance by querying Transfer::P_TYPE (INCOMING/OUTGOING). 4946 4947 You can implement a progress indicator by monitoring Transfer::P_BYTESTRANSFERRED. Note that when testing this on your local network, you will most likely catch these property change events at the beginning and the end of the transfer only - which does not look like too useful. However, for non-local network transfers where the transfer speeds are in the neighborhood of 200-300 KB per second, you should consider implementing progress feedback as being mandatory and expect to catch multiple property change events for all but the smallest files. 4948 4949 Another property of interest is Transfer::P_STATUS. The normal transfer status sequence during successful outgoing transfer is this: 4950 - TRANSFER STATUS -> NEW 4951 - TRANSFER STATUS -> WAITING_FOR_ACCEPT 4952 - TRANSFER STATUS -> CONNECTING 4953 - TRANSFER STATUS -> TRANSFERRING 4954 - TRANSFER STATUS -> CONNECTING 4955 - TRANSFER STATUS -> COMPLETED 4956 4957 The list of all terminal Transfer statuses is: 4958 - COMPLETED 4959 - FAILED 4960 - CANCELLED 4961 - CANCELLED_BY_REMOTE 4962 4963 In-progress transfers can be canceled with Transfer::Cancel and paused/resumed with Transfer::Pause and Transfer::Resume. For transfers that complete with a status of FAILED, your UI should provide feedback based on the value of Transfer::P_FAILUREREASON. 4964 4965 Incoming transfers, once accepted, overwrite existing files with the same name. Before accepting an incoming file transfer, 4966 your UI should prompt the recipient to: 4967 - accept or decline the file 4968 - if accepted, specify the directory of here to save the file (with a pre-filled default) 4969 - if accepted and a file having the same name already exists at the specified destination, your UI should prompt for confirmation to overwrite and provide a way to alter the file name before accepting it 4970 4971 Similarly, your UI should verify the existence of outgoing files prior to invoking Conversation::PostFiles. 4972 4973 Note that you should provide both Conversation::PostFiles and Transfer::Accept methods fully-qualified paths. Otherwise, the paths will be assumed to be relative to the path of SkypeKit runtime, since the methods are actually executed in the runtime context. 4974 4975 """ 4976 event_handlers = {} 4977 propid2label = {}
4978 - def _sk_init_(self, object_id, transport):
4979 """ actual constructor """ 4980 skypekit.Object._sk_init_(self, object_id, transport)
4981 - def __str__(self):
4982 return "Transfer %s" % (self.object_id, )
4983 @staticmethod
4984 - def propid(propname):
4985 """ convert a property name to the enum of the property """ 4986 return getattr(Transfer, "P_"+propname.upper())
4987 module_id = 6
4988 - def OnPropertyChange(self, property_name):
4989 """ notifies from a property change """ 4990 4991 pass
4992 TYPE = {1:'INCOMING', 'INCOMING':1, 2:'OUTGOING', 'OUTGOING':2} 4993 """ 4994 - INCOMING 4995 - OUTGOING 4996 """ 4997 STATUS = { 4998 0 :'NEW', 4999 1 :'CONNECTING', 5000 2 :'WAITING_FOR_ACCEPT', 5001 3 :'TRANSFERRING', 5002 4 :'TRANSFERRING_OVER_RELAY', 5003 5 :'PAUSED', 5004 6 :'REMOTELY_PAUSED', 5005 7 :'CANCELLED', 5006 8 :'COMPLETED', 5007 9 :'FAILED', 5008 10:'PLACEHOLDER', 5009 11:'OFFER_FROM_OTHER_INSTANCE', 5010 12:'CANCELLED_BY_REMOTE', 5011 'NEW' : 0, 5012 'CONNECTING' : 1, 5013 'WAITING_FOR_ACCEPT' : 2, 5014 'TRANSFERRING' : 3, 5015 'TRANSFERRING_OVER_RELAY' : 4, 5016 'PAUSED' : 5, 5017 'REMOTELY_PAUSED' : 6, 5018 'CANCELLED' : 7, 5019 'COMPLETED' : 8, 5020 'FAILED' : 9, 5021 'PLACEHOLDER' :10, 5022 'OFFER_FROM_OTHER_INSTANCE' :11, 5023 'CANCELLED_BY_REMOTE' :12 5024 } 5025 """ 5026 Recognized values for the P_STATUS property. Reflects current state of this Transfer. 5027 5028 - NEW - The file has either not been posted (sent) (OUTGOING), or not accepted (received) (INCOMING). 5029 5030 - CONNECTING - A temporary state that transitions either into TRANSFERRING (relayed or direct) or to FAILED. For unknown reasons, outgoing transfers tend go into this state twice - immediately before the actual data transfer starts and immediately after it ends. 5031 5032 - WAITING_FOR_ACCEPT - The files have been posted but the recipient has not yet accepted (or has declined) the transfer. 5033 5034 - TRANSFERRING - The transfer has been accepted and file data is being sent/received. Periodic updates of P_BYTESTRANSFERRED property should occur. 5035 5036 - TRANSFERRING_OVER_RELAY - The transfer has been accepted and file data is being sent/received but is going over at least one relay. Since relayed transfers tend to be significantly slower than direct transfers, you might want to differentiate the two in your UI and notify the user that relayed transfer typically take significantly longer to finish. 5037 5038 - PAUSED - The local user (either the sender or a receiver) has paused the transfer. 5039 5040 - REMOTELY_PAUSED - A remote user has paused the transfer. For senders, a receiver has paused the transfer; for receivers, the sender has paused the transfer. 5041 5042 - CANCELLED - Local side (either sender or receiver) has canceled the transfer. This is a final state of the STATE property. 5043 5044 - COMPLETED - File transfer has completed. This is a terminal state. 5045 5046 - FAILED - File transfer has failed. This is a terminal state. UI should provide feedback, based on value of P_FAILUREREASON. 5047 5048 - PLACEHOLDER - Transfer whose existence has been hinted by corresponding chat message, but which is yet to arrive. 5049 5050 - OFFER_FROM_OTHER_INSTANCE - Outgoing transfer object from another instance of the same account as current local login, running on another system. Hinted through chat message - only implies an offer was made; not necessarily accepted, failed, or completed. 5051 5052 - CANCELLED_BY_REMOTE - Remote side (either sender or receiver) has canceled the transfer. This is a final state of the STATE property. 5053 5054 """ 5055 FAILUREREASON = { 5056 1 :'SENDER_NOT_AUTHORISED', 5057 2 :'REMOTELY_CANCELLED', 5058 3 :'FAILED_READ', 5059 4 :'FAILED_REMOTE_READ', 5060 5 :'FAILED_WRITE', 5061 6 :'FAILED_REMOTE_WRITE', 5062 7 :'REMOTE_DOES_NOT_SUPPORT_FT', 5063 8 :'REMOTE_OFFLINE_FOR_TOO_LONG', 5064 9 :'TOO_MANY_PARALLEL', 5065 10:'PLACEHOLDER_TIMEOUT', 5066 'SENDER_NOT_AUTHORISED' : 1, 5067 'REMOTELY_CANCELLED' : 2, 5068 'FAILED_READ' : 3, 5069 'FAILED_REMOTE_READ' : 4, 5070 'FAILED_WRITE' : 5, 5071 'FAILED_REMOTE_WRITE' : 6, 5072 'REMOTE_DOES_NOT_SUPPORT_FT' : 7, 5073 'REMOTE_OFFLINE_FOR_TOO_LONG' : 8, 5074 'TOO_MANY_PARALLEL' : 9, 5075 'PLACEHOLDER_TIMEOUT' :10 5076 } 5077 """ 5078 - SENDER_NOT_AUTHORISED 5079 - REMOTELY_CANCELLED 5080 - FAILED_READ 5081 - FAILED_REMOTE_READ 5082 - FAILED_WRITE 5083 - FAILED_REMOTE_WRITE 5084 - REMOTE_DOES_NOT_SUPPORT_FT 5085 - REMOTE_OFFLINE_FOR_TOO_LONG 5086 - TOO_MANY_PARALLEL 5087 - PLACEHOLDER_TIMEOUT 5088 """ 5089
5090 - def _sk_get_type(self):
5091 """ 5092 INCOMING / OUTGOING 5093 5094 """ 5095 return skypekit.enumof(Transfer.TYPE, self._sk_property("ZGP]\006", 80, True))
5096 type = property(_sk_get_type) 5097 propid2label[80] = "type" 5098 P_TYPE = 80
5099 - def _sk_get_partner_handle(self):
5100 """ 5101 Skype Name of the remote party of the file transfer. If a file is posted in a conversation with more than one participant, Transfer objects are created for each of them - so a transfer is always to one single remote target. 5102 5103 """ 5104 return self._sk_property("ZGQ]\006", 81, True)
5105 partner_handle = property(_sk_get_partner_handle) 5106 propid2label[81] = "partner_handle" 5107 P_PARTNER_HANDLE = 81
5108 - def _sk_get_partner_dispname(self):
5109 """ 5110 Display name of the remote participant. 5111 5112 """ 5113 return self._sk_property("ZGR]\006", 82, True)
5114 partner_dispname = property(_sk_get_partner_dispname) 5115 propid2label[82] = "partner_dispname" 5116 P_PARTNER_DISPNAME = 82
5117 - def _sk_get_status(self):
5118 """ 5119 Current state of the transfer 5120 5121 """ 5122 return skypekit.enumof(Transfer.STATUS, self._sk_property("ZGS]\006", 83, True))
5123 status = property(_sk_get_status) 5124 propid2label[83] = "status" 5125 P_STATUS = 83
5126 - def _sk_get_failurereason(self):
5127 """ 5128 Set whenever P_STATUS transitions to FAILED. 5129 5130 """ 5131 return skypekit.enumof(Transfer.FAILUREREASON, self._sk_property("ZGT]\006", 84, True))
5132 failurereason = property(_sk_get_failurereason) 5133 propid2label[84] = "failurereason" 5134 P_FAILUREREASON = 84
5135 - def _sk_get_starttime(self):
5136 """ 5137 UNIX timestamp of when this Transfer instance was instantiated, not when the transfer process actually started (was accepted from receiver side). Do not use this property when calculate the data transfer speed! Instead, monitor changes to P_BYTESPERSECOND. 5138 5139 """ 5140 return self._sk_property("ZGU]\006", 85, True)
5141 starttime = property(_sk_get_starttime) 5142 propid2label[85] = "starttime" 5143 P_STARTTIME = 85
5144 - def _sk_get_finishtime(self):
5145 """ 5146 UNIX timestamp of when this Transfer COMPLETED or FAILED. This property is never set if the receiving side (local or remote) canceled the transfer. 5147 5148 """ 5149 return self._sk_property("ZGV]\006", 86, True)
5150 finishtime = property(_sk_get_finishtime) 5151 propid2label[86] = "finishtime" 5152 P_FINISHTIME = 86
5153 - def _sk_get_filepath(self):
5154 """ 5155 The path -and- filename of the file being transfered (typically fully qualified). For the receiver, SkypeKit sets this property upon acceptance of the incoming transfer. If not fully qualified, the path is assumed to be relative to the path of the SkypeKit runtime. 5156 5157 """ 5158 return self._sk_property("ZGW]\006", 87, True)
5159 filepath = property(_sk_get_filepath) 5160 propid2label[87] = "filepath" 5161 P_FILEPATH = 87
5162 - def _sk_get_filename(self):
5163 """ 5164 The filename -only- of the file being transfered. The receiver side can use this property to pre-populate relevant UI components while prompting the user to accept the incoming transfer. 5165 5166 """ 5167 return self._sk_property("ZGX]\006", 88, True)
5168 filename = property(_sk_get_filename) 5169 propid2label[88] = "filename" 5170 P_FILENAME = 88
5171 - def _sk_get_filesize(self):
5172 """ 5173 The size of the file being transferred in bytes. Depending on the magnitude of this value, your UI might want to display the size in terms of kilobytes or even megabytes. 5174 5175 """ 5176 return self._sk_property("ZGY]\006", 89, True)
5177 filesize = property(_sk_get_filesize) 5178 propid2label[89] = "filesize" 5179 P_FILESIZE = 89
5180 - def _sk_get_bytestransferred(self):
5181 """ 5182 The number of bytes already transferred. Calculate the percentage of the file transferred so far as: 5183 :: 5184 P_BYTESTRANSFERRED / (P_FILESIZE / 100); 5185 5186 5187 Use float variables to avoid problems with files smaller than 100 bytes! 5188 5189 """ 5190 return self._sk_property("ZGZ]\006", 90, True)
5191 bytestransferred = property(_sk_get_bytestransferred) 5192 propid2label[90] = "bytestransferred" 5193 P_BYTESTRANSFERRED = 90
5194 - def _sk_get_bytespersecond(self):
5195 """ 5196 Current data transfer speed in bytes per second. Typically, your UI will want to display this value as kilobytes per second (KBps). 5197 5198 """ 5199 return self._sk_property("ZG[]\006", 91, True)
5200 bytespersecond = property(_sk_get_bytespersecond) 5201 propid2label[91] = "bytespersecond" 5202 P_BYTESPERSECOND = 91
5203 - def _sk_get_chatmsg_guid(self):
5204 """ 5205 The "global ID" of this Transfer's associated Message instance. GUIDs are shared across Skype client instances and across all users that can see this Message. 5206 5207 """ 5208 return self._sk_property("ZG\134]\006", 92, True)
5209 chatmsg_guid = property(_sk_get_chatmsg_guid) 5210 propid2label[92] = "chatmsg_guid" 5211 P_CHATMSG_GUID = 92
5212 - def _sk_get_chatmsg_index(self):
5213 """ 5214 A more or less arbitrary index for ordering multiple file transfers within the UI. 5215 5216 """ 5217 return self._sk_property("ZG]]\006", 93, True)
5218 chatmsg_index = property(_sk_get_chatmsg_index) 5219 propid2label[93] = "chatmsg_index" 5220 P_CHATMSG_INDEX = 93
5221 - def _sk_get_convo_id(self):
5222 """ 5223 The "global ID" of this Transfer's associated Conversation (as chained through its associated Message). GUIDs are shared across Skype client instances and across all users that can see this Conversation. 5224 5225 Note that currently SkypeKit sets this property for INCOMING file transfers only and returns 0 (zero) for all sending side transfers. This is a known bug. 5226 5227 """ 5228 return module_id2classes[18](self._sk_property("ZGb]\006", 98, True), self.transport)
5229 convo_id = property(_sk_get_convo_id) 5230 propid2label[98] = "convo_id" 5231 P_CONVO_ID = 98 5232
5233 - def Accept( 5234 self, 5235 filename_with_path 5236 ):
5237 """ 5238 Accepts an incoming file transfer and saves it to specified file on the local file system. If the specified file exists, SkypeKit will silently overwrite it. Your UI should prompting the user for confirmation in this case and provide a means for canceling the file transfer or specifying a different target file. 5239 5240 5241 B{Arguments:} 5242 - B{filename_with_path} - Where on the local file system to save the file being transferred. Note that you should specify the path as being fully-qualified. Otherwise, SkypeKit will be assume it to be relative to the SkypeKit runtime path, since the method is actually executed in the runtime context. 5243 5244 5245 B{Return values:} 5246 - B{success} - Set to true if the specified target file was successfully created on the local file system -and- the initial write(s) succeeded. However, the transfer itself can subsequently fail before completion due to its being canceled (either locally or remotely), network failure, local file system space/write issues, and so forth. 5247 5248 """ 5249 l_request = skypekit.XCallRequest("ZR\006\003", 6, 3) 5250 l_request.add_parm('O', 0, self) 5251 l_request.add_parm('f', 1, filename_with_path) 5252 l_response = self.transport.xcall(l_request) 5253 l_result = l_response.get(1, False) 5254 return l_result
5255 - def Pause(self):
5256 """ 5257 Temporarily pauses an in-progress incoming or outgoing file transfer. For incoming transfers, only this affects the sender and the invoking recipient only. For outgoing transfers, this affects the sender and all recipients. 5258 5259 """ 5260 l_request = skypekit.XCallRequest("ZR\006\004", 6, 4) 5261 l_request.add_parm('O', 0, self) 5262 self.transport.xcall(l_request)
5263 - def Resume(self):
5264 """ 5265 Resumes a previously paused file transfer. 5266 5267 """ 5268 l_request = skypekit.XCallRequest("ZR\006\005", 6, 5) 5269 l_request.add_parm('O', 0, self) 5270 self.transport.xcall(l_request)
5271 - def Cancel(self):
5272 """ 5273 Cancels an in-progress file transfer. Transfer::STATUS will transition to CANCELLED for incoming file transfers and to CANCELLED_BY_REMOTE for outgoing transfers. 5274 5275 """ 5276 l_request = skypekit.XCallRequest("ZR\006\006", 6, 6) 5277 l_request.add_parm('O', 0, self) 5278 self.transport.xcall(l_request)
5279 module_id2classes[6] = Transfer
5280 5281 -class Account(skypekit.Object):
5282 """ 5283 Represents a local account. Encapsulates methods for Skype account creation, login and logout as well as account profile setting properties. NB! Unlike all the other SkypeKit classes, most of the Account class properties are actually read-write. In fact, there are two sorts of Account's read-write properties: server-side properties and local properties. Different setter methods need to be used for those two kinds. 5284 5285 The subset of server-side properties consists of all the policy properties (everything with _POLICY suffix) that are all of type int and can be set with SetServersideIntProperty method. There is currently only one server-side string property - OFFLINE_CALLFORWARD which can be set with SetServersideStrProperty setter. 5286 5287 The set of writeable account profile properties (local profile) is as follows; 5288 - P_FULLNAME, 5289 - P_BIRTHDAY, 5290 - P_GENDER, 5291 - P_LANGUAGES, 5292 - P_COUNTRY, 5293 - P_PROVINCE, 5294 - P_CITY, 5295 - P_PHONE_HOME, 5296 - P_PHONE_OFFICE, 5297 - P_PHONE_MOBILE, 5298 - P_EMAILS, 5299 - P_HOMEPAGE, 5300 - P_ABOUT, 5301 - P_MOOD_TEXT, 5302 - P_TIMEZONE, 5303 - P_AVATAR_IMAGE, 5304 - P_RICH_MOOD_TEXT 5305 5306 These can be set with SetIntProperty, SetStrProperty and SetBinProperty setter methods. Note that there are special methods for changing account online status (availability) and enabling/disabling auto-login - SetAvailability and SetSavePwd. 5307 5308 Note that to set Account properties, you that Account needs to be logged in. Generally, assumption is that the first thing you do with an Account object after you retrieve it with Skype::GetAccount is login, with exception of creating a new account. 5309 5310 The Account class has no default constructor and creating an Account instance is not the same as creating a Skype account. To create a Skype account: 5311 5312 - obtain an Account instance by invoking Skype::GetAccount. This automatically sets P_SKYPENAME. 5313 - set any additional profile-related properties. Skype recommends that you minimally set the following: 5314 - their email address so that they can retrieve a lost password (P_EMAILS) 5315 - the user's full name (P_FULLNAME) 5316 - at least one phone number (P_PHONE_HOME, P_PHONE_HOME, P_PHONE_OFFICE) 5317 - invoke Account::Register to actually create the account 5318 5319 """ 5320 event_handlers = {} 5321 propid2label = {}
5322 - def _sk_init_(self, object_id, transport):
5323 """ actual constructor """ 5324 skypekit.Object._sk_init_(self, object_id, transport)
5325 - def __str__(self):
5326 return "Account %s" % (self.object_id, )
5327 @staticmethod
5328 - def propid(propname):
5329 """ convert a property name to the enum of the property """ 5330 return getattr(Account, "P_"+propname.upper())
5331 module_id = 5
5332 - def OnPropertyChange(self, property_name):
5333 """ notifies from a property change """ 5334 5335 pass
5336 STATUS = {1:'LOGGED_OUT', 'LOGGED_OUT':1, 2:'LOGGED_OUT_AND_PWD_SAVED', 'LOGGED_OUT_AND_PWD_SAVED':2, 3:'CONNECTING_TO_P2P', 'CONNECTING_TO_P2P':3, 4:'CONNECTING_TO_SERVER', 'CONNECTING_TO_SERVER':4, 5:'LOGGING_IN', 'LOGGING_IN':5, 6:'INITIALIZING', 'INITIALIZING':6, 7:'LOGGED_IN', 'LOGGED_IN':7, 8:'LOGGING_OUT', 'LOGGING_OUT':8} 5337 """ 5338 - LOGGED_OUT 5339 - LOGGED_OUT_AND_PWD_SAVED - the account is logged out, but password is not needed for re-login 5340 - CONNECTING_TO_P2P - connecting to P2P network 5341 - CONNECTING_TO_SERVER - connecting to login server 5342 - LOGGING_IN - waiting for response from server 5343 - INITIALIZING - response OK. initialising account-specific lib structures 5344 - LOGGED_IN - alright, we're good to go! 5345 - LOGGING_OUT - Logout() has been called but not processed yet 5346 """ 5347 CBLSYNCSTATUS = {0:'CBL_INITIALIZING', 'CBL_INITIALIZING':0, 1:'CBL_INITIAL_SYNC_PENDING', 'CBL_INITIAL_SYNC_PENDING':1, 2:'CBL_SYNC_PENDING', 'CBL_SYNC_PENDING':2, 3:'CBL_SYNC_IN_PROGRESS', 'CBL_SYNC_IN_PROGRESS':3, 4:'CBL_IN_SYNC', 'CBL_IN_SYNC':4, 5:'CBL_SYNC_FAILED', 'CBL_SYNC_FAILED':5, 6:'CBL_REMOTE_SYNC_PENDING', 'CBL_REMOTE_SYNC_PENDING':6} 5348 """ 5349 Recognized values for the P_CBLSYNCSTATUS property. CBL stands for Central Buddy List. In principle, this property and its states can be ignored by most UI developers. However, it can help to optimize UI buildup and behaviour, particularly in case of limited resources (such as mobile devices). 5350 5351 CBL is used to backup your contact list, contact groups, and profile information, and also used to synchronize this information with other Skype instances of your account (i.e. on another device). CBL sync can occur both during login and during normal operation. Note that CBL synchronization does not take place immediately after an Account property is changed. A delay between the first property change and CBL sync initiation enables the client to accumulate changes and do the synchronization in bulk. 5352 5353 Clients with limited resources might want to wait for CBL_IN_SYNC status before generating their UI's contact list representation. Otherwise it might be forced to redraw the contact list multiple times, as new updates get retrieved from the server-side. Similarly, applications that modify an account's mood message might want to know when the P_MOOD_TEXT or P_RICH_MOOD_TEXT property is synchronized to the server. Note that this sync is only for CBL and other logged in instances of the same account - other contacts will receive the mood message update directly. 5354 5355 - CBL_INITIALIZING - status is not clear (yet) 5356 - CBL_INITIAL_SYNC_PENDING - first sync with empty profile 5357 - CBL_SYNC_PENDING - Account properties are considered to be out of sync with CBL - attempt at synchronization is imminent. You might wish to wait with updating UI components that display the data that is about to change anyway. 5358 - CBL_SYNC_IN_PROGRESS - CBL synchronization is currently taking place. 5359 - CBL_IN_SYNC - Account properties are up-to-date. 5360 - CBL_SYNC_FAILED - CBL sync has. Another attempt will be made after several minutes. If a second attempt also fails, subsequent attempts at synchronization will be made at ever increasing intervals. 5361 - CBL_REMOTE_SYNC_PENDING - we have received a hint that there is a remote data change in CBL 5362 """ 5363 LOGOUTREASON = { 5364 1 :'LOGOUT_CALLED', 5365 2 :'HTTPS_PROXY_AUTH_FAILED', 5366 3 :'SOCKS_PROXY_AUTH_FAILED', 5367 4 :'P2P_CONNECT_FAILED', 5368 5 :'SERVER_CONNECT_FAILED', 5369 6 :'SERVER_OVERLOADED', 5370 7 :'DB_IN_USE', 5371 8 :'INVALID_SKYPENAME', 5372 9 :'INVALID_EMAIL', 5373 10:'UNACCEPTABLE_PASSWORD', 5374 11:'SKYPENAME_TAKEN', 5375 12:'REJECTED_AS_UNDERAGE', 5376 13:'NO_SUCH_IDENTITY', 5377 14:'INCORRECT_PASSWORD', 5378 15:'TOO_MANY_LOGIN_ATTEMPTS', 5379 16:'PASSWORD_HAS_CHANGED', 5380 17:'PERIODIC_UIC_UPDATE_FAILED', 5381 18:'DB_DISK_FULL', 5382 19:'DB_IO_ERROR', 5383 20:'DB_CORRUPT', 5384 21:'DB_FAILURE', 5385 22:'INVALID_APP_ID', 5386 23:'APP_ID_FAILURE', 5387 24:'UNSUPPORTED_VERSION', 5388 'LOGOUT_CALLED' : 1, 5389 'HTTPS_PROXY_AUTH_FAILED' : 2, 5390 'SOCKS_PROXY_AUTH_FAILED' : 3, 5391 'P2P_CONNECT_FAILED' : 4, 5392 'SERVER_CONNECT_FAILED' : 5, 5393 'SERVER_OVERLOADED' : 6, 5394 'DB_IN_USE' : 7, 5395 'INVALID_SKYPENAME' : 8, 5396 'INVALID_EMAIL' : 9, 5397 'UNACCEPTABLE_PASSWORD' :10, 5398 'SKYPENAME_TAKEN' :11, 5399 'REJECTED_AS_UNDERAGE' :12, 5400 'NO_SUCH_IDENTITY' :13, 5401 'INCORRECT_PASSWORD' :14, 5402 'TOO_MANY_LOGIN_ATTEMPTS' :15, 5403 'PASSWORD_HAS_CHANGED' :16, 5404 'PERIODIC_UIC_UPDATE_FAILED' :17, 5405 'DB_DISK_FULL' :18, 5406 'DB_IO_ERROR' :19, 5407 'DB_CORRUPT' :20, 5408 'DB_FAILURE' :21, 5409 'INVALID_APP_ID' :22, 5410 'APP_ID_FAILURE' :23, 5411 'UNSUPPORTED_VERSION' :24 5412 } 5413 """ 5414 Recognized values for the Account::P_LOGOUTREASON. Note that this property should only be examined when Account::P_STATUS is LOGGED_OUT or LOGGED_OUT_AND_PWD_SAVED. That is, you should not monitor changes to this property in Account::OnChange callback, other than after already having checked that P_STATUS property has appropriate value. The reason for this is that the LOGOUTREASON does not get reset before the next login attempt. For example: if a user tried to log in with a wrong password, the LOGOUTREASON gets set to INCORRECT_PASSWORD. Now, if the user tries to log in again, and yet again submits an incorrect password, the value of the LOGOUTREASON does not change anymore, because it already is set to INCORRECT_PASSWORD. Consequently, Account::OnChange will not fire in this case. 5415 5416 - LOGOUT_CALLED - manual logout (or unknown reason from previous session) 5417 - HTTPS_PROXY_AUTH_FAILED - sync errors at login/registration 5418 - SOCKS_PROXY_AUTH_FAILED - sync errors at login/registration 5419 - P2P_CONNECT_FAILED - sync errors at login/registration 5420 - SERVER_CONNECT_FAILED - sync errors at login/registration 5421 - SERVER_OVERLOADED - sync errors at login/registration 5422 - DB_IN_USE - sync errors at login/registration 5423 - INVALID_SKYPENAME - sync errors at registration 5424 - INVALID_EMAIL - sync errors at registration 5425 - UNACCEPTABLE_PASSWORD - sync errors at registration 5426 - SKYPENAME_TAKEN - sync errors at registration 5427 - REJECTED_AS_UNDERAGE - sync errors at registration 5428 - NO_SUCH_IDENTITY - sync errors at login 5429 - INCORRECT_PASSWORD - sync errors at login 5430 - TOO_MANY_LOGIN_ATTEMPTS - sync errors at login 5431 - PASSWORD_HAS_CHANGED - async errors (can happen anytime while logged in) 5432 - PERIODIC_UIC_UPDATE_FAILED - async errors (can happen anytime while logged in) 5433 - DB_DISK_FULL - async errors (can happen anytime while logged in) 5434 - DB_IO_ERROR - async errors (can happen anytime while logged in) 5435 - DB_CORRUPT - async errors (can happen anytime while logged in) 5436 - DB_FAILURE - deprecated (superceded by more detailed DB_* errors) 5437 - INVALID_APP_ID - platform sdk 5438 - APP_ID_FAILURE - platform sdk 5439 - UNSUPPORTED_VERSION - forced upgrade/discontinuation 5440 """ 5441 PWDCHANGESTATUS = {0:'PWD_OK', 'PWD_OK':0, 1:'PWD_CHANGING', 'PWD_CHANGING':1, 2:'PWD_INVALID_OLD_PASSWORD', 'PWD_INVALID_OLD_PASSWORD':2, 3:'PWD_SERVER_CONNECT_FAILED', 'PWD_SERVER_CONNECT_FAILED':3, 4:'PWD_OK_BUT_CHANGE_SUGGESTED', 'PWD_OK_BUT_CHANGE_SUGGESTED':4, 5:'PWD_MUST_DIFFER_FROM_OLD', 'PWD_MUST_DIFFER_FROM_OLD':5, 6:'PWD_INVALID_NEW_PWD', 'PWD_INVALID_NEW_PWD':6, 7:'PWD_MUST_LOG_IN_TO_CHANGE', 'PWD_MUST_LOG_IN_TO_CHANGE':7} 5442 """ 5443 Recognized values for the P_PWDCHANGESTATUS property that provides information on whether a password change succeeded or failed, giving detailed failure reason. After successful return from the Change Password method, clients should monitor the P_PWDCHANGESTATUS property changes. 5444 - PWD_CHANGING - consider displaying an "in progress" indicator and continue polling 5445 - PWD_OK - consider displaying an updated indicator and stop polling 5446 - PWD_OK_BUT_CHANGE_SUGGESTED - consider displaying an updated indicator, along with a recommendation to change again to a stronger password. 5447 5448 - PWD_OK - Password change succeeded. 5449 5450 - PWD_CHANGING - Password change is in progress. 5451 5452 - PWD_INVALID_OLD_PASSWORD - Old password was incorrect. 5453 5454 - PWD_SERVER_CONNECT_FAILED - Failed to verify password because of no connection to server. 5455 5456 - PWD_OK_BUT_CHANGE_SUGGESTED - Password was set but server didn't like it much. 5457 5458 - PWD_MUST_DIFFER_FROM_OLD - New password was exactly the same as old one. 5459 5460 - PWD_INVALID_NEW_PWD - The new password was unacceptable. (too short, too simple, etc.) 5461 5462 - PWD_MUST_LOG_IN_TO_CHANGE - Account was currently not logged in. 5463 5464 """ 5465 COMMITSTATUS = {1:'COMMITTED', 'COMMITTED':1, 2:'COMMITTING_TO_SERVER', 'COMMITTING_TO_SERVER':2, 3:'COMMIT_FAILED', 'COMMIT_FAILED':3} 5466 """ 5467 The list of possible values of Account class COMMITSTATUS property. Note that this property and its values have nothing to do with (automatic) CBL synchronization. Rather, the COMMITSTATUS reflects commit status to account's server side properties initiated with calls to Account class SetServersideIntProperty and Account class SetServersideStrProperty methods. After those methods, your client UI may want to wait until the COMMITSTATUS becomes COMMITTING_TO_SERVER followed by COMMITTED and inform the user if the value becomes COMMIT_FAILED. SetServerside<type>Property methods are used for writing privacy policy related and call forwarding related Account properties to the server. Unlike CBL synchronization, those updates are executed immediately. 5468 5469 - COMMITTED - No pending updates to the server. 5470 5471 - COMMITTING_TO_SERVER - Update to the server in progress. 5472 5473 - COMMIT_FAILED - Server update has failed. 5474 5475 """ 5476 CHATPOLICY = {0:'EVERYONE_CAN_ADD', 'EVERYONE_CAN_ADD':0, 2:'BUDDIES_OR_AUTHORIZED_CAN_ADD', 'BUDDIES_OR_AUTHORIZED_CAN_ADD':2} 5477 """ 5478 Recognized values for the P_CHAT_POLICY property that controls whether non-authorized users can initiate text chat with the currently logged in account. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntProperty 5479 5480 - EVERYONE_CAN_ADD - Unauthorized contacts can initiate text chat. 5481 5482 - BUDDIES_OR_AUTHORIZED_CAN_ADD - Only authorized contacts can initiate chat (default policy). 5483 5484 """ 5485 SKYPECALLPOLICY = {0:'EVERYONE_CAN_CALL', 'EVERYONE_CAN_CALL':0, 2:'BUDDIES_OR_AUTHORIZED_CAN_CALL', 'BUDDIES_OR_AUTHORIZED_CAN_CALL':2} 5486 """ 5487 Recognized values for the P_SKYPECALLPOLICY property that controls acceptance of incoming Skype calls. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntPropertyserver-side. 5488 5489 - EVERYONE_CAN_CALL - Skype calls accepted from unauthorized contacts. 5490 - BUDDIES_OR_AUTHORIZED_CAN_CALL - Skype calls not accepted from unauthorized contacts. 5491 """ 5492 PSTNCALLPOLICY = {0:'ALL_NUMBERS_CAN_CALL', 'ALL_NUMBERS_CAN_CALL':0, 1:'DISCLOSED_NUMBERS_CAN_CALL', 'DISCLOSED_NUMBERS_CAN_CALL':1, 2:'BUDDY_NUMBERS_CAN_CALL', 'BUDDY_NUMBERS_CAN_CALL':2} 5493 """ 5494 Recognized values for the P_PSTNCALLPOLICY property that controls whether (and from whom) this account accepts incoming PSTN calls. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntProperty 5495 5496 - ALL_NUMBERS_CAN_CALL - All incoming PSTN calls are accepted. 5497 - DISCLOSED_NUMBERS_CAN_CALL - Only PSTN calls that report caller ID are accepted. 5498 - BUDDY_NUMBERS_CAN_CALL - Only calls from PSTN numbers found in local contact list are accepted. 5499 """ 5500 AVATARPOLICY = {0:'BUDDIES_OR_AUTHORIZED_CAN_SEE', 'BUDDIES_OR_AUTHORIZED_CAN_SEE':0, 2:'EVERYONE_CAN_SEE', 'EVERYONE_CAN_SEE':2} 5501 """ 5502 Recognized values for the P_AVATAR_POLICY property that controls whether remote contacts can view local account's avatar image. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntPropertyserver-side. 5503 Note that setting account's AVATAR_POLICY to BUDDIES_OR_AUTHORIZED_CAN_SEE does not guarantee that remote users will be able to immediately retrieve the avatar picture via corresponding Contact object. Avatar changes propagate between clients only when direct sessions between clients are established. Direct sessions are established during live sessions or whilst online contacts are engaged in chat. 5504 5505 - BUDDIES_OR_AUTHORIZED_CAN_SEE - Only authorized remote users can see this user's avatar image 5506 - EVERYONE_CAN_SEE - Everyone can see this user's avatar image, once the contact/account avatar property has been synchronized during a direct session. The avatar image may also become viewable on some Skype Web-based services. 5507 """ 5508 BUDDYCOUNTPOLICY = {0:'DISCLOSE_TO_AUTHORIZED', 'DISCLOSE_TO_AUTHORIZED':0, 1:'DISCLOSE_TO_NOONE', 'DISCLOSE_TO_NOONE':1} 5509 """ 5510 Recognized values for the P_BUDDYCOUNT_POLICY property that controls whether the number of this user's authorized contacts is visible to other users, either through Account::GetPropNrofAuthedBuddies or Contact::GetPropNrofAuthedBuddies when those instances reference this user. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntProperty, like this: 5511 account->SetServersideIntProperty(Account::P_BUDDYCOUNT_POLICY, Account::DISCLOSE_TO_AUTHORIZED); 5512 account->SetServersideIntProperty(Account::P_BUDDYCOUNT_POLICY, Account::DISCLOSE_TO_NOONE ); 5513 5514 - DISCLOSE_TO_AUTHORIZED - Authorized remote users can retrieve the number of this user's authorized contacts (Contact::P_NROF_AUTHED_BUDDIES) 5515 - DISCLOSE_TO_NOONE - No remote user - regardless their authorization status - can retrieve the number of this user's authorized contacts. Account::GetPropNrofAuthedBuddies and Contact::GetPropNrofAuthedBuddies will always return 0 5516 """ 5517 TIMEZONEPOLICY = {0:'TZ_AUTOMATIC', 'TZ_AUTOMATIC':0, 1:'TZ_MANUAL', 'TZ_MANUAL':1, 2:'TZ_UNDISCLOSED', 'TZ_UNDISCLOSED':2} 5518 """ 5519 Recognized values for the P_TIMEZONEPOLICY property that sets the rules for timezone offset so remote clients can determine your local time. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntPropertyserver-side. 5520 - TZ_AUTOMATIC - Account's timezone setting is determined automatically. 5521 5522 - TZ_MANUAL - Account's timezone setting is set manually. 5523 5524 - TZ_UNDISCLOSED - Remote users will have no idea what your local time is. 5525 5526 """ 5527 WEBPRESENCEPOLICY = {0:'WEBPRESENCE_DISABLED', 'WEBPRESENCE_DISABLED':0, 1:'WEBPRESENCE_ENABLED', 'WEBPRESENCE_ENABLED':1} 5528 """ 5529 Recognized values for the P_WEBPRESENCEPOLICY property that controls whether your online status (presence) can be seen using the "Skype buttons" ( http://www.skype.com/share/buttons/ ) embedded in web pages. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntPropertyserver-side. 5530 5531 - WEBPRESENCE_DISABLED - Disable displaying online status on web for this account. 5532 - WEBPRESENCE_ENABLED - Enable displaying online status on web for this account. 5533 """ 5534 PHONENUMBERSPOLICY = {0:'PHONENUMBERS_VISIBLE_FOR_BUDDIES', 'PHONENUMBERS_VISIBLE_FOR_BUDDIES':0, 1:'PHONENUMBERS_VISIBLE_FOR_EVERYONE', 'PHONENUMBERS_VISIBLE_FOR_EVERYONE':1} 5535 """ 5536 Recognized values for the P_PHONENUMBERSPOLICY property that controls whether unauthorized remote users can see associated phone numbers in their UI (for reference, see the different phone number tabs in Windows desktop Client contact view). Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntProperty 5537 5538 - PHONENUMBERS_VISIBLE_FOR_BUDDIES - Only authorized contacts can see the phone numbers. 5539 - PHONENUMBERS_VISIBLE_FOR_EVERYONE - Everyone can see the phone numbers. 5540 """ 5541 VOICEMAILPOLICY = {0:'VOICEMAIL_ENABLED', 'VOICEMAIL_ENABLED':0, 1:'VOICEMAIL_DISABLED', 'VOICEMAIL_DISABLED':1} 5542 """ 5543 Recognized values for the P_VOICEMAILPOLICY property that controls acceptance of incoming voicemail messages. Note that since this set of values is associated with a server-side property, you must set that property using Account::SetServersideIntPropertyserver-side. 5544 5545 - VOICEMAIL_ENABLED - Incoming voicemails enabled. 5546 - VOICEMAIL_DISABLED - Incoming voicemails disabled. 5547 """ 5548 CAPABILITYSTATUS = {0:'NO_CAPABILITY', 'NO_CAPABILITY':0, 1:'CAPABILITY_EXISTS', 'CAPABILITY_EXISTS':1, 2:'FIRST_EXPIRY_WARNING', 'FIRST_EXPIRY_WARNING':2, 3:'SECOND_EXPIRY_WARNING', 'SECOND_EXPIRY_WARNING':3, 4:'FINAL_EXPIRY_WARNING', 'FINAL_EXPIRY_WARNING':4} 5549 """ 5550 Account capabability statuses are possible values of Contact class CAPABILITY enumerator, when that enumerator is used in context of account. Compared to Contact class CAPABILITYSTATUS enums, Account class CAPABILITYSTATUS has additional items for subscription expiration warnings. 5551 5552 - NO_CAPABILITY - Capability is not supported by the currently logged in SkypeKit client. 5553 - CAPABILITY_EXISTS - Capability is supported by the currently logged in SkypeKit client. 5554 5555 - FIRST_EXPIRY_WARNING - Support for this capability ends this month (within 30 days) 5556 5557 - SECOND_EXPIRY_WARNING - Support for this capability ends this week (within 7 days) 5558 5559 - FINAL_EXPIRY_WARNING - Support for this capability ends today 5560 5561 """ 5562
5563 - def _sk_get_status(self):
5564 """ 5565 Account::STATUS 5566 """ 5567 return skypekit.enumof(Account.STATUS, self._sk_property("ZGF]\005", 70, True))
5568 status = property(_sk_get_status) 5569 propid2label[70] = "status" 5570 P_STATUS = 70
5571 - def _sk_get_pwdchangestatus(self):
5572 """ 5573 Account::PWDCHANGESTATUS 5574 """ 5575 return skypekit.enumof(Account.PWDCHANGESTATUS, self._sk_property("ZGG]\005", 71, True))
5576 pwdchangestatus = property(_sk_get_pwdchangestatus) 5577 propid2label[71] = "pwdchangestatus" 5578 P_PWDCHANGESTATUS = 71
5579 - def _sk_get_logoutreason(self):
5580 """ 5581 This property should only be examined when Account::P_STATUS is LOGGED_OUT or LOGGED_OUT_AND_PWD_SAVED. That is, you should not monitor changes to this property in Account::OnChange callback, other than after already having checked that P_STATUS property has appropriate value. The reason for this is that the LOGOUTREASON does not get reset before the next login attempt. For example: if a user tried to log in with a wrong password, the LOGOUTREASON gets set to INCORRECT_PASSWORD. Now, if the user tries to log in again, and yet again submits an incorrect password, the value of the LOGOUTREASON does not change anymore, because it already is set to INCORRECT_PASSWORD. Consequently, Account::OnChange will not fire in this case. 5582 5583 """ 5584 return skypekit.enumof(Account.LOGOUTREASON, self._sk_property("ZGI]\005", 73, True))
5585 logoutreason = property(_sk_get_logoutreason) 5586 propid2label[73] = "logoutreason" 5587 P_LOGOUTREASON = 73
5588 - def _sk_get_commitstatus(self):
5589 """ 5590 Account::COMMITSTATUS 5591 """ 5592 return skypekit.enumof(Account.COMMITSTATUS, self._sk_property("ZGN]\005", 78, True))
5593 commitstatus = property(_sk_get_commitstatus) 5594 propid2label[78] = "commitstatus" 5595 P_COMMITSTATUS = 78
5597 """ 5598 suggested skypenames, semi-colon separated. present if logoutreason==SKYPENAME_TAKEN 5599 """ 5600 return self._sk_property("ZGH]\005", 72, True)
5601 suggested_skypename = property(_sk_get_suggested_skypename) 5602 propid2label[72] = "suggested_skypename" 5603 P_SUGGESTED_SKYPENAME = 72
5605 """ 5606 'EUR', 'USD', etc. 5607 """ 5608 return self._sk_property("ZGJ]\005", 74, True)
5609 skypeout_balance_currency = property(_sk_get_skypeout_balance_currency) 5610 propid2label[74] = "skypeout_balance_currency" 5611 P_SKYPEOUT_BALANCE_CURRENCY = 74
5612 - def _sk_get_skypeout_balance(self):
5613 """ 5614 balance in 'cents' 5615 """ 5616 return self._sk_property("ZGK]\005", 75, True)
5617 skypeout_balance = property(_sk_get_skypeout_balance) 5618 propid2label[75] = "skypeout_balance" 5619 P_SKYPEOUT_BALANCE = 75
5620 - def _sk_get_skypeout_precision(self):
5621 """ 5622 decimal points in ACCOUNT_SKYPEOUT_BALANCE 5623 """ 5624 return self._sk_property("ZG\244\006]\005", 804, True)
5625 skypeout_precision = property(_sk_get_skypeout_precision) 5626 propid2label[804] = "skypeout_precision" 5627 P_SKYPEOUT_PRECISION = 804
5628 - def _sk_get_skypein_numbers(self):
5629 """ 5630 space-separated list of skypein numbers 5631 """ 5632 return self._sk_property("ZGL]\005", 76, True)
5633 skypein_numbers = property(_sk_get_skypein_numbers) 5634 propid2label[76] = "skypein_numbers" 5635 P_SKYPEIN_NUMBERS = 76
5636 - def _sk_get_cblsyncstatus(self):
5637 """ 5638 Account::CBLSYNCSTATUS 5639 """ 5640 return skypekit.enumof(Account.CBLSYNCSTATUS, self._sk_property("ZGO]\005", 79, True))
5641 cblsyncstatus = property(_sk_get_cblsyncstatus) 5642 propid2label[79] = "cblsyncstatus" 5643 P_CBLSYNCSTATUS = 79
5645 """ 5646 space-separated list of 'begSecond,endSecond,identity' tokens 5647 """ 5648 return self._sk_property("ZGM]\005", 77, True)
5649 offline_callforward = property(_sk_get_offline_callforward) 5650 propid2label[77] = "offline_callforward" 5651 P_OFFLINE_CALLFORWARD = 77
5652 - def _sk_get_chat_policy(self):
5653 """ 5654 Server-side account property, use SetServerside*Property() to set 5655 """ 5656 return skypekit.enumof(Account.CHATPOLICY, self._sk_property("ZG\240\001]\005", 160, True))
5657 chat_policy = property(_sk_get_chat_policy) 5658 propid2label[160] = "chat_policy" 5659 P_CHAT_POLICY = 160
5660 - def _sk_get_skype_call_policy(self):
5661 """ 5662 Server-side account property, use SetServerside*Property() to set 5663 """ 5664 return skypekit.enumof(Account.SKYPECALLPOLICY, self._sk_property("ZG\241\001]\005", 161, True))
5665 skype_call_policy = property(_sk_get_skype_call_policy) 5666 propid2label[161] = "skype_call_policy" 5667 P_SKYPE_CALL_POLICY = 161
5668 - def _sk_get_pstn_call_policy(self):
5669 """ 5670 Server-side account property, use SetServerside*Property() to set 5671 """ 5672 return skypekit.enumof(Account.PSTNCALLPOLICY, self._sk_property("ZG\242\001]\005", 162, True))
5673 pstn_call_policy = property(_sk_get_pstn_call_policy) 5674 propid2label[162] = "pstn_call_policy" 5675 P_PSTN_CALL_POLICY = 162
5676 - def _sk_get_avatar_policy(self):
5677 """ 5678 Server-side account property, use SetServerside*Property() to set 5679 """ 5680 return skypekit.enumof(Account.AVATARPOLICY, self._sk_property("ZG\243\001]\005", 163, True))
5681 avatar_policy = property(_sk_get_avatar_policy) 5682 propid2label[163] = "avatar_policy" 5683 P_AVATAR_POLICY = 163
5684 - def _sk_get_buddycount_policy(self):
5685 """ 5686 Server-side account property, use SetServerside*Property() to set 5687 """ 5688 return skypekit.enumof(Account.BUDDYCOUNTPOLICY, self._sk_property("ZG\244\001]\005", 164, True))
5689 buddycount_policy = property(_sk_get_buddycount_policy) 5690 propid2label[164] = "buddycount_policy" 5691 P_BUDDYCOUNT_POLICY = 164
5692 - def _sk_get_timezone_policy(self):
5693 """ 5694 Server-side account property, use SetServerside*Property() to set 5695 """ 5696 return skypekit.enumof(Account.TIMEZONEPOLICY, self._sk_property("ZG\245\001]\005", 165, True))
5697 timezone_policy = property(_sk_get_timezone_policy) 5698 propid2label[165] = "timezone_policy" 5699 P_TIMEZONE_POLICY = 165
5700 - def _sk_get_webpresence_policy(self):
5701 """ 5702 Server-side account property, use SetServerside*Property() to set 5703 """ 5704 return skypekit.enumof(Account.WEBPRESENCEPOLICY, self._sk_property("ZG\246\001]\005", 166, True))
5705 webpresence_policy = property(_sk_get_webpresence_policy) 5706 propid2label[166] = "webpresence_policy" 5707 P_WEBPRESENCE_POLICY = 166
5709 """ 5710 Server-side account property, use SetServerside*Property() to set 5711 """ 5712 return skypekit.enumof(Account.PHONENUMBERSPOLICY, self._sk_property("ZG\250\001]\005", 168, True))
5713 phonenumbers_policy = property(_sk_get_phonenumbers_policy) 5714 propid2label[168] = "phonenumbers_policy" 5715 P_PHONENUMBERS_POLICY = 168
5716 - def _sk_get_voicemail_policy(self):
5717 """ 5718 Server-side account property, use SetServerside*Property() to set 5719 """ 5720 return skypekit.enumof(Account.VOICEMAILPOLICY, self._sk_property("ZG\251\001]\005", 169, True))
5721 voicemail_policy = property(_sk_get_voicemail_policy) 5722 propid2label[169] = "voicemail_policy" 5723 P_VOICEMAIL_POLICY = 169
5724 - def _sk_get_partner_optedout(self):
5725 """ 5726 Alerts: opted out partner id's, space separated 5727 """ 5728 return self._sk_property("ZG\205\006]\005", 773, True)
5729 partner_optedout = property(_sk_get_partner_optedout) 5730 propid2label[773] = "partner_optedout" 5731 P_PARTNER_OPTEDOUT = 773
5733 """ 5734 service information if the user is a paid service provider 5735 """ 5736 return self._sk_property("ZG\240\006]\005", 800, True)
5737 service_provider_info = property(_sk_get_service_provider_info) 5738 propid2label[800] = "service_provider_info" 5739 P_SERVICE_PROVIDER_INFO = 800
5741 """ 5742 NB! Unlike your common UNIX timestamps, the registration_timestamp is special, as it counts MINUTES rather than seconds, from Epoch (January 1, 1970) 5743 5744 """ 5745 return self._sk_property("ZG\241\006]\005", 801, True)
5746 registration_timestamp = property(_sk_get_registration_timestamp) 5747 propid2label[801] = "registration_timestamp" 5748 P_REGISTRATION_TIMESTAMP = 801
5750 """ 5751 number of times this user is logged in from other computers 5752 """ 5753 return self._sk_property("ZG\242\006]\005", 802, True)
5754 nr_of_other_instances = property(_sk_get_nr_of_other_instances) 5755 propid2label[802] = "nr_of_other_instances" 5756 P_NR_OF_OTHER_INSTANCES = 802
5757 - def _sk_get_skypename(self):
5758 return self._sk_property("ZG\004]\005", 4, True)
5759 skypename = property(_sk_get_skypename) 5760 propid2label[4] = "skypename" 5761 P_SKYPENAME = 4
5762 - def _sk_get_fullname(self):
5763 return self._sk_property("ZG\005]\005", 5, True)
5764 fullname = property(_sk_get_fullname) 5765 propid2label[5] = "fullname" 5766 P_FULLNAME = 5
5767 - def _sk_get_birthday(self):
5768 """ 5769 YYYYMMDD 5770 """ 5771 return self._sk_property("ZG\007]\005", 7, True)
5772 birthday = property(_sk_get_birthday) 5773 propid2label[7] = "birthday" 5774 P_BIRTHDAY = 7
5775 - def _sk_get_gender(self):
5776 """ 5777 1-male, 2-female 5778 """ 5779 return self._sk_property("ZG\010]\005", 8, True)
5780 gender = property(_sk_get_gender) 5781 propid2label[8] = "gender" 5782 P_GENDER = 8
5783 - def _sk_get_languages(self):
5784 """ 5785 ISO language codes, space-separated 5786 """ 5787 return self._sk_property("ZG\011]\005", 9, True)
5788 languages = property(_sk_get_languages) 5789 propid2label[9] = "languages" 5790 P_LANGUAGES = 9
5791 - def _sk_get_country(self):
5792 """ 5793 ISO country code 5794 """ 5795 return self._sk_property("ZG\012]\005", 10, True)
5796 country = property(_sk_get_country) 5797 propid2label[10] = "country" 5798 P_COUNTRY = 10
5799 - def _sk_get_province(self):
5800 return self._sk_property("ZG\013]\005", 11, True)
5801 province = property(_sk_get_province) 5802 propid2label[11] = "province" 5803 P_PROVINCE = 11
5804 - def _sk_get_city(self):
5805 return self._sk_property("ZG\014]\005", 12, True)
5806 city = property(_sk_get_city) 5807 propid2label[12] = "city" 5808 P_CITY = 12
5809 - def _sk_get_phone_home(self):
5810 """ 5811 NB! string not integer 5812 """ 5813 return self._sk_property("ZG\015]\005", 13, True)
5814 phone_home = property(_sk_get_phone_home) 5815 propid2label[13] = "phone_home" 5816 P_PHONE_HOME = 13
5817 - def _sk_get_phone_office(self):
5818 return self._sk_property("ZG\016]\005", 14, True)
5819 phone_office = property(_sk_get_phone_office) 5820 propid2label[14] = "phone_office" 5821 P_PHONE_OFFICE = 14
5822 - def _sk_get_phone_mobile(self):
5823 return self._sk_property("ZG\017]\005", 15, True)
5824 phone_mobile = property(_sk_get_phone_mobile) 5825 propid2label[15] = "phone_mobile" 5826 P_PHONE_MOBILE = 15
5827 - def _sk_get_emails(self):
5828 """ 5829 This is a string property, that contains space-separated list of email addresses. When surfacing this property in your UI, you will need to take into account that there may be more than one email addresses in this property (i.e. split the value at spaces and display them as list). Similarly, when modifying this property with SetStrProperty method, your editor should allow editing of component email addresses separately and add them all up again, before submitting back to the account. 5830 5831 """ 5832 return self._sk_property("ZG\020]\005", 16, True)
5833 emails = property(_sk_get_emails) 5834 propid2label[16] = "emails" 5835 P_EMAILS = 16
5836 - def _sk_get_homepage(self):
5837 return self._sk_property("ZG\021]\005", 17, True)
5838 homepage = property(_sk_get_homepage) 5839 propid2label[17] = "homepage" 5840 P_HOMEPAGE = 17
5841 - def _sk_get_about(self):
5842 """ 5843 arbitrary introductory text 5844 """ 5845 return self._sk_property("ZG\022]\005", 18, True)
5846 about = property(_sk_get_about) 5847 propid2label[18] = "about" 5848 P_ABOUT = 18
5849 - def _sk_get_profile_timestamp(self):
5850 """ 5851 UNIX timestamp of last profile change 5852 """ 5853 return self._sk_property("ZG\023]\005", 19, True)
5854 profile_timestamp = property(_sk_get_profile_timestamp) 5855 propid2label[19] = "profile_timestamp" 5856 P_PROFILE_TIMESTAMP = 19
5857 - def _sk_get_mood_text(self):
5858 """ 5859 Personal mood text (visible to authorised users only). Max length 300 bytes. 5860 5861 """ 5862 return self._sk_property("ZG\032]\005", 26, True)
5863 mood_text = property(_sk_get_mood_text) 5864 propid2label[26] = "mood_text" 5865 P_MOOD_TEXT = 26
5866 - def _sk_get_timezone(self):
5867 """ 5868 24*3600+diff_to_UTC_in_seconds. nb! changes with DST 5869 """ 5870 return self._sk_property("ZG\033]\005", 27, True)
5871 timezone = property(_sk_get_timezone) 5872 propid2label[27] = "timezone" 5873 P_TIMEZONE = 27
5875 """ 5876 Count of this user's authorized contacts. 5877 5878 """ 5879 return self._sk_property("ZG\034]\005", 28, True)
5880 nrof_authed_buddies = property(_sk_get_nrof_authed_buddies) 5881 propid2label[28] = "nrof_authed_buddies" 5882 P_NROF_AUTHED_BUDDIES = 28
5883 - def _sk_get_availability(self):
5884 """ 5885 Contact::AVAILABILITY 5886 """ 5887 return skypekit.enumof(Contact.AVAILABILITY, self._sk_property("ZG\042]\005", 34, True))
5888 availability = property(_sk_get_availability) 5889 propid2label[34] = "availability" 5890 P_AVAILABILITY = 34
5891 - def _sk_get_avatar_image(self):
5892 """ 5893 Account avatar picture can be set with Account::SetBinProperty method. The contact avatar picture is limited to max 96x96 pixels and 32000 bytes. If the submitted avatar picture exceeds either of these size limits, it is the responsibility of your client to scale the image down to appropriate size. 5894 5895 The avatar pictures have to be in JPG format. A SkypeKit client can enable the user to set the Account avatar in other picture formats, in which case the picture should be converted to JPG before submitting it. 5896 5897 In any case, the avatar picture should be pre-validated with the Skype::ValidateAvatar method. 5898 5899 """ 5900 return self._sk_property("ZG%]\005", 37, True)
5901 avatar_image = property(_sk_get_avatar_image) 5902 propid2label[37] = "avatar_image" 5903 P_AVATAR_IMAGE = 37
5904 - def _sk_get_avatar_timestamp(self):
5905 """ 5906 UNIX timestamp of when current avatar was set 5907 """ 5908 return self._sk_property("ZG\266\001]\005", 182, True)
5909 avatar_timestamp = property(_sk_get_avatar_timestamp) 5910 propid2label[182] = "avatar_timestamp" 5911 P_AVATAR_TIMESTAMP = 182
5912 - def _sk_get_mood_timestamp(self):
5913 """ 5914 UNIX timestamp of when current mood was set 5915 """ 5916 return self._sk_property("ZG\267\001]\005", 183, True)
5917 mood_timestamp = property(_sk_get_mood_timestamp) 5918 propid2label[183] = "mood_timestamp" 5919 P_MOOD_TIMESTAMP = 183
5920 - def _sk_get_rich_mood_text(self):
5921 """ 5922 XML version of CONTACT_MOOD_TEXT. Max length 1000 bytes. 5923 5924 """ 5925 return self._sk_property("ZG\315\001]\005", 205, True)
5926 rich_mood_text = property(_sk_get_rich_mood_text) 5927 propid2label[205] = "rich_mood_text" 5928 P_RICH_MOOD_TEXT = 205 5929
5930 - def GetStatusWithProgress(self):
5931 """ 5932 No description available. 5933 5934 B{Return values:} 5935 - B{status} - Current value of this account's P_STATUS property 5936 - B{progress} - This argument returns 0. 5937 5938 """ 5939 l_request = skypekit.XCallRequest("ZR\005\001", 5, 1) 5940 l_request.add_parm('O', 0, self) 5941 l_response = self.transport.xcall(l_request) 5942 l_result = (skypekit.enumof(Account.STATUS, l_response.get(1))), 5943 l_result += (l_response.get(2, 0)), 5944 return l_result
5945 - def Login( 5946 self, 5947 set_availability_to = "UNKNOWN" 5948 ):
5949 """ 5950 Login an auto-login enabled account (P_STATUS is LOGGED_OUT_AND_PWD_SAVED) and optionally set the availability, for example login in as Contact::DO_NOT_DISTURB. To find out whether there is an auto-login enabled account available, you can use Skype::GetDefaultAccountName to retrieve the skypename of that account. You can then get an Account instance for login by invoking Skype::GetAccount. 5951 5952 If no accounts with stored login credentials are available (GetDefaultAccountName returns an empty string), then you will have to prompt the user for account name and password and then use LoginWithPassword. Account name field in the UI can be pre-populated with strings retrieved with Skype::GetExistingAccounts 5953 5954 5955 B{Arguments:} 5956 - B{set_availability_to} - force this account's initial online status to the specified Contact::AVAILABILITY value. 5957 """ 5958 l_request = skypekit.XCallRequest("ZR\005\005", 5, 5) 5959 l_request.add_parm('O', 0, self) 5960 l_request.add_parm('e', 1, Contact.AVAILABILITY[set_availability_to]) 5961 self.transport.xcall(l_request)
5962 - def LoginWithPassword( 5963 self, 5964 password, 5965 save_pwd = False, 5966 save_data_locally = True 5967 ):
5968 """ 5969 5970 Login in an account by specifying its password. To retrieve an account instance for login, invoke Skype::GetAccount. 5971 5972 5973 B{Arguments:} 5974 - B{password} - Password string (plaintext) for this account, which should be pre-validated (Skype::ValidatePassword) 5975 5976 - B{save_pwd} - 5977 - true: Saves the password, ensuring that auto-login is enabled. 5978 - false (default): Does not save the password, and so the user might not be able to effect auto-login until they explicitly invoke Account::SetPasswordSaved(true). 5979 - B{save_data_locally} - For internal use only. 5980 """ 5981 l_request = skypekit.XCallRequest("ZR\005\006", 5, 6) 5982 l_request.add_parm('O', 0, self) 5983 l_request.add_parm('S', 1, password) 5984 l_request.add_parm('b', 2, save_pwd) 5985 l_request.add_parm('b', 3, save_data_locally) 5986 self.transport.xcall(l_request)
5987 - def Register( 5988 self, 5989 password, 5990 save_pwd = False, 5991 save_data_locally = True, 5992 email = "", 5993 allow_spam = False 5994 ):
5995 """ 5996 This command can be used to create a new Skype account, based on the Account object. When successful, this command will also log in with the newly created account. If the new account registration was not successful, Account status property will change to LOGGED_OUT. A common reason for registration failures is that the an account with that name already exists. In that case, Account LOGOUT_REASON will be set to SKYPENAME_TAKEN. Also, Account SUGGESTED_SKYPENAME property will be set to a list of similar but still available skypenames that could be used instead. The property will contain up to 5 semicolon-separated alternative skypenames. In if no suggested skypenames were available, then this property will contain an empty string. 5997 NB! You should pre-validate your P_SKYPENAME value and any email string (Skype::ValidateProfileString) prior to invoking this method. 5998 5999 6000 B{Arguments:} 6001 - B{password} - Password string (plaintext) for this account, which should be pre-validated (Skype::ValidatePassword) 6002 - B{save_pwd} - 6003 - true: Saves the password and enables auto-login. 6004 - false (default): Does not save the password, and the user needs to be prompted for password on the next login attempt. 6005 - B{save_data_locally} - For internal use only. 6006 - B{email} - An email address for retrieving lost passwords and receiving news and information from Skype. 6007 - B{allow_spam} - enable/disable news and information from Skype being sent to account's e-mail. 6008 """ 6009 l_request = skypekit.XCallRequest("ZR\005\007", 5, 7) 6010 l_request.add_parm('O', 0, self) 6011 l_request.add_parm('S', 1, password) 6012 l_request.add_parm('b', 2, save_pwd) 6013 l_request.add_parm('b', 3, save_data_locally) 6014 l_request.add_parm('S', 4, email) 6015 l_request.add_parm('b', 5, allow_spam) 6016 self.transport.xcall(l_request)
6017 - def Logout( 6018 self, 6019 clear_saved_pwd = False 6020 ):
6021 """ 6022 Logs out current account. Note that calling this on client application exit is optional. 6023 6024 6025 B{Arguments:} 6026 - B{clear_saved_pwd} - 6027 - true: Clears any saved password use with auto-login and so disables auto-login until you explicitly invoke Account::SetPasswordSaved(true). 6028 - false (default): Does not clear any saved password and so does not affect existing auto-login behavior. 6029 """ 6030 l_request = skypekit.XCallRequest("ZR\005\010", 5, 8) 6031 l_request.add_parm('O', 0, self) 6032 l_request.add_parm('b', 1, clear_saved_pwd) 6033 self.transport.xcall(l_request)
6034 - def ChangePassword( 6035 self, 6036 old_password, 6037 new_password, 6038 save_pwd = False 6039 ):
6040 """ 6041 Changes this account's password. Returns false if the change failed. NB! You should pre-validate your password strings (Skype::ValidatePassword) and ensure that they are different prior to invoking this method. 6042 6043 6044 B{Arguments:} 6045 - B{old_password} - "Current password string (plaintext) for this account 6046 - B{new_password} - New password string (plaintext) for this account 6047 - B{save_pwd} - 6048 - true: Saves the new password and enables auto-login. 6049 - false (default): Clears any existing saved password and so the user cannot effect auto-login until they explicitly invoke Account::SetPasswordSaved(true) 6050 """ 6051 l_request = skypekit.XCallRequest("ZR\005\013", 5, 11) 6052 l_request.add_parm('O', 0, self) 6053 l_request.add_parm('S', 1, old_password) 6054 l_request.add_parm('S', 2, new_password) 6055 l_request.add_parm('b', 3, save_pwd) 6056 self.transport.xcall(l_request)
6057 - def SetPasswordSaved( 6058 self, 6059 save_pwd 6060 ):
6061 """ 6062 save or clear credentials for auto-login whilst already logged in 6063 6064 B{Arguments:} 6065 - B{save_pwd} 6066 """ 6067 l_request = skypekit.XCallRequest("ZR\005\031", 5, 25) 6068 l_request.add_parm('O', 0, self) 6069 l_request.add_parm('b', 1, save_pwd) 6070 self.transport.xcall(l_request)
6071 - def SetServersideIntProperty( 6072 self, 6073 prop_key, 6074 value 6075 ):
6076 """ 6077 Setter for integer (and enum) server-side properties. For a list of writeable server-side properties, see the detailed description of the Account class. 6078 6079 6080 B{Arguments:} 6081 - B{prop_key} 6082 - B{value} 6083 """ 6084 l_request = skypekit.XCallRequest("ZR\005\014", 5, 12) 6085 l_request.add_parm('O', 0, self) 6086 l_request.add_parm('e', 1, prop_key) 6087 l_request.add_parm('u', 2, value) 6088 self.transport.xcall(l_request)
6089 - def SetServersideStrProperty( 6090 self, 6091 prop_key, 6092 value 6093 ):
6094 """ 6095 Setter for String server-side properties. For a list of writeable server-side properties, see the detailed description of the Account class. 6096 6097 6098 B{Arguments:} 6099 - B{prop_key} 6100 - B{value} 6101 """ 6102 l_request = skypekit.XCallRequest("ZR\005\015", 5, 13) 6103 l_request.add_parm('O', 0, self) 6104 l_request.add_parm('e', 1, prop_key) 6105 l_request.add_parm('S', 2, value) 6106 self.transport.xcall(l_request)
6107 - def CancelServerCommit(self):
6108 """ 6109 Cancels an attempt to commit a server-side P_XXX_POLICY or the P_OFFLINE_CALLFORWARD server-side property. Invoking this cancellation only makes sense whilst the P_COMMITTSTATUS is in COMMITTING_TO_SERVER state. 6110 6111 """ 6112 l_request = skypekit.XCallRequest("ZR\005\017", 5, 15) 6113 l_request.add_parm('O', 0, self) 6114 self.transport.xcall(l_request)
6115 - def SetIntProperty( 6116 self, 6117 prop_key, 6118 value 6119 ):
6120 """ 6121 Setter for integer properties. For a list of writeable account profile properties, see the detailed description of the Account class. 6122 6123 6124 B{Arguments:} 6125 - B{prop_key} 6126 - B{value} 6127 """ 6128 l_request = skypekit.XCallRequest("ZR\005\020", 5, 16) 6129 l_request.add_parm('O', 0, self) 6130 l_request.add_parm('e', 1, prop_key) 6131 l_request.add_parm('u', 2, value) 6132 self.transport.xcall(l_request)
6133 - def SetStrProperty( 6134 self, 6135 prop_key, 6136 value 6137 ):
6138 """ 6139 Setter for String properties. For a list of writeable account profile properties, see the detailed description of the Account class. NB! You should pre-validate your about and mood message strings (Skype::ValidateProfileString) prior to invoking this method. 6140 6141 6142 B{Arguments:} 6143 - B{prop_key} 6144 - B{value} 6145 """ 6146 l_request = skypekit.XCallRequest("ZR\005\021", 5, 17) 6147 l_request.add_parm('O', 0, self) 6148 l_request.add_parm('e', 1, prop_key) 6149 l_request.add_parm('S', 2, value) 6150 self.transport.xcall(l_request)
6151 - def SetBinProperty( 6152 self, 6153 prop_key, 6154 value 6155 ):
6156 """ 6157 Setter for BLOB properties, such as its avatar image. For a list of writeable account profile properties, see the detailed description of the Account class. NB! You should pre-validate your avatar image (Skype::ValidateAvatar) prior to invoking this method. 6158 6159 6160 B{Arguments:} 6161 - B{prop_key} 6162 - B{value} 6163 """ 6164 l_request = skypekit.XCallRequest("ZR\005\022", 5, 18) 6165 l_request.add_parm('O', 0, self) 6166 l_request.add_parm('e', 1, prop_key) 6167 l_request.add_parm('B', 2, value) 6168 self.transport.xcall(l_request)
6169 - def SetAvailability( 6170 self, 6171 availability 6172 ):
6173 """ 6174 Sets online status of the currently logged in account to one of the values from Contact class AVAILABILITY enumerator. 6175 6176 6177 B{Arguments:} 6178 - B{availability} - only subset of all contact availabilities allowed 6179 """ 6180 l_request = skypekit.XCallRequest("ZR\005\023", 5, 19) 6181 l_request.add_parm('O', 0, self) 6182 l_request.add_parm('e', 1, Contact.AVAILABILITY[availability]) 6183 self.transport.xcall(l_request)
6184 - def SetStandby( 6185 self, 6186 standby 6187 ):
6188 """ 6189 Transitions the availability of this account's associated user, who is assumed to be logged in. 6190 6191 6192 B{Arguments:} 6193 - B{standby} - 6194 - true: Saves the user's current availability, then sets it to CONTACT::AVAILABILITY.OFFLINE 6195 - false: Reconnects the user and restores their previous availability 6196 """ 6197 l_request = skypekit.XCallRequest("ZR\005\012", 5, 10) 6198 l_request.add_parm('O', 0, self) 6199 l_request.add_parm('b', 1, standby) 6200 self.transport.xcall(l_request)
6201 - def GetCapabilityStatus( 6202 self, 6203 capability 6204 ):
6205 """ 6206 Returns state of a given account capability. Takes Contact class CAPABILITY property as input argument and returns its state and expiration timestamp where appropriate. For example (C++ wrapper, with other wrappers the syntax may vary but the idea is the same) MyAccount.GetCapabilityStatus(Contact::CAPABILITY_SKYPEOUT, Cap, T); will return Account::CAPABILITY_EXISTS if local account has SkypeOut enabled. 6207 6208 6209 B{Arguments:} 6210 - B{capability} 6211 6212 B{Return values:} 6213 - B{status} 6214 - B{expiry_timestamp} 6215 """ 6216 l_request = skypekit.XCallRequest("ZR\005\025", 5, 21) 6217 l_request.add_parm('O', 0, self) 6218 l_request.add_parm('e', 1, Contact.CAPABILITY[capability]) 6219 l_response = self.transport.xcall(l_request) 6220 l_result = (skypekit.enumof(Account.CAPABILITYSTATUS, l_response.get(1))), 6221 l_result += (l_response.get(2, 0)), 6222 return l_result
6223 - def GetSkypenameHash(self):
6224 """ 6225 Response is empty when called with an inactive or invalid account 6226 6227 B{Return values:} 6228 - B{skypename_hash} 6229 """ 6230 l_request = skypekit.XCallRequest("ZR\005\026", 5, 22) 6231 l_request.add_parm('O', 0, self) 6232 l_response = self.transport.xcall(l_request) 6233 l_result = l_response.get(1, '') 6234 return l_result
6235 - def GetVerifiedEmail(self):
6236 """ 6237 returns verified-by-Skype e-mail for this account if exists and verifiable 6238 6239 B{Return values:} 6240 - B{email} 6241 """ 6242 l_request = skypekit.XCallRequest("ZR\005\002", 5, 2) 6243 l_request.add_parm('O', 0, self) 6244 l_response = self.transport.xcall(l_request) 6245 l_result = l_response.get(1, '') 6246 return l_result
6247 - def GetVerifiedCompany(self):
6248 """ 6249 returns verified-by-Skype company for this account if exists and verifiable 6250 6251 B{Return values:} 6252 - B{company} 6253 """ 6254 l_request = skypekit.XCallRequest("ZR\005\003", 5, 3) 6255 l_request.add_parm('O', 0, self) 6256 l_response = self.transport.xcall(l_request) 6257 l_result = l_response.get(1, '') 6258 return l_result
6259 - def Delete(self):
6260 """ 6261 Deletes all account data stored locally. Does not remove any account data from the server! 6262 6263 """ 6264 l_request = skypekit.XCallRequest("ZR\005\030", 5, 24) 6265 l_request.add_parm('O', 0, self) 6266 self.transport.xcall(l_request)
6267 - def mget_profile(self):
6268 """ get multiple properties from self """ 6269 self.multiget("ZG\004,\005,\032,\020,\015,\016,\017,\007,\010,\011,\012,\013,\014,\021,\022,\033]\005")
6270 module_id2classes[5] = Account
6271 -class Skype(object):
6272 """ 6273 The main class that exposes Skype-related functionality to your application. Currently the SDK only supports one Skype class instance per runtime. Note that most of the Skype class methods will fail until you have successfully logged in with an account. For more information on constructing a Skype object and the login sequence, see first tutorial example. 6274 6275 """ 6276 module_id = 0 6277 event_handlers = {}
6278 - def __init__(self, transport):
6279 self.object_id = 0 6280 self.transport = transport 6281 transport.set_root(self)
6282 ''' Stop background operations (background threads). Might take some time. 6283 '''
6284 - def stop(self):
6285 self.transport.stop()
6286 - def Stop(self):
6287 warnings.warn("use stop() instead of Stop()", DeprecationWarning, stacklevel=2) 6288 self.stop()
6289 - def Start(self):
6290 """ 6291 No description available. 6292 6293 B{Return values:} 6294 - B{started} 6295 """ 6296 l_request = skypekit.XCallRequest("ZR\000\221\001", 0, 145) 6297 l_response = self.transport.xcall(l_request) 6298 l_result = l_response.get(1, False) 6299 return l_result
6300 SETUPKEY_DB_STORAGE_QUOTA_KB = "*Lib/DbManager/StorageQuotaKb"
6301 - def GetVersionString(self):
6302 """ 6303 returns the runtime version as a string 6304 6305 B{Return values:} 6306 - B{version} 6307 """ 6308 l_request = skypekit.XCallRequest("ZR\000\034", 0, 28) 6309 l_response = self.transport.xcall(l_request) 6310 l_result = l_response.get(1, '') 6311 return l_result
6312 - def GetUnixTimestamp(self):
6313 """ 6314 Returns the time as used in SkypeKit, in the form of a Unix timestamp (number of seconds since 1.1.1970). If the local system time is incorrect my more than one year, the time provided by the Skype network will be provided, which is correct. Therefore this function can be used to adjust the system time if set incorrectly (e.g. if set to 1.1.1970). 6315 6316 B{Return values:} 6317 - B{timestamp} 6318 """ 6319 l_request = skypekit.XCallRequest("ZR\000\206\001", 0, 134) 6320 l_response = self.transport.xcall(l_request) 6321 l_result = l_response.get(1, 0) 6322 return l_result
6323 - def GetHardwiredContactGroup( 6324 self, 6325 type_ 6326 ):
6327 """ 6328 Takes TYPE argument (TYPE comes from ContactGroup class) and returns reference to the corresponding hardwired contact group. For example (C++): skype->GetHardwiredContactGroup(ContactGroup::ONLINE_BUDDIES, GroupRef) would return the list of all contacts that are currently online. 6329 6330 6331 B{Arguments:} 6332 - B{type_} 6333 6334 B{Return values:} 6335 - B{contact_group} 6336 """ 6337 l_request = skypekit.XCallRequest("ZR\000\001", 0, 1) 6338 l_request.add_parm('e', 1, ContactGroup.TYPE[type_]) 6339 l_response = self.transport.xcall(l_request) 6340 l_result = module_id2classes[10](l_response.get(1), self.transport) 6341 return l_result
6342 - def GetCustomContactGroups(self):
6343 """ 6344 Returns a list of custom contact group references, i.e. all contact groups that are not hardwired. 6345 6346 6347 B{Return values:} 6348 - B{groups} 6349 """ 6350 l_request = skypekit.XCallRequest("ZR\000\002", 0, 2) 6351 l_response = self.transport.xcall(l_request) 6352 l_result = [module_id2classes[10](oid, self.transport) for oid in l_response.get(1, [])] 6353 return l_result
6354 - def CreateCustomContactGroup(self):
6355 """ 6356 Creates a new empty contact group object and returns a reference to it. The group will then show up in the custom group list that you can get with Skype class GetCustomContactGroups method. Existing contacts can be added to the new group with ContactGroup class AddContact method and a custom name can be given to it with GiveDisplayName method. 6357 Note that no check is made for existing of displaynames with the same name - if you wish to force uniqueness in custom group names you will have to check that yourself before creating the group. 6358 6359 6360 B{Return values:} 6361 - B{group} 6362 """ 6363 l_request = skypekit.XCallRequest("ZR\000\003", 0, 3) 6364 l_response = self.transport.xcall(l_request) 6365 l_result = module_id2classes[10](l_response.get(1), self.transport) 6366 return l_result
6367 - def OnNewCustomContactGroup( 6368 self, 6369 group 6370 ):
6371 """ 6372 No description available. 6373 6374 B{Return values:} 6375 - B{group} - eg, new contact group loaded from CBL 6376 """ 6377 pass
6378 event_handlers[1] = "_sk_on_new_custom_contact_group"
6379 - def _sk_on_new_custom_contact_group(self, parms):
6380 """ internal event dispatcher for OnNewCustomContactGroup """ 6381 l_cleanparms = module_id2classes[10](parms.get(1), self.transport) 6382 self.OnNewCustomContactGroup(l_cleanparms)
6383 - def mget_info_from_contacts(self, objects):
6384 """ get multiple properties from objects """ 6385 self.transport.multiget("ZG\042,\025]\002", objects)
6386 - def GetContactType( 6387 self, 6388 identity 6389 ):
6390 """ 6391 analyzes the identity for contact type 6392 6393 B{Arguments:} 6394 - B{identity} 6395 6396 B{Return values:} 6397 - B{type_} 6398 """ 6399 l_request = skypekit.XCallRequest("ZR\000\005", 0, 5) 6400 l_request.add_parm('S', 1, identity) 6401 l_response = self.transport.xcall(l_request) 6402 l_result = skypekit.enumof(Contact.TYPE, l_response.get(1)) 6403 return l_result
6404 - def GetContact( 6405 self, 6406 identity 6407 ):
6408 """ 6409 Returns a Contact object reference. If a matching contact is not found in the existing contact list, a new Contact object will be created. Note that if you pass in a phone number in the identity argument, the type for the newly created Contact will be automatically set to Contact::PSTN (Contact::SKYPE otherwise). 6410 6411 6412 B{Arguments:} 6413 - B{identity} - Either skypename or a phone number 6414 6415 6416 B{Return values:} 6417 - B{contact} - Returns a contact object. 6418 6419 """ 6420 l_request = skypekit.XCallRequest("ZR\000\006", 0, 6) 6421 l_request.add_parm('S', 1, identity) 6422 l_response = self.transport.xcall(l_request) 6423 l_result = module_id2classes[2](l_response.get(2), self.transport) 6424 return l_result
6425 - def FindContactByPstnNumber( 6426 self, 6427 number 6428 ):
6429 """ 6430 No description available. 6431 6432 B{Arguments:} 6433 - B{number} 6434 6435 B{Return values:} 6436 - B{found} 6437 - B{contact} 6438 - B{found_in_key} - type is actually PROPKEY 6439 """ 6440 l_request = skypekit.XCallRequest("ZR\000\010", 0, 8) 6441 l_request.add_parm('S', 1, number) 6442 l_response = self.transport.xcall(l_request) 6443 l_result = (l_response.get(1, False)), 6444 l_result += (module_id2classes[2](l_response.get(2), self.transport)), 6445 l_result += (l_response.get(3, 0)), 6446 return l_result
6447 IDENTITYTYPE = { 6448 0:'UNRECOGNIZED', 6449 1:'SKYPE', 6450 2:'SKYPE_MYSELF', 6451 3:'SKYPE_UNDISCLOSED', 6452 4:'PSTN', 6453 5:'PSTN_EMERGENCY', 6454 6:'PSTN_FREE', 6455 7:'PSTN_UNDISCLOSED', 6456 8:'CONFERENCE', 6457 9:'EXTERNAL', 6458 'UNRECOGNIZED' :0, 6459 'SKYPE' :1, 6460 'SKYPE_MYSELF' :2, 6461 'SKYPE_UNDISCLOSED' :3, 6462 'PSTN' :4, 6463 'PSTN_EMERGENCY' :5, 6464 'PSTN_FREE' :6, 6465 'PSTN_UNDISCLOSED' :7, 6466 'CONFERENCE' :8, 6467 'EXTERNAL' :9 6468 } 6469 """ 6470 - UNRECOGNIZED 6471 - SKYPE 6472 - SKYPE_MYSELF 6473 - SKYPE_UNDISCLOSED 6474 - PSTN 6475 - PSTN_EMERGENCY 6476 - PSTN_FREE 6477 - PSTN_UNDISCLOSED 6478 - CONFERENCE 6479 - EXTERNAL 6480 """
6481 - def GetIdentityType( 6482 self, 6483 identity 6484 ):
6485 """ 6486 This takes skypename or a phone number string as argument and returns corresponding identity type (SKYPE, SKYPE_MYSELF, PSTN, etc.) 6487 6488 6489 B{Arguments:} 6490 - B{identity} 6491 6492 B{Return values:} 6493 - B{type_} 6494 """ 6495 l_request = skypekit.XCallRequest("ZR\000\023", 0, 19) 6496 l_request.add_parm('S', 1, identity) 6497 l_response = self.transport.xcall(l_request) 6498 l_result = skypekit.enumof(Skype.IDENTITYTYPE, l_response.get(1)) 6499 return l_result
6500 NORMALIZERESULT = {0:'IDENTITY_OK', 'IDENTITY_OK':0, 1:'IDENTITY_EMPTY', 'IDENTITY_EMPTY':1, 2:'IDENTITY_TOO_LONG', 'IDENTITY_TOO_LONG':2, 3:'IDENTITY_CONTAINS_INVALID_CHAR', 'IDENTITY_CONTAINS_INVALID_CHAR':3, 4:'PSTN_NUMBER_TOO_SHORT', 'PSTN_NUMBER_TOO_SHORT':4, 5:'PSTN_NUMBER_HAS_INVALID_PREFIX', 'PSTN_NUMBER_HAS_INVALID_PREFIX':5, 6:'SKYPENAME_STARTS_WITH_NONALPHA', 'SKYPENAME_STARTS_WITH_NONALPHA':6, 7:'SKYPENAME_SHORTER_THAN_6_CHARS', 'SKYPENAME_SHORTER_THAN_6_CHARS':7} 6501 """ 6502 - IDENTITY_OK 6503 - IDENTITY_EMPTY 6504 - IDENTITY_TOO_LONG 6505 - IDENTITY_CONTAINS_INVALID_CHAR 6506 - PSTN_NUMBER_TOO_SHORT 6507 - PSTN_NUMBER_HAS_INVALID_PREFIX - identity looks like pstn number but does not start with +/00/011 6508 - SKYPENAME_STARTS_WITH_NONALPHA 6509 - SKYPENAME_SHORTER_THAN_6_CHARS - returned only when isNewSkypeName 6510 """
6511 - def IdentitiesMatch( 6512 self, 6513 identity_a, 6514 identity_b 6515 ):
6516 """ 6517 compares two identities to see if they match 6518 6519 B{Arguments:} 6520 - B{identity_a} 6521 - B{identity_b} 6522 6523 B{Return values:} 6524 - B{result} 6525 """ 6526 l_request = skypekit.XCallRequest("ZR\000X", 0, 88) 6527 l_request.add_parm('S', 1, identity_a) 6528 l_request.add_parm('S', 2, identity_b) 6529 l_response = self.transport.xcall(l_request) 6530 l_result = l_response.get(1, False) 6531 return l_result
6532 - def NormalizeIdentity( 6533 self, 6534 original, 6535 is_new_skype_name = False 6536 ):
6537 """ 6538 This method is deprecated. Use ValidateProfileString method instead. 6539 6540 6541 B{Arguments:} 6542 - B{original} 6543 - B{is_new_skype_name} 6544 6545 B{Return values:} 6546 - B{result} 6547 - B{normalized} 6548 """ 6549 l_request = skypekit.XCallRequest("ZR\000\011", 0, 9) 6550 l_request.add_parm('S', 1, original) 6551 l_request.add_parm('b', 2, is_new_skype_name) 6552 l_response = self.transport.xcall(l_request) 6553 l_result = (skypekit.enumof(Skype.NORMALIZERESULT, l_response.get(1))), 6554 l_result += (l_response.get(2, '')), 6555 return l_result
6556 - def NormalizePSTNWithCountry( 6557 self, 6558 original, 6559 country_prefix = 0 6560 ):
6561 """ 6562 NormalizePSTNWithCountry checks if the phone number starts with + if it doesn't, it prefixes the output with +XXX (where XXX is the country code). It also converts letters to numbers based on the standard phone keypad, so that the phone number string 212CALLME1 with country code 372 (Estonia) would be normalized to +3722122255631. If the method cannot normalize the phone number (because it's too long, too short, etc.), it returns an error code in &result. 6563 6564 6565 B{Arguments:} 6566 - B{original} 6567 - B{country_prefix} 6568 6569 B{Return values:} 6570 - B{result} 6571 - B{normalized} 6572 """ 6573 l_request = skypekit.XCallRequest("ZR\000\315\001", 0, 205) 6574 l_request.add_parm('S', 1, original) 6575 l_request.add_parm('u', 2, country_prefix) 6576 l_response = self.transport.xcall(l_request) 6577 l_result = (skypekit.enumof(Skype.NORMALIZERESULT, l_response.get(1))), 6578 l_result += (l_response.get(2, '')), 6579 return l_result
6580 - def OnContactOnlineAppearance( 6581 self, 6582 contact 6583 ):
6584 """ 6585 This contact has appeared online. display alert 6586 6587 B{Return values:} 6588 - B{contact} 6589 """ 6590 pass
6591 event_handlers[2] = "_sk_on_contact_online_appearance"
6592 - def _sk_on_contact_online_appearance(self, parms):
6593 """ internal event dispatcher for OnContactOnlineAppearance """ 6594 l_cleanparms = module_id2classes[2](parms.get(1), self.transport) 6595 self.OnContactOnlineAppearance(l_cleanparms)
6596 - def OnContactGoneOffline( 6597 self, 6598 contact 6599 ):
6600 """ 6601 This contact has gone offline. display alert 6602 6603 B{Return values:} 6604 - B{contact} 6605 """ 6606 pass
6607 event_handlers[3] = "_sk_on_contact_gone_offline"
6608 - def _sk_on_contact_gone_offline(self, parms):
6609 """ internal event dispatcher for OnContactGoneOffline """ 6610 l_cleanparms = module_id2classes[2](parms.get(1), self.transport) 6611 self.OnContactGoneOffline(l_cleanparms)
6612 - def GetOptimalAgeRanges(self):
6613 """ 6614 list of (min,max) pairs 6615 6616 B{Return values:} 6617 - B{range_list} 6618 """ 6619 l_request = skypekit.XCallRequest("ZR\000M", 0, 77) 6620 l_response = self.transport.xcall(l_request) 6621 l_result = l_response.get(1, []) 6622 return l_result
6623 - def CreateContactSearch(self):
6624 """ 6625 Creates a blank contact search object, in which you can add your custom search terms. For more information how asynchronous contact search works, see ContactSearch class details. 6626 6627 6628 B{Return values:} 6629 - B{search} - Returns blank ContactSearch object. 6630 6631 """ 6632 l_request = skypekit.XCallRequest("ZR\000\012", 0, 10) 6633 l_response = self.transport.xcall(l_request) 6634 l_result = module_id2classes[1](l_response.get(1), self.transport) 6635 return l_result
6636 - def CreateBasicContactSearch( 6637 self, 6638 text 6639 ):
6640 """ 6641 searches skypenames, aliases, fullnames, emails. false if not valid 6642 6643 B{Arguments:} 6644 - B{text} 6645 6646 B{Return values:} 6647 - B{search} 6648 """ 6649 l_request = skypekit.XCallRequest("ZR\000\013", 0, 11) 6650 l_request.add_parm('S', 1, text) 6651 l_response = self.transport.xcall(l_request) 6652 l_result = module_id2classes[1](l_response.get(1), self.transport) 6653 return l_result
6654 - def CreateIdentitySearch( 6655 self, 6656 identity 6657 ):
6658 """ 6659 searches skypenames and aliases. returns 0 or 1 results. false if not valid 6660 6661 B{Arguments:} 6662 - B{identity} 6663 6664 B{Return values:} 6665 - B{search} 6666 """ 6667 l_request = skypekit.XCallRequest("ZR\000\014", 0, 12) 6668 l_request.add_parm('S', 1, identity) 6669 l_response = self.transport.xcall(l_request) 6670 l_result = module_id2classes[1](l_response.get(1), self.transport) 6671 return l_result
6672 TRANSFER_SENDFILE_ERROR = {0:'TRANSFER_OPEN_SUCCESS', 'TRANSFER_OPEN_SUCCESS':0, 1:'TRANSFER_BAD_FILENAME', 'TRANSFER_BAD_FILENAME':1, 2:'TRANSFER_OPEN_FAILED', 'TRANSFER_OPEN_FAILED':2, 3:'TRANSFER_TOO_MANY_PARALLEL', 'TRANSFER_TOO_MANY_PARALLEL':3} 6673 """ 6674 sync failure reasons when starting a transfer 6675 - TRANSFER_OPEN_SUCCESS 6676 - TRANSFER_BAD_FILENAME 6677 - TRANSFER_OPEN_FAILED 6678 - TRANSFER_TOO_MANY_PARALLEL 6679 """ 6680 LEAVE_REASON = { 6681 0 :'LEAVE_REASON_NONE', 6682 2 :'RETIRED_USER_INCAPABLE', 6683 3 :'RETIRED_ADDER_MUST_BE_FRIEND', 6684 4 :'RETIRED_ADDER_MUST_BE_AUTHORIZED', 6685 5 :'RETIRED_DECLINE_ADD', 6686 6 :'RETIRED_UNSUBSCRIBE', 6687 100:'LIVE_NO_ANSWER', 6688 101:'LIVE_MANUAL', 6689 102:'LIVE_BUSY', 6690 103:'LIVE_CONNECTION_DROPPED', 6691 104:'LIVE_NO_SKYPEOUT_SUBSCRIPTION', 6692 105:'LIVE_INSUFFICIENT_FUNDS', 6693 106:'LIVE_INTERNET_CONNECTION_LOST', 6694 107:'LIVE_SKYPEOUT_ACCOUNT_BLOCKED', 6695 108:'LIVE_PSTN_COULD_NOT_CONNECT_TO_SKYPE_PROXY', 6696 109:'LIVE_PSTN_INVALID_NUMBER', 6697 110:'LIVE_PSTN_NUMBER_FORBIDDEN', 6698 111:'LIVE_PSTN_CALL_TIMED_OUT', 6699 112:'LIVE_PSTN_BUSY', 6700 113:'LIVE_PSTN_CALL_TERMINATED', 6701 114:'LIVE_PSTN_NETWORK_ERROR', 6702 115:'LIVE_NUMBER_UNAVAILABLE', 6703 116:'LIVE_PSTN_CALL_REJECTED', 6704 117:'LIVE_PSTN_MISC_ERROR', 6705 118:'LIVE_INTERNAL_ERROR', 6706 119:'LIVE_UNABLE_TO_CONNECT', 6707 120:'LIVE_RECORDING_FAILED', 6708 121:'LIVE_PLAYBACK_ERROR', 6709 122:'LIVE_LEGACY_ERROR', 6710 123:'LIVE_BLOCKED_BY_PRIVACY_SETTINGS', 6711 124:'LIVE_ERROR', 6712 125:'LIVE_TRANSFER_FAILED', 6713 126:'LIVE_TRANSFER_INSUFFICIENT_FUNDS', 6714 127:'LIVE_BLOCKED_BY_US', 6715 128:'LIVE_EMERGENCY_CALL_DENIED', 6716 'LEAVE_REASON_NONE' : 0, 6717 'RETIRED_USER_INCAPABLE' : 2, 6718 'RETIRED_ADDER_MUST_BE_FRIEND' : 3, 6719 'RETIRED_ADDER_MUST_BE_AUTHORIZED' : 4, 6720 'RETIRED_DECLINE_ADD' : 5, 6721 'RETIRED_UNSUBSCRIBE' : 6, 6722 'LIVE_NO_ANSWER' :100, 6723 'LIVE_MANUAL' :101, 6724 'LIVE_BUSY' :102, 6725 'LIVE_CONNECTION_DROPPED' :103, 6726 'LIVE_NO_SKYPEOUT_SUBSCRIPTION' :104, 6727 'LIVE_INSUFFICIENT_FUNDS' :105, 6728 'LIVE_INTERNET_CONNECTION_LOST' :106, 6729 'LIVE_SKYPEOUT_ACCOUNT_BLOCKED' :107, 6730 'LIVE_PSTN_COULD_NOT_CONNECT_TO_SKYPE_PROXY' :108, 6731 'LIVE_PSTN_INVALID_NUMBER' :109, 6732 'LIVE_PSTN_NUMBER_FORBIDDEN' :110, 6733 'LIVE_PSTN_CALL_TIMED_OUT' :111, 6734 'LIVE_PSTN_BUSY' :112, 6735 'LIVE_PSTN_CALL_TERMINATED' :113, 6736 'LIVE_PSTN_NETWORK_ERROR' :114, 6737 'LIVE_NUMBER_UNAVAILABLE' :115, 6738 'LIVE_PSTN_CALL_REJECTED' :116, 6739 'LIVE_PSTN_MISC_ERROR' :117, 6740 'LIVE_INTERNAL_ERROR' :118, 6741 'LIVE_UNABLE_TO_CONNECT' :119, 6742 'LIVE_RECORDING_FAILED' :120, 6743 'LIVE_PLAYBACK_ERROR' :121, 6744 'LIVE_LEGACY_ERROR' :122, 6745 'LIVE_BLOCKED_BY_PRIVACY_SETTINGS' :123, 6746 'LIVE_ERROR' :124, 6747 'LIVE_TRANSFER_FAILED' :125, 6748 'LIVE_TRANSFER_INSUFFICIENT_FUNDS' :126, 6749 'LIVE_BLOCKED_BY_US' :127, 6750 'LIVE_EMERGENCY_CALL_DENIED' :128 6751 } 6752 """ 6753 - LEAVE_REASON_NONE 6754 - RETIRED_USER_INCAPABLE - automatic, user cannot chat (only some older versions might set this) 6755 - RETIRED_ADDER_MUST_BE_FRIEND - automatic 6756 - RETIRED_ADDER_MUST_BE_AUTHORIZED - automatic 6757 - RETIRED_DECLINE_ADD - manual reason (afaik no UI uses this) 6758 - RETIRED_UNSUBSCRIBE - manual reason 6759 - LIVE_NO_ANSWER 6760 - LIVE_MANUAL - live: User hung up 6761 - LIVE_BUSY 6762 - LIVE_CONNECTION_DROPPED 6763 - LIVE_NO_SKYPEOUT_SUBSCRIPTION 6764 - LIVE_INSUFFICIENT_FUNDS 6765 - LIVE_INTERNET_CONNECTION_LOST 6766 - LIVE_SKYPEOUT_ACCOUNT_BLOCKED 6767 - LIVE_PSTN_COULD_NOT_CONNECT_TO_SKYPE_PROXY 6768 - LIVE_PSTN_INVALID_NUMBER 6769 - LIVE_PSTN_NUMBER_FORBIDDEN 6770 - LIVE_PSTN_CALL_TIMED_OUT 6771 - LIVE_PSTN_BUSY 6772 - LIVE_PSTN_CALL_TERMINATED 6773 - LIVE_PSTN_NETWORK_ERROR 6774 - LIVE_NUMBER_UNAVAILABLE 6775 - LIVE_PSTN_CALL_REJECTED 6776 - LIVE_PSTN_MISC_ERROR 6777 - LIVE_INTERNAL_ERROR 6778 - LIVE_UNABLE_TO_CONNECT 6779 - LIVE_RECORDING_FAILED - live: Voicemail recording failed 6780 - LIVE_PLAYBACK_ERROR - live: Voicemail playback failed 6781 - LIVE_LEGACY_ERROR 6782 - LIVE_BLOCKED_BY_PRIVACY_SETTINGS 6783 - LIVE_ERROR - live: Fallback error 6784 - LIVE_TRANSFER_FAILED 6785 - LIVE_TRANSFER_INSUFFICIENT_FUNDS 6786 - LIVE_BLOCKED_BY_US 6787 - LIVE_EMERGENCY_CALL_DENIED 6788 """
6789 - def mget_info_from_participants(self, objects):
6790 """ get multiple properties from objects """ 6791 self.transport.multiget("ZG\247\007,\246\007,\250\007,\244\007,\266\007,\252\007,\243\007]\023", objects)
6792 - def mget_info_from_conversations(self, objects):
6793 """ get multiple properties from objects """ 6794 self.transport.multiget("ZG\234\007,\320\007,\240\007]\022", objects)
6795 - def CreateConference(self):
6796 """ 6797 Creates a new empty conversation object and returns a reference to it. 6798 6799 6800 B{Return values:} 6801 - B{conference} 6802 """ 6803 l_request = skypekit.XCallRequest("ZR\000\015", 0, 13) 6804 l_response = self.transport.xcall(l_request) 6805 l_result = module_id2classes[18](l_response.get(1), self.transport) 6806 return l_result
6807 - def GetConversationByIdentity( 6808 self, 6809 convo_identity 6810 ):
6811 """ 6812 Returns reference tp conversation object by conversation ID string (equivalent of old chat ID). NB! ID here is that of conversation, rather than skypename of dialog partner. If you want to retrieve a conversation object with any particular person, then Skype class GetConversationByParticipants method is what you are looking for. 6813 6814 6815 B{Arguments:} 6816 - B{convo_identity} 6817 6818 B{Return values:} 6819 - B{conversation} 6820 """ 6821 l_request = skypekit.XCallRequest("ZR\000\017", 0, 15) 6822 l_request.add_parm('S', 1, convo_identity) 6823 l_response = self.transport.xcall(l_request) 6824 l_result = module_id2classes[18](l_response.get(1), self.transport) 6825 return l_result
6826 - def GetConversationByParticipants( 6827 self, 6828 participant_identities, 6829 create_if_non_existing = False, 6830 ignore_bookmarked_or_named = False 6831 ):
6832 """ 6833 myself not included 6834 6835 B{Arguments:} 6836 - B{participant_identities} 6837 - B{create_if_non_existing} 6838 - B{ignore_bookmarked_or_named} 6839 6840 B{Return values:} 6841 - B{conversation} 6842 """ 6843 l_request = skypekit.XCallRequest("ZR\000\020", 0, 16) 6844 l_request.add_parm('S', 1, participant_identities) 6845 l_request.add_parm('b', 2, create_if_non_existing) 6846 l_request.add_parm('b', 3, ignore_bookmarked_or_named) 6847 l_response = self.transport.xcall(l_request) 6848 l_result = module_id2classes[18](l_response.get(1), self.transport) 6849 return l_result
6850 - def GetConversationByBlob( 6851 self, 6852 join_blob, 6853 also_join = True 6854 ):
6855 """ 6856 Retrieves a Conversation object by Public Conversation BLOB. Public conversation blobs are globally unique conversation IDs that provide a method for joining conversation without explicitly being added to the conversation by someone already in it. Programmatically, a Conversation BLOB can be retrieved with Conversation::GetJoinBlob method. In Skype desktop clients, the BLOB can be retrieved by typing "/get uri" in a conversation. The conversation can then be joined by people who have somehow received that BLOB. 6857 6858 6859 B{Arguments:} 6860 - B{join_blob} - The BLOB string. 6861 6862 - B{also_join} - If set to true, automatically joins current user into the Conversation. 6863 6864 6865 B{Return values:} 6866 - B{conversation} - Returns Conversation object if successful. 6867 6868 """ 6869 l_request = skypekit.XCallRequest("ZR\000\021", 0, 17) 6870 l_request.add_parm('S', 1, join_blob) 6871 l_request.add_parm('b', 2, also_join) 6872 l_response = self.transport.xcall(l_request) 6873 l_result = module_id2classes[18](l_response.get(1), self.transport) 6874 return l_result
6875 - def GetConversationList( 6876 self, 6877 type_ = "ALL_CONVERSATIONS" 6878 ):
6879 """ 6880 Returns a list of Conversation objects by Conversation::LIST_TYPE filter. 6881 6882 6883 B{Arguments:} 6884 - B{type_} - Filter. 6885 6886 6887 B{Return values:} 6888 - B{conversations} - List of conversations matching the filter. 6889 6890 """ 6891 l_request = skypekit.XCallRequest("ZR\000\022", 0, 18) 6892 l_request.add_parm('e', 1, Conversation.LIST_TYPE[type_]) 6893 l_response = self.transport.xcall(l_request) 6894 l_result = [module_id2classes[18](oid, self.transport) for oid in l_response.get(1, [])] 6895 return l_result
6896 - def OnConversationListChange( 6897 self, 6898 conversation, 6899 type_, 6900 added 6901 ):
6902 """ 6903 This event gets fired when a Conversation item is added or removed from the list specified in the type argument. The primary use of this event is to detect creation of new Conversation objects. It can also be used for detecting occurance of live sessions - by monitoring added = true in Conversation::LIVE_CONVERSATIONS. Note that this method is not entirely sufficient for detecting live session termination (added = false and type = Conversation::LIVE_CONVERSATIONS). When the live session goes down, the default behaviour is that the Conversation object remains in the LIVE_CONVERSATIONS list for approximately 10 seconds. When another live session comes up within the same Conversation, the OnConversationListChange event will not fire - because the conversation was already in that list. There are two ways of getting around that. Firstly you can have all the conversations referenced at all times and then monitor Conversation::P_LOCAL_LIVESTATUS property changes, in which case you can pick up incoming live sessions from there. Alternatively, you can remove the delay between live session termination and conversation's removal from the LIVE_CONVERSATIONS list. This delay is controlled by the SETUPKEY_RECENTLY_LIVE_TIMEOUT setup key. To remove the delay, use Skype::SetInt(SETUPKEY_RECENTLY_LIVE_TIMEOUT, 0). Note that this setup key is account-based. You will need to have an account logged in in order to modify its value. 6904 6905 6906 B{Return values:} 6907 - B{conversation} - Conversation object that was added or removed to a list specified in the type argument. 6908 6909 - B{type_} - Specifies the list, into which the conversation was added or removed from. 6910 6911 - B{added} - Specifies whether the conversation was added or removed. For ALL_CONVERSATIONS list, the removed event is only fired when the conversation is actually deleted. 6912 6913 """ 6914 pass
6915 event_handlers[4] = "_sk_on_conversation_list_change"
6916 - def _sk_on_conversation_list_change(self, parms):
6917 """ internal event dispatcher for OnConversationListChange """ 6918 l_cleanparms = (module_id2classes[18](parms.get(1), self.transport)), 6919 l_cleanparms += (Conversation.LIST_TYPE[parms.get(2)]), 6920 l_cleanparms += (parms.get(3, False)), 6921 self.OnConversationListChange(*l_cleanparms)
6922 - def mget_info_from_messages(self, objects):
6923 """ get multiple properties from objects """ 6924 self.transport.multiget("ZG\300\007,{,\301\007,\177,y]\011", objects)
6925 - def GetMessageByGuid( 6926 self, 6927 guid 6928 ):
6929 """ 6930 Retrieves a Message object by the P_GUID property (globally unique ID, same for all the participants of the conversation, in which this message occured). 6931 6932 6933 B{Arguments:} 6934 - B{guid} - Globally unique ID of the message. 6935 6936 6937 B{Return values:} 6938 - B{message} - Returns a Message object if a match was found. 6939 6940 """ 6941 l_request = skypekit.XCallRequest("ZR\000\025", 0, 21) 6942 l_request.add_parm('B', 1, guid) 6943 l_response = self.transport.xcall(l_request) 6944 l_result = module_id2classes[9](l_response.get(1), self.transport) 6945 return l_result
6946 - def GetMessageListByType( 6947 self, 6948 type_, 6949 latest_per_conv_only, 6950 from_timestamp_inc = 0, 6951 to_timestamp_exc = skypekit.MAX_UINT 6952 ):
6953 """ 6954 Returns all messages of the given type 6955 6956 B{Arguments:} 6957 - B{type_} - Type of messages requested. For POSTED_TEXT or POSTED_EMOTE, returns a list with both types 6958 - B{latest_per_conv_only} - Whether to return only the most recent message per conversation 6959 - B{from_timestamp_inc} - Starting timestamp for reqested range, inclusive 6960 - B{to_timestamp_exc} - Ending timestamp for requested range, exclusive 6961 6962 B{Return values:} 6963 - B{messages} 6964 """ 6965 l_request = skypekit.XCallRequest("ZR\000\210\001", 0, 136) 6966 l_request.add_parm('e', 1, Message.TYPE[type_]) 6967 l_request.add_parm('b', 2, latest_per_conv_only) 6968 l_request.add_parm('u', 3, from_timestamp_inc) 6969 l_request.add_parm('u', 4, to_timestamp_exc) 6970 l_response = self.transport.xcall(l_request) 6971 l_result = [module_id2classes[9](oid, self.transport) for oid in l_response.get(1, [])] 6972 return l_result
6973 - def OnMessage( 6974 self, 6975 message, 6976 changes_inbox_timestamp, 6977 supersedes_history_message, 6978 conversation 6979 ):
6980 """ 6981 No description available. 6982 6983 B{Return values:} 6984 - B{message} 6985 - B{changes_inbox_timestamp} - if changesInboxTimestamp==true is a hint that tray alert should probably be displayed 6986 - B{supersedes_history_message} - DEPRECATED, not set anymore 6987 - B{conversation} 6988 """ 6989 pass
6990 event_handlers[5] = "_sk_on_message"
6991 - def _sk_on_message(self, parms):
6992 """ internal event dispatcher for OnMessage """ 6993 l_cleanparms = (module_id2classes[9](parms.get(1), self.transport)), 6994 l_cleanparms += (parms.get(2, False)), 6995 l_cleanparms += (module_id2classes[9](parms.get(3), self.transport)), 6996 l_cleanparms += (module_id2classes[18](parms.get(4), self.transport)), 6997 self.OnMessage(*l_cleanparms) 6998 l_cleanparms[3].OnMessage(l_cleanparms[0])
6999 - def GetAvailableVideoDevices(self):
7000 """ 7001 This method returns a table in form of two string lists of equal length and an uint argument that returns the count of items i both lists. The first list contains video recording device handles and the second list descriptive names of those devices. NB! This method requires videortphost to be running, otherwise it will return empty lists. 7002 7003 7004 B{Return values:} 7005 - B{device_names} 7006 - B{device_paths} 7007 - B{count} 7008 """ 7009 l_request = skypekit.XCallRequest("ZR\000P", 0, 80) 7010 l_response = self.transport.xcall(l_request) 7011 l_result = (l_response.get(1, [])), 7012 l_result += (l_response.get(2, [])), 7013 l_result += (l_response.get(3, 0)), 7014 return l_result
7015 - def HasVideoDeviceCapability( 7016 self, 7017 device_name, 7018 device_path, 7019 cap 7020 ):
7021 """ 7022 Queries whether the given video device has a specific Video::VIDEO_DEVICE_CAPABILITY. Use Skype::GetAvailableVideoDevices method to retrieve sstring lists with available deviceName and devicePath values. 7023 7024 7025 B{Arguments:} 7026 - B{device_name} - Human readable device name. 7027 7028 - B{device_path} - Device ID. 7029 7030 - B{cap} - Any of the Video::VIDEO_DEVICE_CAPABILITY values. 7031 7032 7033 B{Return values:} 7034 - B{result} 7035 """ 7036 l_request = skypekit.XCallRequest("ZR\000!", 0, 33) 7037 l_request.add_parm('S', 1, device_name) 7038 l_request.add_parm('S', 2, device_path) 7039 l_request.add_parm('e', 3, Video.VIDEO_DEVICE_CAPABILITY[cap]) 7040 l_response = self.transport.xcall(l_request) 7041 l_result = l_response.get(1, False) 7042 return l_result
7043 - def DisplayVideoDeviceTuningDialog( 7044 self, 7045 device_name, 7046 device_path 7047 ):
7048 """ 7049 No description available. 7050 7051 B{Arguments:} 7052 - B{device_name} 7053 - B{device_path} 7054 """ 7055 l_request = skypekit.XCallRequest("ZR\000\042", 0, 34) 7056 l_request.add_parm('S', 1, device_name) 7057 l_request.add_parm('S', 2, device_path) 7058 self.transport.xcall(l_request)
7059 - def GetPreviewVideo( 7060 self, 7061 type_, 7062 device_name = "", 7063 device_path = "" 7064 ):
7065 """ 7066 Warning: Will be deprecated soon 7067 7068 B{Arguments:} 7069 - B{type_} 7070 - B{device_name} - name and path to be used only with media type VIDEO 7071 - B{device_path} 7072 7073 B{Return values:} 7074 - B{video} 7075 """ 7076 l_request = skypekit.XCallRequest("ZR\000#", 0, 35) 7077 l_request.add_parm('e', 1, Video.MEDIATYPE[type_]) 7078 l_request.add_parm('S', 2, device_name) 7079 l_request.add_parm('S', 3, device_path) 7080 l_response = self.transport.xcall(l_request) 7081 l_result = module_id2classes[11](l_response.get(1), self.transport) 7082 return l_result
7083 - def VideoCommand( 7084 self, 7085 command 7086 ):
7087 """ 7088 Avaible to Video Engines using the Video RTP API 7089 7090 B{Arguments:} 7091 - B{command} 7092 7093 B{Return values:} 7094 - B{response} 7095 """ 7096 l_request = skypekit.XCallRequest("ZR\000;", 0, 59) 7097 l_request.add_parm('S', 1, command) 7098 l_response = self.transport.xcall(l_request) 7099 l_result = l_response.get(1, '') 7100 return l_result
7102 """ 7103 This callback gets fired when there are changes in the system video device list (USB webcam gets plugged in or is detached.) 7104 7105 """ 7106 pass
7108 """ internal event dispatcher for OnAvailableVideoDeviceListChange """ 7109 self.OnAvailableVideoDeviceListChange()
7110 event_handlers[7] = "_sk_on_available_video_device_list_change"
7111 - def OnH264Activated(self):
7112 """ 7113 Event is implemented only in SkypeKit builds. Fired when Skype video library uses software H264 codec for the first time on the particular hardware by particular SkypeKit-based application 7114 """ 7115 pass
7116 - def _sk_on_h264activated(self, parms):
7117 """ internal event dispatcher for OnH264Activated """ 7118 self.OnH264Activated()
7119 event_handlers[44] = "_sk_on_h264activated" 7120 QUALITYTESTTYPE = {0:'QTT_AUDIO_IN', 'QTT_AUDIO_IN':0, 1:'QTT_AUDIO_OUT', 'QTT_AUDIO_OUT':1, 2:'QTT_VIDEO_OUT', 'QTT_VIDEO_OUT':2, 3:'QTT_CPU', 'QTT_CPU':3, 4:'QTT_NETWORK', 'QTT_NETWORK':4, 5:'QTT_VIDEO_IN', 'QTT_VIDEO_IN':5} 7121 """ 7122 - QTT_AUDIO_IN 7123 - QTT_AUDIO_OUT 7124 - QTT_VIDEO_OUT 7125 - QTT_CPU 7126 - QTT_NETWORK 7127 - QTT_VIDEO_IN 7128 """ 7129 QUALITYTESTRESULT = {0:'QTR_UNDEFINED', 'QTR_UNDEFINED':0, 1:'QTR_CRITICAL', 'QTR_CRITICAL':1, 2:'QTR_POOR', 'QTR_POOR':2, 3:'QTR_AVERAGE', 'QTR_AVERAGE':3, 4:'QTR_GOOD', 'QTR_GOOD':4, 5:'QTR_EXCELLENT', 'QTR_EXCELLENT':5} 7130 """ 7131 - QTR_UNDEFINED 7132 - QTR_CRITICAL 7133 - QTR_POOR 7134 - QTR_AVERAGE 7135 - QTR_GOOD 7136 - QTR_EXCELLENT 7137 """
7138 - def StartMonitoringQuality( 7139 self, 7140 with_user, 7141 exclude_network_test 7142 ):
7143 """ 7144 No description available. 7145 7146 B{Arguments:} 7147 - B{with_user} - if empty, network test results would reflect status of local node only 7148 - B{exclude_network_test} 7149 """ 7150 l_request = skypekit.XCallRequest("ZR\000\214\001", 0, 140) 7151 l_request.add_parm('S', 1, with_user) 7152 l_request.add_parm('b', 2, exclude_network_test) 7153 self.transport.xcall(l_request)
7154 - def StopMonitoringQuality( 7155 self, 7156 with_user, 7157 just_stop = False 7158 ):
7159 """ 7160 No description available. 7161 7162 B{Arguments:} 7163 - B{with_user} 7164 - B{just_stop} 7165 7166 B{Return values:} 7167 - B{result} 7168 """ 7169 l_request = skypekit.XCallRequest("ZR\000\215\001", 0, 141) 7170 l_request.add_parm('S', 1, with_user) 7171 l_request.add_parm('b', 2, just_stop) 7172 l_response = self.transport.xcall(l_request) 7173 l_result = skypekit.enumof(Skype.QUALITYTESTRESULT, l_response.get(1)) 7174 return l_result
7175 - def OnQualityTestResult( 7176 self, 7177 test_type, 7178 test_result, 7179 with_user, 7180 details, 7181 xml_details 7182 ):
7183 """ 7184 No description available. 7185 7186 B{Return values:} 7187 - B{test_type} 7188 - B{test_result} 7189 - B{with_user} 7190 - B{details} 7191 - B{xml_details} 7192 """ 7193 pass
7194 event_handlers[28] = "_sk_on_quality_test_result"
7195 - def _sk_on_quality_test_result(self, parms):
7196 """ internal event dispatcher for OnQualityTestResult """ 7197 l_cleanparms = (Skype.QUALITYTESTTYPE[parms.get(0)]), 7198 l_cleanparms += (Skype.QUALITYTESTRESULT[parms.get(1)]), 7199 l_cleanparms += (parms.get(2, '')), 7200 l_cleanparms += (parms.get(3, '')), 7201 l_cleanparms += (parms.get(4, '')), 7202 self.OnQualityTestResult(*l_cleanparms)
7203 - def GetGreeting( 7204 self, 7205 skype_name 7206 ):
7207 """ 7208 No description available. 7209 7210 B{Arguments:} 7211 - B{skype_name} 7212 7213 B{Return values:} 7214 - B{greeting} 7215 """ 7216 l_request = skypekit.XCallRequest("ZR\000-", 0, 45) 7217 l_request.add_parm('S', 1, skype_name) 7218 l_response = self.transport.xcall(l_request) 7219 l_result = module_id2classes[7](l_response.get(1), self.transport) 7220 return l_result
7221 SETUPKEY_DISABLED_CODECS = "*Lib/Audio/DisableCodecs" 7222 SETUPKEY_DISABLE_AEC = "*Lib/Audio/DisableAEC" 7223 SETUPKEY_DISABLE_NOISE_SUPPRESSOR = "*Lib/Audio/DisableNS" 7224 SETUPKEY_DISABLE_AGC = "*Lib/Audio/DisableAGC" 7225 SETUPKEY_DISABLE_DIGITAL_NEAR_END_AGC = "*Lib/Audio/DisableDigitalNearEndAGC" 7226 SETUPKEY_DISABLE_DIGITAL_FAR_END_AGC = "*Lib/Audio/DisableDigitalFarEndAGC" 7227 SETUPKEY_BEAMFORMER_MIC_SPACING = "*Lib/Audio/BeamformerMicSpacing" 7228 SETUPKEY_DISABLE_AUDIO_DEVICE_PROBING = "*Lib/QualityMonitor/DisableAudioDeviceProbing" 7229 PREPARESOUNDRESULT = {0:'PREPARESOUND_SUCCESS', 'PREPARESOUND_SUCCESS':0, 1:'PREPARESOUND_MISC_ERROR', 'PREPARESOUND_MISC_ERROR':1, 2:'PREPARESOUND_FILE_NOT_FOUND', 'PREPARESOUND_FILE_NOT_FOUND':2, 3:'PREPARESOUND_FILE_TOO_BIG', 'PREPARESOUND_FILE_TOO_BIG':3, 4:'PREPARESOUND_FILE_READ_ERROR', 'PREPARESOUND_FILE_READ_ERROR':4, 5:'PREPARESOUND_UNSUPPORTED_FILE_FORMAT', 'PREPARESOUND_UNSUPPORTED_FILE_FORMAT':5, 6:'PREPARESOUND_PLAYBACK_NOT_SUPPORTED', 'PREPARESOUND_PLAYBACK_NOT_SUPPORTED':6} 7230 """ 7231 - PREPARESOUND_SUCCESS 7232 - PREPARESOUND_MISC_ERROR 7233 - PREPARESOUND_FILE_NOT_FOUND 7234 - PREPARESOUND_FILE_TOO_BIG 7235 - PREPARESOUND_FILE_READ_ERROR 7236 - PREPARESOUND_UNSUPPORTED_FILE_FORMAT 7237 - PREPARESOUND_PLAYBACK_NOT_SUPPORTED 7238 """ 7239 AUDIODEVICE_CAPABILITIES = { 7240 1 :'HAS_VIDEO_CAPTURE', 7241 2 :'HAS_USB_INTERFACE', 7242 4 :'POSSIBLY_HEADSET', 7243 8 :'HAS_AUDIO_CAPTURE', 7244 16 :'HAS_AUDIO_RENDERING', 7245 32 :'HAS_LOWBANDWIDTH_CAPTURE', 7246 64 :'IS_WEBCAM', 7247 128 :'IS_HEADSET', 7248 256 :'POSSIBLY_WEBCAM', 7249 2048:'HAS_VIDEO_RENDERING', 7250 4096:'HAS_BLUETOOTH_INTERFACE', 7251 'HAS_VIDEO_CAPTURE' : 1, 7252 'HAS_USB_INTERFACE' : 2, 7253 'POSSIBLY_HEADSET' : 4, 7254 'HAS_AUDIO_CAPTURE' : 8, 7255 'HAS_AUDIO_RENDERING' : 16, 7256 'HAS_LOWBANDWIDTH_CAPTURE' : 32, 7257 'IS_WEBCAM' : 64, 7258 'IS_HEADSET' : 128, 7259 'POSSIBLY_WEBCAM' : 256, 7260 'HAS_VIDEO_RENDERING' :2048, 7261 'HAS_BLUETOOTH_INTERFACE' :4096 7262 } 7263 """ 7264 - HAS_VIDEO_CAPTURE 7265 - HAS_USB_INTERFACE 7266 - POSSIBLY_HEADSET 7267 - HAS_AUDIO_CAPTURE 7268 - HAS_AUDIO_RENDERING 7269 - HAS_LOWBANDWIDTH_CAPTURE 7270 - IS_WEBCAM 7271 - IS_HEADSET 7272 - POSSIBLY_WEBCAM 7273 - HAS_VIDEO_RENDERING 7274 - HAS_BLUETOOTH_INTERFACE 7275 """
7276 - def PlayStart( 7277 self, 7278 soundid, 7279 sound, 7280 loop, 7281 use_call_out_device = False 7282 ):
7283 """ 7284 Takes audio data that comes from the sound argument and mixes it into playback or notification device, depending on the value passed in the useCallOutDevice argument. The sound argument contains the audio data in in follwing format: first 4 bytes of the binary contain the sample rate, followed by 16 bit (mono) samples. The soundid argument is an arbitrary ID that you can pass in and then later use as an argument for Skype class PlayStop method. To mix the audio into playback device stream, set useCallOutDevice to true, to mic it into notification stream, set useCallOutDevice to false. 7285 7286 7287 B{Arguments:} 7288 - B{soundid} 7289 - B{sound} 7290 - B{loop} 7291 - B{use_call_out_device} 7292 """ 7293 l_request = skypekit.XCallRequest("ZR\000\060", 0, 48) 7294 l_request.add_parm('u', 1, soundid) 7295 l_request.add_parm('B', 2, sound) 7296 l_request.add_parm('b', 3, loop) 7297 l_request.add_parm('b', 4, use_call_out_device) 7298 self.transport.xcall(l_request)
7299 - def PlayStartFromFile( 7300 self, 7301 soundid, 7302 datafile, 7303 loop, 7304 use_call_out_device = False 7305 ):
7306 """ 7307 No description available. 7308 7309 B{Arguments:} 7310 - B{soundid} 7311 - B{datafile} 7312 - B{loop} 7313 - B{use_call_out_device} 7314 7315 B{Return values:} 7316 - B{result} 7317 """ 7318 l_request = skypekit.XCallRequest("ZR\000\324\001", 0, 212) 7319 l_request.add_parm('u', 1, soundid) 7320 l_request.add_parm('f', 2, datafile) 7321 l_request.add_parm('b', 3, loop) 7322 l_request.add_parm('b', 4, use_call_out_device) 7323 l_response = self.transport.xcall(l_request) 7324 l_result = skypekit.enumof(Skype.PREPARESOUNDRESULT, l_response.get(1)) 7325 return l_result
7326 - def PlayStop( 7327 self, 7328 soundid 7329 ):
7330 """ 7331 Stops playback of the soundfile. The argument is the same ID you passed in the Skype class StartPlayback method. 7332 7333 7334 B{Arguments:} 7335 - B{soundid} 7336 """ 7337 l_request = skypekit.XCallRequest("ZR\000\061", 0, 49) 7338 l_request.add_parm('u', 1, soundid) 7339 self.transport.xcall(l_request)
7340 - def StartRecordingTest( 7341 self, 7342 record_and_playback_data = False 7343 ):
7344 """ 7345 No description available. 7346 7347 B{Arguments:} 7348 - B{record_and_playback_data} 7349 """ 7350 l_request = skypekit.XCallRequest("ZR\000\062", 0, 50) 7351 l_request.add_parm('b', 1, record_and_playback_data) 7352 self.transport.xcall(l_request)
7353 - def StopRecordingTest(self):
7354 """ 7355 No description available. 7356 """ 7357 l_request = skypekit.XCallRequest("ZR\000\063", 0, 51) 7358 self.transport.xcall(l_request)
7359 - def GetAvailableOutputDevices(self):
7360 """ 7361 This method returns a table in form of three string lists of equal lengths. The first list contains audio output device handles ('hw:0,0', 'hw:0,1', etc.) The second list contains descriptive names of those devices (Ensoniq AudioPCI etc.) The third list contains device product IDs. Note that the values in these lists depend on which audio engine you are running (SAL, PCM, RTP). 7362 7363 7364 B{Return values:} 7365 - B{handle_list} 7366 - B{name_list} 7367 - B{product_id_list} 7368 """ 7369 l_request = skypekit.XCallRequest("ZR\000\065", 0, 53) 7370 l_response = self.transport.xcall(l_request) 7371 l_result = (l_response.get(1, [])), 7372 l_result += (l_response.get(2, [])), 7373 l_result += (l_response.get(3, [])), 7374 return l_result
7376 """ 7377 This method returns a table in form of three string lists of equal length. The first list contains audio recording device handles ('hw:0,0', 'hw:0,1', etc.) The second list contains descriptive names of those devices (Ensoniq AudioPCI etc.) The third list contains device product IDs. Note that the values in these lists depend on which audio engine you are running (SAL, PCM, RTP). 7378 7379 7380 B{Return values:} 7381 - B{handle_list} 7382 - B{name_list} 7383 - B{product_id_list} 7384 """ 7385 l_request = skypekit.XCallRequest("ZR\000\066", 0, 54) 7386 l_response = self.transport.xcall(l_request) 7387 l_result = (l_response.get(1, [])), 7388 l_result += (l_response.get(2, [])), 7389 l_result += (l_response.get(3, [])), 7390 return l_result
7391 - def SelectSoundDevices( 7392 self, 7393 call_in_device, 7394 call_out_device, 7395 wave_out_device 7396 ):
7397 """ 7398 Sets audio devices given in arguments as active audio devices. This command selects all three devices - microphone, playback and the notification channel. Valid input values for this method come from the first string list you get back from Skype class GetAvailableOutputDevices (handleList). 7399 7400 7401 B{Arguments:} 7402 - B{call_in_device} 7403 - B{call_out_device} 7404 - B{wave_out_device} 7405 """ 7406 l_request = skypekit.XCallRequest("ZR\000\067", 0, 55) 7407 l_request.add_parm('S', 1, call_in_device) 7408 l_request.add_parm('S', 2, call_out_device) 7409 l_request.add_parm('S', 3, wave_out_device) 7410 self.transport.xcall(l_request)
7411 - def GetAudioDeviceCapabilities( 7412 self, 7413 device_handle 7414 ):
7415 """ 7416 The uint argument returns AUDIODEVICE_CAPABILITIES (declared in Skype class) 7417 7418 7419 B{Arguments:} 7420 - B{device_handle} 7421 7422 B{Return values:} 7423 - B{interface_string} 7424 - B{capabilities} - bit set of AUDIODEVICE_CAPABILITIES 7425 """ 7426 l_request = skypekit.XCallRequest("ZR\000\070", 0, 56) 7427 l_request.add_parm('S', 1, device_handle) 7428 l_response = self.transport.xcall(l_request) 7429 l_result = (l_response.get(1, '')), 7430 l_result += (l_response.get(2, 0)), 7431 return l_result
7432 - def GetNrgLevels(self):
7433 """ 7434 Returns current audio stream volume for both playback and microphone streams. Useful for displaying visual audio indicators in you UI. See also Skype class OnNrgLevelsChange callback that gets fired each time the these values are changed. 7435 7436 7437 B{Return values:} 7438 - B{mic_level} 7439 - B{speaker_level} 7440 """ 7441 l_request = skypekit.XCallRequest("ZR\000\071", 0, 57) 7442 l_response = self.transport.xcall(l_request) 7443 l_result = (l_response.get(1, 0)), 7444 l_result += (l_response.get(2, 0)), 7445 return l_result
7446 - def VoiceCommand( 7447 self, 7448 command 7449 ):
7450 """ 7451 NB! This command only works if its implemented in external audiohost (RTP or PCM host). The command can be is used for passing custom commands from client UI to the audio implementation. 7452 7453 7454 B{Arguments:} 7455 - B{command} 7456 7457 B{Return values:} 7458 - B{response} 7459 """ 7460 l_request = skypekit.XCallRequest("ZR\000:", 0, 58) 7461 l_request.add_parm('S', 1, command) 7462 l_response = self.transport.xcall(l_request) 7463 l_result = l_response.get(1, '') 7464 return l_result
7465 - def GetSpeakerVolume(self):
7466 """ 7467 Returns value of audio playback volume setting (0..100). 7468 7469 7470 B{Return values:} 7471 - B{volume} 7472 """ 7473 l_request = skypekit.XCallRequest("ZR\000<", 0, 60) 7474 l_response = self.transport.xcall(l_request) 7475 l_result = l_response.get(1, 0) 7476 return l_result
7477 - def SetSpeakerVolume( 7478 self, 7479 volume 7480 ):
7481 """ 7482 This method is for setting speaker volume. It will set the level for Skype digital gain control. Skype audio library will not control gain of audio device itself. 7483 7484 7485 B{Arguments:} 7486 - B{volume} 7487 """ 7488 l_request = skypekit.XCallRequest("ZR\000=", 0, 61) 7489 l_request.add_parm('u', 1, volume) 7490 self.transport.xcall(l_request)
7491 - def GetMicVolume(self):
7492 """ 7493 Returns value of microphone volume setting (0..100). It will return the analog gain of audio device set by Skype AGC. For real-time microphone volume, use GetNrgLevels method or OnNrgLevelsChange callback (both are methods of Skype class). 7494 7495 7496 B{Return values:} 7497 - B{mic_volume} 7498 """ 7499 l_request = skypekit.XCallRequest("ZR\000>", 0, 62) 7500 l_response = self.transport.xcall(l_request) 7501 l_result = l_response.get(1, 0) 7502 return l_result
7503 - def SetMicVolume( 7504 self, 7505 volume 7506 ):
7507 """ 7508 This method is for setting the microphone volume level. This does not work when Skype AGC (Automatic Gain Control) is enabled, which it is by default. It is currently impossible to disable AGC, so for now this method is here for purpose of future compatibility. 7509 7510 7511 B{Arguments:} 7512 - B{volume} 7513 """ 7514 l_request = skypekit.XCallRequest("ZR\000?", 0, 63) 7515 l_request.add_parm('u', 1, volume) 7516 self.transport.xcall(l_request)
7517 - def IsSpeakerMuted(self):
7518 """ 7519 Returns true in &muted argument if the currently selected playback device is muted. 7520 7521 7522 B{Return values:} 7523 - B{muted} 7524 """ 7525 l_request = skypekit.XCallRequest("ZR\000@", 0, 64) 7526 l_response = self.transport.xcall(l_request) 7527 l_result = l_response.get(1, False) 7528 return l_result
7529 - def IsMicrophoneMuted(self):
7530 """ 7531 Returns true in &muted argument if the currently selected microphone is muted. 7532 7533 7534 B{Return values:} 7535 - B{muted} 7536 """ 7537 l_request = skypekit.XCallRequest("ZR\000\101", 0, 65) 7538 l_response = self.transport.xcall(l_request) 7539 l_result = l_response.get(1, False) 7540 return l_result
7541 - def MuteSpeakers( 7542 self, 7543 mute 7544 ):
7545 """ 7546 Sets currently selected playback device mute status according to argument. 7547 7548 7549 B{Arguments:} 7550 - B{mute} 7551 """ 7552 l_request = skypekit.XCallRequest("ZR\000\102", 0, 66) 7553 l_request.add_parm('b', 1, mute) 7554 self.transport.xcall(l_request)
7555 - def MuteMicrophone( 7556 self, 7557 mute 7558 ):
7559 """ 7560 Sets currently selected microphone mute status according to argument. 7561 7562 7563 B{Arguments:} 7564 - B{mute} 7565 """ 7566 l_request = skypekit.XCallRequest("ZR\000\103", 0, 67) 7567 l_request.add_parm('b', 1, mute) 7568 self.transport.xcall(l_request)
7570 """ 7571 This callback gets fired when there are changes in the system audio device list (USB headset gets plugged in or is detached.) 7572 7573 """ 7574 pass
7575 - def _sk_on_available_device_list_change(self, parms):
7576 """ internal event dispatcher for OnAvailableDeviceListChange """ 7577 self.OnAvailableDeviceListChange()
7578 event_handlers[10] = "_sk_on_available_device_list_change"
7579 - def OnNrgLevelsChange(self):
7580 """ 7581 This callback gets fired when the audio strength changes in either playback or recording audio streams. Useful for providing visual indicators of audio activity in your UI. 7582 7583 """ 7584 pass
7585 - def _sk_on_nrg_levels_change(self, parms):
7586 """ internal event dispatcher for OnNrgLevelsChange """ 7587 self.OnNrgLevelsChange()
7588 event_handlers[11] = "_sk_on_nrg_levels_change" 7589 OPERATING_MEDIA = {0:'OM_UNKNOWN', 'OM_UNKNOWN':0, 1:'OM_FREE', 'OM_FREE':1, 2:'OM_FREE_WIRELESS', 'OM_FREE_WIRELESS':2, 3:'OM_3G', 'OM_3G':3, 4:'OM_4G', 'OM_4G':4} 7590 """ 7591 - OM_UNKNOWN 7592 - OM_FREE 7593 - OM_FREE_WIRELESS 7594 - OM_3G 7595 - OM_4G 7596 """
7597 - def SetOperatingMedia( 7598 self, 7599 media, 7600 max_uplink_bps, 7601 max_downlink_bps 7602 ):
7603 """ 7604 No description available. 7605 7606 B{Arguments:} 7607 - B{media} 7608 - B{max_uplink_bps} 7609 - B{max_downlink_bps} 7610 """ 7611 l_request = skypekit.XCallRequest("ZR\000\377\001", 0, 255) 7612 l_request.add_parm('e', 1, Skype.OPERATING_MEDIA[media]) 7613 l_request.add_parm('u', 2, max_uplink_bps) 7614 l_request.add_parm('u', 3, max_downlink_bps) 7615 self.transport.xcall(l_request)
7616 - def RequestConfirmationCode( 7617 self, 7618 type_, 7619 number 7620 ):
7621 """ 7622 creates and sends a CONFIRMATION_CODE_REQUEST message this sends a confirmation code to the number provided 7623 7624 B{Arguments:} 7625 - B{type_} 7626 - B{number} 7627 7628 B{Return values:} 7629 - B{sms} 7630 """ 7631 l_request = skypekit.XCallRequest("ZR\000\035", 0, 29) 7632 l_request.add_parm('e', 1, Sms.CONFIRM_TYPE[type_]) 7633 l_request.add_parm('S', 2, number) 7634 l_response = self.transport.xcall(l_request) 7635 l_result = module_id2classes[12](l_response.get(1), self.transport) 7636 return l_result
7637 - def SubmitConfirmationCode( 7638 self, 7639 number, 7640 code 7641 ):
7642 """ 7643 creates and sends a CONFIRMATION_CODE_SUBMIT message this authorizes the number with the server for the purpose given in RequestConfirmationCode 7644 7645 B{Arguments:} 7646 - B{number} 7647 - B{code} 7648 7649 B{Return values:} 7650 - B{sms} 7651 """ 7652 l_request = skypekit.XCallRequest("ZR\000\036", 0, 30) 7653 l_request.add_parm('S', 1, number) 7654 l_request.add_parm('S', 2, code) 7655 l_response = self.transport.xcall(l_request) 7656 l_result = module_id2classes[12](l_response.get(1), self.transport) 7657 return l_result
7658 - def CreateOutgoingSms(self):
7659 """ 7660 creates an OUTGOING/COMPOSING SMS message 7661 7662 B{Return values:} 7663 - B{sms} 7664 """ 7665 l_request = skypekit.XCallRequest("ZR\000\106", 0, 70) 7666 l_response = self.transport.xcall(l_request) 7667 l_result = module_id2classes[12](l_response.get(1), self.transport) 7668 return l_result
7669 SETUPKEY_FT_AUTOACCEPT = "Lib/FileTransfer/AutoAccept" 7670 SETUPKEY_FT_SAVEPATH = "Lib/FileTransfer/SavePath" 7671 SETUPKEY_FT_INCOMING_LIMIT = "Lib/FileTransfer/IncomingLimit" 7672 SETUPKEY_IDLE_TIME_FOR_AWAY = "Lib/Account/IdleTimeForAway" 7673 SETUPKEY_IDLE_TIME_FOR_NA = "Lib/Account/IdleTimeForNA"
7674 - def GetAccount( 7675 self, 7676 identity 7677 ):
7678 """ 7679 Retrieves an Account object by Skype name (identity). This should normally be one of the first method calls after Skype object initialization. Nearly all the other methods require successful account login in order to work properly. The list of accounts that have been used on the local machine/database can be retrieved with Skype::GetExistingAccounts method. If a matching identity is not found, a new Account object is created. This object can then be used to populate requred fields and then use Account::Register method for new account creation. This method returns false on error. 7680 7681 7682 B{Arguments:} 7683 - B{identity} - Account skypename. 7684 7685 7686 B{Return values:} 7687 - B{account} - Returns account object if successful. 7688 7689 """ 7690 l_request = skypekit.XCallRequest("ZR\000s", 0, 115) 7691 l_request.add_parm('S', 1, identity) 7692 l_response = self.transport.xcall(l_request) 7693 l_result = module_id2classes[5](l_response.get(1), self.transport) 7694 return l_result
7695 - def GetExistingAccounts(self):
7696 """ 7697 Returns a list of possible profiles used before on this machine 7698 7699 B{Return values:} 7700 - B{account_name_list} 7701 """ 7702 l_request = skypekit.XCallRequest("ZR\000q", 0, 113) 7703 l_response = self.transport.xcall(l_request) 7704 l_result = l_response.get(1, []) 7705 return l_result
7706 - def GetDefaultAccountName(self):
7707 """ 7708 return most recently used account that has pwd saved. empty string if none 7709 7710 B{Return values:} 7711 - B{account} 7712 """ 7713 l_request = skypekit.XCallRequest("ZR\000r", 0, 114) 7714 l_response = self.transport.xcall(l_request) 7715 l_result = l_response.get(1, '') 7716 return l_result
7717 - def GetSuggestedSkypename( 7718 self, 7719 fullname 7720 ):
7721 """ 7722 suggest a nice skypename to go with given fullname 7723 7724 B{Arguments:} 7725 - B{fullname} 7726 7727 B{Return values:} 7728 - B{suggested_name} 7729 """ 7730 l_request = skypekit.XCallRequest("ZR\000t", 0, 116) 7731 l_request.add_parm('S', 1, fullname) 7732 l_response = self.transport.xcall(l_request) 7733 l_result = l_response.get(1, '') 7734 return l_result
7735 VALIDATERESULT = { 7736 0 :'NOT_VALIDATED', 7737 1 :'VALIDATED_OK', 7738 2 :'TOO_SHORT', 7739 3 :'TOO_LONG', 7740 4 :'CONTAINS_INVALID_CHAR', 7741 5 :'CONTAINS_SPACE', 7742 6 :'SAME_AS_USERNAME', 7743 7 :'INVALID_FORMAT', 7744 8 :'CONTAINS_INVALID_WORD', 7745 9 :'TOO_SIMPLE', 7746 10:'STARTS_WITH_INVALID_CHAR', 7747 'NOT_VALIDATED' : 0, 7748 'VALIDATED_OK' : 1, 7749 'TOO_SHORT' : 2, 7750 'TOO_LONG' : 3, 7751 'CONTAINS_INVALID_CHAR' : 4, 7752 'CONTAINS_SPACE' : 5, 7753 'SAME_AS_USERNAME' : 6, 7754 'INVALID_FORMAT' : 7, 7755 'CONTAINS_INVALID_WORD' : 8, 7756 'TOO_SIMPLE' : 9, 7757 'STARTS_WITH_INVALID_CHAR' :10 7758 } 7759 """ 7760 A value of this type can be returned by one of the following methods (of Skype class): ValidateAvatar, ValidateProfileString, ValidatePassword. 7761 7762 - NOT_VALIDATED - Given property could not be validated. The length of the field was within limits and the value is assumed to be Ok. Your client should treat this value as equivalent to VALIDATED_OK. 7763 7764 - VALIDATED_OK - Avatar or profile string validation succeeded. 7765 7766 - TOO_SHORT - Password is too short. 7767 7768 - TOO_LONG - The value exceeds max size limit for the given property. 7769 7770 - CONTAINS_INVALID_CHAR - Value contains illegal characters. 7771 7772 - CONTAINS_SPACE - Value contains whitespace. 7773 7774 - SAME_AS_USERNAME - Password cannot be the same as skypename. 7775 7776 - INVALID_FORMAT - Value has invalid format. 7777 7778 - CONTAINS_INVALID_WORD - Value contains invalid word. 7779 7780 - TOO_SIMPLE - Password is too simple. 7781 7782 - STARTS_WITH_INVALID_CHAR - Value starts with an invalid character. 7783 7784 """
7785 - def ValidateAvatar( 7786 self, 7787 value 7788 ):
7789 """ 7790 No description available. 7791 7792 B{Arguments:} 7793 - B{value} 7794 7795 B{Return values:} 7796 - B{result} 7797 - B{free_bytes_left} 7798 """ 7799 l_request = skypekit.XCallRequest("ZR\000w", 0, 119) 7800 l_request.add_parm('B', 1, value) 7801 l_response = self.transport.xcall(l_request) 7802 l_result = (skypekit.enumof(Skype.VALIDATERESULT, l_response.get(1))), 7803 l_result += (l_response.get(2, 0)), 7804 return l_result
7805 - def ValidateProfileString( 7806 self, 7807 prop_key, 7808 str_value, 7809 for_registration = False 7810 ):
7811 """ 7812 This method should be used for validating skypenames before registering new accounts, if the propKey is set to SKYPENAME (Contact class) and forRegistration argument is set to true. If the forRegistration argument is false, only string length check is applied. It is also useful to probe, what the size limits are, for each string property (e.g. 300 characters for moodmessage) 7813 7814 7815 B{Arguments:} 7816 - B{prop_key} 7817 - B{str_value} 7818 - B{for_registration} 7819 7820 B{Return values:} 7821 - B{result} 7822 - B{free_bytes_left} 7823 """ 7824 l_request = skypekit.XCallRequest("ZR\000f", 0, 102) 7825 l_request.add_parm('e', 1, prop_key) 7826 l_request.add_parm('S', 2, str_value) 7827 l_request.add_parm('b', 3, for_registration) 7828 l_response = self.transport.xcall(l_request) 7829 l_result = (skypekit.enumof(Skype.VALIDATERESULT, l_response.get(1))), 7830 l_result += (l_response.get(2, 0)), 7831 return l_result
7832 - def ValidatePassword( 7833 self, 7834 username, 7835 password 7836 ):
7837 """ 7838 This method is for pre-validating account passwords before account creation or password change. The result will return either VALIDATED_OK or one of many possible reasons the password is unacceptable (too short, too simple, etc.) 7839 7840 7841 B{Arguments:} 7842 - B{username} 7843 - B{password} 7844 7845 B{Return values:} 7846 - B{result} 7847 """ 7848 l_request = skypekit.XCallRequest("ZR\000G", 0, 71) 7849 l_request.add_parm('S', 1, username) 7850 l_request.add_parm('S', 2, password) 7851 l_response = self.transport.xcall(l_request) 7852 l_result = skypekit.enumof(Skype.VALIDATERESULT, l_response.get(1)) 7853 return l_result
7854 SETUPKEY_PORT = "*Lib/Connection/Port" 7855 SETUPKEY_HTTPS_PROXY_ENABLE = "*Lib/Connection/HttpsProxy/Enable" 7856 SETUPKEY_HTTPS_PROXY_ADDR = "*Lib/Connection/HttpsProxy/Addr" 7857 SETUPKEY_HTTPS_PROXY_USER = "*Lib/Connection/HttpsProxy/User" 7858 SETUPKEY_HTTPS_PROXY_PWD = "*Lib/Connection/HttpsProxy/Pwd" 7859 SETUPKEY_SOCKS_PROXY_ENABLE = "*Lib/Connection/SocksProxy/Enable" 7860 SETUPKEY_SOCKS_PROXY_ADDR = "*Lib/Connection/SocksProxy/Addr" 7861 SETUPKEY_SOCKS_PROXY_USER = "*Lib/Connection/SocksProxy/User" 7862 SETUPKEY_SOCKS_PROXY_PWD = "*Lib/Connection/SocksProxy/Pwd" 7863 SETUPKEY_LOCALADDRESS = "*Lib/Connection/LocalAddress" 7864 SETUPKEY_DISABLE_PORT80 = "*Lib/Connection/DisablePort80" 7865 SETUPKEY_DISABLE_UDP = "*Lib/Connection/DisableUDP" 7866 PROXYTYPE = {0:'HTTPS_PROXY', 'HTTPS_PROXY':0, 1:'SOCKS_PROXY', 'SOCKS_PROXY':1} 7867 """ 7868 - HTTPS_PROXY 7869 - SOCKS_PROXY 7870 """
7871 - def OnProxyAuthFailure( 7872 self, 7873 type_ 7874 ):
7875 """ 7876 No description available. 7877 7878 B{Return values:} 7879 - B{type_} 7880 """ 7881 pass
7882 event_handlers[12] = "_sk_on_proxy_auth_failure"
7883 - def _sk_on_proxy_auth_failure(self, parms):
7884 """ internal event dispatcher for OnProxyAuthFailure """ 7885 l_cleanparms = Skype.PROXYTYPE[parms.get(1)] 7886 self.OnProxyAuthFailure(l_cleanparms)
7887 - def GetUsedPort(self):
7888 """ 7889 port that lib ended up listening. usually equal to SETUPKEY_PORT. 0 if none used (disconnected or binding failed) 7890 7891 B{Return values:} 7892 - B{port} 7893 """ 7894 l_request = skypekit.XCallRequest("ZR\000\202\001", 0, 130) 7895 l_response = self.transport.xcall(l_request) 7896 l_result = l_response.get(1, 0) 7897 return l_result
7898 - def GetStr( 7899 self, 7900 key 7901 ):
7902 """ 7903 This is used for retrieving local setup keys of type string. For more information, see Defines section in the skype-embedded_2.h 7904 7905 7906 B{Arguments:} 7907 - B{key} 7908 7909 B{Return values:} 7910 - B{value} 7911 """ 7912 l_request = skypekit.XCallRequest("ZR\000x", 0, 120) 7913 l_request.add_parm('S', 1, key) 7914 l_response = self.transport.xcall(l_request) 7915 l_result = l_response.get(1, '') 7916 return l_result
7917 - def GetInt( 7918 self, 7919 key 7920 ):
7921 """ 7922 This is used for retrieving local setup keys of type int. For more information, see Defines section in the skype-embedded_2.h 7923 7924 7925 B{Arguments:} 7926 - B{key} 7927 7928 B{Return values:} 7929 - B{value} 7930 """ 7931 l_request = skypekit.XCallRequest("ZR\000y", 0, 121) 7932 l_request.add_parm('S', 1, key) 7933 l_response = self.transport.xcall(l_request) 7934 l_result = l_response.get(1, 0) 7935 return l_result
7936 - def GetBin( 7937 self, 7938 key 7939 ):
7940 """ 7941 This is used for retrieving local setup keys of type binary. For more information, see Defines section in the skype-embedded_2.h 7942 7943 7944 B{Arguments:} 7945 - B{key} 7946 7947 B{Return values:} 7948 - B{value} 7949 """ 7950 l_request = skypekit.XCallRequest("ZR\000z", 0, 122) 7951 l_request.add_parm('S', 1, key) 7952 l_response = self.transport.xcall(l_request) 7953 l_result = l_response.get(1, '') 7954 return l_result
7955 - def SetStr( 7956 self, 7957 key, 7958 value 7959 ):
7960 """ 7961 This is used for setting local setup keys of type string. For more information, see Defines section in the skype-embedded_2.h 7962 7963 7964 B{Arguments:} 7965 - B{key} 7966 - B{value} 7967 """ 7968 l_request = skypekit.XCallRequest("ZR\000{", 0, 123) 7969 l_request.add_parm('S', 1, key) 7970 l_request.add_parm('S', 2, value) 7971 self.transport.xcall(l_request)
7972 - def SetInt( 7973 self, 7974 key, 7975 value 7976 ):
7977 """ 7978 This is used for setting local setup keys of type int. For more information, see Defines section in the skype-embedded_2.h 7979 7980 7981 B{Arguments:} 7982 - B{key} 7983 - B{value} 7984 """ 7985 l_request = skypekit.XCallRequest("ZR\000|", 0, 124) 7986 l_request.add_parm('S', 1, key) 7987 l_request.add_parm('i', 2, value) 7988 self.transport.xcall(l_request)
7989 - def SetBin( 7990 self, 7991 key, 7992 value 7993 ):
7994 """ 7995 This is used for setting local setup keys of type binary. For more information, see Defines section in the skype-embedded_2.h 7996 7997 7998 B{Arguments:} 7999 - B{key} 8000 - B{value} 8001 """ 8002 l_request = skypekit.XCallRequest("ZR\000}", 0, 125) 8003 l_request.add_parm('S', 1, key) 8004 l_request.add_parm('B', 2, value) 8005 self.transport.xcall(l_request)
8006 - def IsDefined( 8007 self, 8008 key 8009 ):
8010 """ 8011 Returns true if the given setup key is defined in local setup. For more information, see Defines section in the skype-embedded_2.h 8012 8013 8014 B{Arguments:} 8015 - B{key} 8016 8017 B{Return values:} 8018 - B{value} 8019 """ 8020 l_request = skypekit.XCallRequest("ZR\000~", 0, 126) 8021 l_request.add_parm('S', 1, key) 8022 l_response = self.transport.xcall(l_request) 8023 l_result = l_response.get(1, False) 8024 return l_result
8025 - def Delete( 8026 self, 8027 key 8028 ):
8029 """ 8030 No description available. 8031 8032 B{Arguments:} 8033 - B{key} 8034 """ 8035 l_request = skypekit.XCallRequest("ZR\000\177", 0, 127) 8036 l_request.add_parm('S', 1, key) 8037 self.transport.xcall(l_request)
8038 - def GetSubKeys( 8039 self, 8040 key 8041 ):
8042 """ 8043 No description available. 8044 8045 B{Arguments:} 8046 - B{key} 8047 8048 B{Return values:} 8049 - B{value} 8050 """ 8051 l_request = skypekit.XCallRequest("ZR\000\200\001", 0, 128) 8052 l_request.add_parm('S', 1, key) 8053 l_response = self.transport.xcall(l_request) 8054 l_result = l_response.get(1, []) 8055 return l_result
8056 - def GetISOLanguageInfo(self):
8057 """ 8058 Returns two string lists. First of them will contain list of two-letter language codes (ISO 639-1) The second list contains names of corresponding languages. 8059 8060 8061 B{Return values:} 8062 - B{language_code_list} 8063 - B{language_name_list} - assumes UI has set correct language 8064 """ 8065 l_request = skypekit.XCallRequest("ZR\000\317\001", 0, 207) 8066 l_response = self.transport.xcall(l_request) 8067 l_result = (l_response.get(1, [])), 8068 l_result += (l_response.get(2, [])), 8069 return l_result
8070 - def GetISOCountryInfo(self):
8071 """ 8072 Returns three string lists and one int array, containing 2-letter country code, country name, dialing prefix and example dial string (not available for all items). This method does currently return 0 for South Georgia and the South Sandwich Islands. 8073 8074 8075 B{Return values:} 8076 - B{country_code_list} 8077 - B{country_name_list} - assumes UI has set correct language 8078 - B{country_prefix_list} 8079 - B{country_dial_example_list} 8080 """ 8081 l_request = skypekit.XCallRequest("ZR\000\320\001", 0, 208) 8082 l_response = self.transport.xcall(l_request) 8083 l_result = (l_response.get(1, [])), 8084 l_result += (l_response.get(2, [])), 8085 l_result += (l_response.get(3, [])), 8086 l_result += (l_response.get(4, [])), 8087 return l_result
8088 - def GetISOCountryCodebyPhoneNo( 8089 self, 8090 number 8091 ):
8092 """ 8093 Returns 2-letter country code based on PSTN number. The input argument has to be without + in from of it - '37212345678' will return 'ee' while '+37212345678' will return an empty string. 8094 8095 8096 B{Arguments:} 8097 - B{number} 8098 8099 B{Return values:} 8100 - B{country_code} 8101 """ 8102 l_request = skypekit.XCallRequest("ZR\000\323\001", 0, 211) 8103 l_request.add_parm('S', 1, number) 8104 l_response = self.transport.xcall(l_request) 8105 l_result = l_response.get(1, '') 8106 return l_result
8107 - def App2AppCreate( 8108 self, 8109 appname 8110 ):
8111 """ 8112 App2AppCreate method constructs a local instance of an App2App application. App2App applications are not abstracted in the SkypeKit API as a separate class. Rather, they can be created with App2AppCreate, supplying their name as ID, and then connected to remote parties using App2AppConnect method. 8113 8114 App2App portion of the SkypeKit API enables you to implement arbitrary data exchange protocols between Skype clients. Basically, if you are ever tempted to use conversation chat messages for something other than actual human-readable chat - you should consider using your own custom App2App protocol instead. 8115 8116 The downside of App2App is that all the participants need to be running a client that supports the same App2App application. Although, it is possible to have one side using a custom SkypeKit client and another side using Skype desktop client - App2App is supported in both, in case of desktop client via Public API - you are still limited to remote side running something that can recognize your protocol and react to connection attempts from your side. 8117 8118 To establish connection between each other, all participants need to create their local instances of the application (with the same ID, and then connect to each other. More than one App2App applications can be active in a local client at the same time. Also, more than two clients can be connected with the same application. 8119 8120 Once connection is established, you can choose between two communication methods - datagrams and stream read/write methods. Overall, there are not much principal difference between the two. Datagram packet size is limited to 1500 bytes and stream packet size to 32 KB of payload data. Implementation-wise, datagrams are probably somewhat easier to deal with. 8121 8122 8123 B{Arguments:} 8124 - B{appname} - Application ID. This ID is used by the rest of the App2App commands to differentiate between applications, should there be more than one app2app applications running on the local system. 8125 8126 8127 B{Return values:} 8128 - B{result} - Returns true if the app creation was successful. Returns false when an application with the same name already exists in the local system. 8129 8130 """ 8131 l_request = skypekit.XCallRequest("ZR\000\327\001", 0, 215) 8132 l_request.add_parm('S', 1, appname) 8133 l_response = self.transport.xcall(l_request) 8134 l_result = l_response.get(1, False) 8135 return l_result
8136 - def App2AppDelete( 8137 self, 8138 appname 8139 ):
8140 """ 8141 Disconnects and deletes the App2App application. 8142 8143 8144 B{Arguments:} 8145 - B{appname} - application ID. 8146 8147 8148 B{Return values:} 8149 - B{result} - Returns true if the deletion was successful (application with such ID actually existed) 8150 8151 """ 8152 l_request = skypekit.XCallRequest("ZR\000\330\001", 0, 216) 8153 l_request.add_parm('S', 1, appname) 8154 l_response = self.transport.xcall(l_request) 8155 l_result = l_response.get(1, False) 8156 return l_result
8157 - def App2AppConnect( 8158 self, 8159 appname, 8160 skypename 8161 ):
8162 """ 8163 The App2AppConnect connect result does not mean the connection was immediately established. It will return Ok even if the remote party was offline. The actual connection will be established when both parties have fired App2AppConnect with the same application name, at eachother. At that point, OnApp2AppStreamListChange event will fire for both local and remote party (with listType argument set to ALL_STREAMS) and you can start exchanging data, using either App2App datagrams or App2AppRead App2AppWrite methods. 8164 8165 8166 B{Arguments:} 8167 - B{appname} - Application ID. This needs to match with application ID connecting from the remote side. 8168 8169 - B{skypename} - Skype Name of the remote party. 8170 8171 8172 B{Return values:} 8173 - B{result} - NB! This argument will return true even if the remote party has not yet connected (or is not even online yet) - it merely indicates that the connect command was successfuly processed in runtime. The actual connection success will be indicated when the OnApp2AppStreamListChange event fires, i.e. when App2App stream will be established between connecting parties. 8174 8175 """ 8176 l_request = skypekit.XCallRequest("ZR\000\331\001", 0, 217) 8177 l_request.add_parm('S', 1, appname) 8178 l_request.add_parm('S', 2, skypename) 8179 l_response = self.transport.xcall(l_request) 8180 l_result = l_response.get(1, False) 8181 return l_result
8182 - def App2AppDisconnect( 8183 self, 8184 appname, 8185 stream 8186 ):
8187 """ 8188 Disconnects an App2App stream. This is different from App2AppDelete command in that it enables you to disconnect remote parties selectively - in case there are more than two participants in the App2App stream pool. 8189 8190 8191 B{Arguments:} 8192 - B{appname} - application ID 8193 8194 - B{stream} - stream ID. 8195 8196 8197 B{Return values:} 8198 - B{result} - returns true when the stream disconnect was successful. 8199 8200 """ 8201 l_request = skypekit.XCallRequest("ZR\000\332\001", 0, 218) 8202 l_request.add_parm('S', 1, appname) 8203 l_request.add_parm('S', 2, stream) 8204 l_response = self.transport.xcall(l_request) 8205 l_result = l_response.get(1, False) 8206 return l_result
8207 - def App2AppWrite( 8208 self, 8209 appname, 8210 stream, 8211 data 8212 ):
8213 """ 8214 Sends a stream packet to the remote party specified in the stream argument. The max size of stream write packet is 32KB. After calling this method, OnApp2AppStreamListChange will fire for both parties. In local ssytem with listType set to SENDING_STREAMS and on remote system with listType set to RECEIVED_STREAMS. This event can be used to read received packets out of the stream. 8215 8216 8217 B{Arguments:} 8218 - B{appname} - application ID 8219 8220 - B{stream} - stream ID 8221 8222 - B{data} - packet payload 8223 8224 8225 B{Return values:} 8226 - B{result} - returns true if the call was successful. Note that this does indicate the packet was actually received by remote party. 8227 8228 """ 8229 l_request = skypekit.XCallRequest("ZR\000\333\001", 0, 219) 8230 l_request.add_parm('S', 1, appname) 8231 l_request.add_parm('S', 2, stream) 8232 l_request.add_parm('B', 3, data) 8233 l_response = self.transport.xcall(l_request) 8234 l_result = l_response.get(1, False) 8235 return l_result
8236 - def App2AppDatagram( 8237 self, 8238 appname, 8239 stream, 8240 data 8241 ):
8242 """ 8243 Sends a datagram to the remote party specified in the stream argument. The max size of datagram payload is 1500 bytes. 8244 8245 8246 B{Arguments:} 8247 - B{appname} - application ID - from App2AppCreate 8248 8249 - B{stream} - stream ID - either from App2AppGetStreamsList or from OnApp2AppStreamListChange 8250 - B{data} - datagram payload (max 1500 bytes) 8251 8252 B{Return values:} 8253 - B{result} - returns true on method success. Note that this does mean the remote party has actually received your datagram - that sort of feedback, should you want it, is up to you to implement in your custom protocol. 8254 """ 8255 l_request = skypekit.XCallRequest("ZR\000\334\001", 0, 220) 8256 l_request.add_parm('S', 1, appname) 8257 l_request.add_parm('S', 2, stream) 8258 l_request.add_parm('B', 3, data) 8259 l_response = self.transport.xcall(l_request) 8260 l_result = l_response.get(1, False) 8261 return l_result
8262 - def App2AppRead( 8263 self, 8264 appname, 8265 stream 8266 ):
8267 """ 8268 Reads data from the specified stream. This method should be called from the OnApp2AppStreamListChange event callback, when this callback gets fired with listType argument set to RECEIVED_STREAMS. 8269 8270 8271 B{Arguments:} 8272 - B{appname} - application ID 8273 8274 - B{stream} - stream ID 8275 8276 8277 B{Return values:} 8278 - B{result} - returns true on method success. Note that this does mean the remote party has actually received your packet - that sort of feedback, should you want it, is up to you to implement in your custom protocol. 8279 8280 - B{data} - stream packet payload 8281 8282 """ 8283 l_request = skypekit.XCallRequest("ZR\000\335\001", 0, 221) 8284 l_request.add_parm('S', 1, appname) 8285 l_request.add_parm('S', 2, stream) 8286 l_response = self.transport.xcall(l_request) 8287 l_result = (l_response.get(1, False)), 8288 l_result += (l_response.get(2, '')), 8289 return l_result
8290 - def App2AppGetConnectableUsers( 8291 self, 8292 appname 8293 ):
8294 """ 8295 App2AppGetConnectableUsers returns a list of currently online contacts. It does not return a list of contacts who have an app2app application running. There is currently no way of querying whether an application has been launched on the remote side - other than trying to connect to the remote side and waiting for timeout. NB! if you use App2AppGetConnectableUsers immediately after login - then the online presence of your contact list has not yet updated itself - so this method will most likely return either an empty list or a list with echo123 in it. 8296 8297 8298 B{Arguments:} 8299 - B{appname} - application ID 8300 8301 8302 B{Return values:} 8303 - B{result} - returns true on method success 8304 8305 - B{users} - stringlist with Skype Names of connectable users 8306 8307 """ 8308 l_request = skypekit.XCallRequest("ZR\000\336\001", 0, 222) 8309 l_request.add_parm('S', 1, appname) 8310 l_response = self.transport.xcall(l_request) 8311 l_result = (l_response.get(1, False)), 8312 l_result += (l_response.get(2, [])), 8313 return l_result
8314 APP2APP_STREAMS = {0:'ALL_STREAMS', 'ALL_STREAMS':0, 1:'SENDING_STREAMS', 'SENDING_STREAMS':1, 2:'RECEIVED_STREAMS', 'RECEIVED_STREAMS':2} 8315 """ 8316 - ALL_STREAMS 8317 - SENDING_STREAMS 8318 - RECEIVED_STREAMS 8319 """
8320 - def App2AppGetStreamsList( 8321 self, 8322 appname, 8323 list_type 8324 ):
8325 """ 8326 Takes application ID and list type filter and returns a stringlist with streamID's that pass the filter. 8327 8328 8329 B{Arguments:} 8330 - B{appname} - application ID 8331 8332 - B{list_type} - list type filter 8333 8334 8335 B{Return values:} 8336 - B{result} - results true if the method call was successful 8337 8338 - B{streams} - string list with stream IDs 8339 8340 - B{received_sizes} - For RECEIVED_STREAMS, contains the number of bytes in each stream waiting to be read 8341 """ 8342 l_request = skypekit.XCallRequest("ZR\000\337\001", 0, 223) 8343 l_request.add_parm('S', 1, appname) 8344 l_request.add_parm('e', 2, Skype.APP2APP_STREAMS[list_type]) 8345 l_response = self.transport.xcall(l_request) 8346 l_result = (l_response.get(1, False)), 8347 l_result += (l_response.get(2, [])), 8348 l_result += (l_response.get(3, [])), 8349 return l_result
8350 - def OnApp2AppDatagram( 8351 self, 8352 appname, 8353 stream, 8354 data 8355 ):
8356 """ 8357 This event gets fired on incoming app2app datagram. 8358 8359 8360 B{Return values:} 8361 - B{appname} - App2app application ID. 8362 8363 - B{stream} - App2app stream ID - see OnApp2AppStreamListChange event for obtaining stream IDs. 8364 8365 - B{data} - Datagram payload - limited to 1500 bytes. 8366 8367 """ 8368 pass
8369 event_handlers[6] = "_sk_on_app2app_datagram"
8370 - def _sk_on_app2app_datagram(self, parms):
8371 """ internal event dispatcher for OnApp2AppDatagram """ 8372 l_cleanparms = (parms.get(1, '')), 8373 l_cleanparms += (parms.get(2, '')), 8374 l_cleanparms += (parms.get(3, '')), 8375 self.OnApp2AppDatagram(*l_cleanparms)
8376 - def OnApp2AppStreamListChange( 8377 self, 8378 appname, 8379 list_type, 8380 streams, 8381 received_sizes 8382 ):
8383 """ 8384 In context of datagrams, this event will fire when: 8385 - Connection is established between two app2app applications. That is, when both parties have an app up with the same name and -both- used App2AppConnect In that case, both parties get this event, with listType ALL_STREAMS 8386 - When a datagram is sent, the sender will get this event with listType SENDING_STREAMS Receiver of the datagram will get OnApp2AppDatagram event instead. 8387 - When the remote party drops app2app connection, the local user will get OnApp2AppStreamListChange with listType ALL_STREAMS and streams.size() zero. 8388 In context of stream reads/writes, this event will fire for both the sender (listType == SENDING_STREAMS)and the receiver (listType == RECEIVED_STREAMS). For receiver side, this is the place to put your reading code - App2AppRead. 8389 8390 8391 B{Return values:} 8392 - B{appname} - application ID - the name you supplied in App2AppCreate. 8393 8394 - B{list_type} - application list type (read/write/all) 8395 8396 - B{streams} - SEStringlist with affected stream IDs. 8397 8398 - B{received_sizes} - For RECEIVED_STREAMS, contains the number of bytes in each stream waiting to be read 8399 """ 8400 pass
8401 event_handlers[8] = "_sk_on_app2app_stream_list_change"
8402 - def _sk_on_app2app_stream_list_change(self, parms):
8403 """ internal event dispatcher for OnApp2AppStreamListChange """ 8404 l_cleanparms = (parms.get(1, '')), 8405 l_cleanparms += (Skype.APP2APP_STREAMS[parms.get(2)]), 8406 l_cleanparms += (parms.get(3, [])), 8407 l_cleanparms += (parms.get(4, [])), 8408 self.OnApp2AppStreamListChange(*l_cleanparms)
8409
8410 -def GetSkype(apptoken, has_event_thread=True, host='127.0.0.1', port=8963, logtransport=False, secure=True):
8411 setup = "SkypeKit/SubscribedProperties=10:155,10:154,10:151,10:152,10:153,2:202,2:4,2:6,2:5,2:7,2:8,2:9,2:10,2:11,2:12,2:13,2:14,2:15,2:16,2:17,2:18,2:37,2:26,2:205,2:27,2:36,2:19,2:28,2:29,2:182,2:183,2:20,2:25,2:35,2:34,2:21,2:22,2:23,2:33,2:180,2:39,2:41,2:184,2:185,2:186,2:187,2:188,2:189,2:42,1:200,19:930,19:931,19:932,19:933,19:934,19:935,19:936,19:943,19:938,19:948,19:939,19:941,19:942,19:947,19:949,19:950,19:951,19:952,19:953,19:954,19:955,18:972,18:902,18:918,18:974,18:996,18:920,18:921,18:925,18:924,18:927,18:928,18:973,18:975,18:976,18:977,18:970,18:971,18:979,18:981,18:915,18:903,18:904,18:919,18:922,18:906,18:907,18:909,18:980,18:910,18:911,18:913,18:914,9:960,9:120,9:122,9:123,9:792,9:790,9:121,9:961,9:962,9:968,9:222,9:223,9:963,9:964,9:127,9:125,9:966,9:126,9:982,11:130,11:131,11:132,11:133,11:134,11:1104,11:1105,7:100,7:101,7:102,7:103,7:104,7:105,7:106,7:107,7:108,7:109,7:830,7:831,12:190,12:191,12:192,12:48,12:198,12:193,12:49,12:194,12:199,12:195,12:196,12:197,12:840,6:80,6:81,6:82,6:83,6:84,6:85,6:86,6:87,6:88,6:89,6:90,6:91,6:92,6:93,6:98,5:70,5:71,5:73,5:78,5:72,5:74,5:75,5:804,5:76,5:79,5:77,5:160,5:161,5:162,5:163,5:164,5:165,5:166,5:168,5:169,5:773,5:800,5:801,5:802,5:4,5:5,5:7,5:8,5:9,5:10,5:11,5:12,5:13,5:14,5:15,5:16,5:17,5:18,5:19,5:26,5:27,5:28,5:34,5:37,5:182,5:183,5:205\nSkypeKit/SubscribedEvents=10:1,10:2,0:1,0:2,0:3,1:1,19:1,18:1,18:2,18:3,0:4,0:5,11:2,0:7,0:44,0:28,0:10,0:11,0:12,0:6,0:8\n" 8412 return Skype(skypekit.SkypeKit(apptoken, module_id2classes, has_event_thread, host, port, logtransport, secure, setup))
8413