001    package com.skype.api;
002    
003    import java.io.IOException;
004    import java.util.*;
005    import com.skype.ipc.*;
006    /**
007     * 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. <br><br>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. <br><br>The set of writeable account profile properties (local profile) is as follows; <br> - P_FULLNAME, <br> - P_BIRTHDAY, <br> - P_GENDER, <br> - P_LANGUAGES, <br> - P_COUNTRY, <br> - P_PROVINCE, <br> - P_CITY, <br> - P_PHONE_HOME, <br> - P_PHONE_OFFICE, <br> - P_PHONE_MOBILE, <br> - P_EMAILS, <br> - P_HOMEPAGE, <br> - P_ABOUT, <br> - P_MOOD_TEXT, <br> - P_TIMEZONE, <br> - P_AVATAR_IMAGE, <br> - P_RICH_MOOD_TEXT <br><br>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. <br><br>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. <br><br>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: <br><br> - obtain an Account instance by invoking Skype.GetAccount. This automatically sets P_SKYPENAME. <br> - set any additional profile-related properties. Skype recommends that you minimally set the following: <br> - their email address so that they can retrieve a lost password (P_EMAILS) <br> - the user's full name (P_FULLNAME) <br> - at least one phone number (P_PHONE_HOME, P_PHONE_HOME, P_PHONE_OFFICE) <br> - invoke Account.Register to actually create the account <br>
008     */
009    
010    
011    public class Account extends SkypeObject {
012    
013    
014            public interface AccountListener {
015                    /** This event gets called when there are changes to Account properties defined in Account.PROPERTY  */
016                    public void OnPropertyChange(SkypeObject obj, PROPERTY prop, Object value);
017                    
018            }
019            
020            public Account(int oid, Skype skype) {
021                    super(oid,skype);
022                    /**get default properties for this module **/
023                    GetDefaultProps();
024            }
025            
026            private static final int MODULE_ID = 5;
027            
028            public static final int moduleID() {
029                    return MODULE_ID;
030            }
031            
032            /** Properties of the Account class */
033            public enum PROPERTY {
034            
035                    /** Account.STATUS, type: STATUS */
036                    status(70),
037                    
038                    /** Account.PWDCHANGESTATUS, type: PWDCHANGESTATUS */
039                    pwdchangestatus(71),
040                    
041                    /** 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. <br>, type: LOGOUTREASON */
042                    logoutreason(73),
043                    
044                    /** Account.COMMITSTATUS, type: COMMITSTATUS */
045                    commitstatus(78),
046                    
047                    /** suggested skypenames, semi-colon separated. present if logoutreason==SKYPENAME_TAKEN, type: String */
048                    suggested_skypename(72),
049                    
050                    /** 'EUR', 'USD', etc., type: String */
051                    skypeout_balance_currency(74),
052                    
053                    /** balance in 'cents', type: int */
054                    skypeout_balance(75),
055                    
056                    /** decimal points in ACCOUNT_SKYPEOUT_BALANCE, type: int */
057                    skypeout_precision(804),
058                    
059                    /** space-separated list of skypein numbers, type: String */
060                    skypein_numbers(76),
061                    
062                    /** Account.CBLSYNCSTATUS, type: CBLSYNCSTATUS */
063                    cblsyncstatus(79),
064                    
065                    /** space-separated list of 'begSecond,endSecond,identity' tokens, type: String */
066                    offline_callforward(77),
067                    
068                    /** Server-side account property, use SetServerside*Property() to set, type: CHATPOLICY */
069                    chat_policy(160),
070                    
071                    /** Server-side account property, use SetServerside*Property() to set, type: SKYPECALLPOLICY */
072                    skype_call_policy(161),
073                    
074                    /** Server-side account property, use SetServerside*Property() to set, type: PSTNCALLPOLICY */
075                    pstn_call_policy(162),
076                    
077                    /** Server-side account property, use SetServerside*Property() to set, type: AVATARPOLICY */
078                    avatar_policy(163),
079                    
080                    /** Server-side account property, use SetServerside*Property() to set, type: BUDDYCOUNTPOLICY */
081                    buddycount_policy(164),
082                    
083                    /** Server-side account property, use SetServerside*Property() to set, type: TIMEZONEPOLICY */
084                    timezone_policy(165),
085                    
086                    /** Server-side account property, use SetServerside*Property() to set, type: WEBPRESENCEPOLICY */
087                    webpresence_policy(166),
088                    
089                    /** Server-side account property, use SetServerside*Property() to set, type: PHONENUMBERSPOLICY */
090                    phonenumbers_policy(168),
091                    
092                    /** Server-side account property, use SetServerside*Property() to set, type: VOICEMAILPOLICY */
093                    voicemail_policy(169),
094                    
095                    /** Alerts: opted out partner id's, space separated, type: String */
096                    partner_optedout(773),
097                    
098                    /** service information if the user is a paid service provider, type: String */
099                    service_provider_info(800),
100                    
101                    /** NB! Unlike your common UNIX timestamps, the registration_timestamp is special, as it counts MINUTES rather than seconds, from Epoch (January 1, 1970) <br>, type: int */
102                    registration_timestamp(801),
103                    
104                    /** number of times this user is logged in from other computers, type: int */
105                    nr_of_other_instances(802),
106                    
107                    /** type: String */
108                    skypename(4),
109                    
110                    /** type: String */
111                    fullname(5),
112                    
113                    /** YYYYMMDD, type: int */
114                    birthday(7),
115                    
116                    /** 1-male, 2-female, type: int */
117                    gender(8),
118                    
119                    /** ISO language codes, space-separated, type: String */
120                    languages(9),
121                    
122                    /** ISO country code, type: String */
123                    country(10),
124                    
125                    /** type: String */
126                    province(11),
127                    
128                    /** type: String */
129                    city(12),
130                    
131                    /** NB! string not integer, type: String */
132                    phone_home(13),
133                    
134                    /** type: String */
135                    phone_office(14),
136                    
137                    /** type: String */
138                    phone_mobile(15),
139                    
140                    /** 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. <br>, type: String */
141                    emails(16),
142                    
143                    /** type: String */
144                    homepage(17),
145                    
146                    /** arbitrary introductory text, type: String */
147                    about(18),
148                    
149                    /** UNIX timestamp of last profile change, type: int */
150                    profile_timestamp(19),
151                    
152                    /** Personal mood text (visible to authorised users only). Max length 300 bytes. <br>, type: String */
153                    mood_text(26),
154                    
155                    /** 24*3600+diff_to_UTC_in_seconds. nb! changes with DST, type: int */
156                    timezone(27),
157                    
158                    /** Count of this user's authorized contacts. <br>, type: int */
159                    nrof_authed_buddies(28),
160                    
161                    /** Contact.AVAILABILITY, type: Contact.AVAILABILITY */
162                    availability(34),
163                    
164                    /** 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. <br><br>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.  <br><br>In any case, the avatar picture should be pre-validated with the Skype.ValidateAvatar method. <br>, type: byte[] */
165                    avatar_image(37),
166                    
167                    /** UNIX timestamp of when current avatar was set, type: int */
168                    avatar_timestamp(182),
169                    
170                    /** UNIX timestamp of when current mood was set, type: int */
171                    mood_timestamp(183),
172                    
173                    /** XML version of CONTACT_MOOD_TEXT. Max length 1000 bytes. <br>, type: String */
174                    rich_mood_text(205);
175                    
176                    private static final Map<Integer,PROPERTY> lookup = new HashMap<Integer,PROPERTY>();
177                    
178                    static {
179                            for(PROPERTY s : EnumSet.allOf(PROPERTY.class))
180                                    lookup.put(s.getId(), s);
181                    }
182                    
183                    private final int id;
184                    
185                    private PROPERTY(int value) {
186                            this.id = value;
187                    }
188                    
189                    public int getId() { return id; }
190                    
191                    public static PROPERTY get(int code) {
192                            return lookup.get(code);
193                    }
194                    
195                    public static PROPERTY fromString(String s) {
196                            for (PROPERTY p : lookup.values()) {
197                                    if (p.toString() == s) {
198                                            return p;
199                                    }
200                            }
201                            return null;
202                    }
203            }
204            
205            public Object GetPropertyAsEnum(int propid) {
206                    return PROPERTY.get(propid);
207            }
208            
209            public String GetStrProperty(PROPERTY prop) {
210                    //check in propcache if so then return
211                    if (mPropCache.containsKey(new Integer(prop.id))){
212                            String value =  (String)mPropCache.get(prop.id);
213                            if (value != null && !(value.length() == 0) ){
214                                    return value;
215                            }
216                    }
217                    //else get from skypekit...
218                    GetPropertyRequest request = new GetPropertyRequest(5, mObjectId, prop.id);
219                    
220                    String string = null;
221                    GetPropertyResponse r = skype.GetProperty(request);
222                    if (r != null){
223                            string = r.GetAsString();
224                    }
225                    
226                    if (string != null)
227                    {
228                            mPropCache.put(new Integer(prop.id), string);
229                    }
230                    return string;
231            }
232            
233            public int GetIntProperty(PROPERTY prop) {
234                    //check in propcache if so then return
235                    if (mPropCache.containsKey(new Integer(prop.id))){
236                            int value = ((Integer)mPropCache.get(prop.id)).intValue();
237                            if (value != 0){
238                                    return value;
239                            }
240                    }
241                    //else get from skypekit...
242                    GetPropertyRequest request = new GetPropertyRequest(moduleID(), mObjectId, prop.id);
243                    
244                    Integer integer = null;
245                    GetPropertyResponse r = skype.GetProperty(request);
246                    if (r != null){
247                            integer  = r.GetAsInt();
248                    }
249                    
250                    if (integer != null)
251                    {
252                            mPropCache.put(new Integer(prop.id), integer);
253                            return integer.intValue();
254                    }
255                    else
256                    {
257                            return 0;
258                    }
259            }
260            
261            public boolean GetBooleanProperty(PROPERTY prop) {
262                    //check in propcache if so then return
263                    if (mPropCache.containsKey(new Integer(prop.id))){
264                            return ((Boolean)mPropCache.get(prop.id)).booleanValue();
265                    }
266                    //else get from skypekit...
267                    GetPropertyRequest request = new GetPropertyRequest(moduleID(), mObjectId, prop.id);
268                    
269                    Boolean boolResp = null;
270                    GetPropertyResponse r = skype.GetProperty(request);
271                    if (r != null){
272                            boolResp  = r.GetAsBoolean();
273                    }
274                    
275                    if (boolResp != null)
276                    {
277                            mPropCache.put(new Integer(prop.id), boolResp);
278                            return boolResp.booleanValue();
279                    }
280                    else
281                    {
282                            return false;
283                    }
284            }
285            
286            public byte [] GetBinProperty(PROPERTY prop) {
287                    //get from skypekit...
288                    GetPropertyRequest request = new GetPropertyRequest(5, mObjectId, prop.id);
289                    
290                    byte [] data = null;
291                    GetPropertyResponse r = skype.GetProperty(request);
292                    if (r != null) {
293                            data = r.GetAsBinary();
294                    }
295                    return data;
296            }
297            
298            /**default array of Account Properties that get fetched & cached upon class construction*/
299            private static PROPERTY [] defaultProperties = { PROPERTY.skypename, PROPERTY.fullname, PROPERTY.mood_text, PROPERTY.birthday, PROPERTY.skypeout_balance, PROPERTY.skypeout_balance_currency, PROPERTY.skypeout_precision, PROPERTY.availability, PROPERTY.cblsyncstatus};
300            
301            private void GetDefaultProps() {
302                    MultiGetPropertyRequest request = null;
303                    ArrayList<Integer> proparray = null;
304                            /**Add the single oid into array*/
305                            ArrayList<Integer> oidarray=new ArrayList<Integer>();
306                            oidarray.add(mObjectId);
307                            
308                            /**Add all requested propids into array*/
309                            proparray=new ArrayList<Integer>();
310                            for (PROPERTY defaultProp : defaultProperties) {
311                                    proparray.add(defaultProp.getId());
312                            }
313                            /**Generate the request*/
314                            request = new MultiGetPropertyRequest(moduleID(), oidarray,proparray);
315                            
316                            /** Make Multi Get call*/
317                            GetPropertyResponse r=skype.MultiGetProperty(request);
318                            /**Verify that it is a proper multiresponse*/
319                            if(!r.isMultiresponse())
320                            {
321                                    return;
322                            }
323                            /**update property cache with results*/
324                            mPropCache.putAll(r.GetAsMap(mObjectId, proparray));
325                    }
326                    
327                    /**
328                     */
329                    public enum STATUS {
330                    
331                            /** */
332                            LOGGED_OUT(1),
333                            
334                            /** the account is logged out, but password is not needed for re-login*/
335                            LOGGED_OUT_AND_PWD_SAVED(2),
336                            
337                            /** connecting to P2P network*/
338                            CONNECTING_TO_P2P(3),
339                            
340                            /** connecting to login server*/
341                            CONNECTING_TO_SERVER(4),
342                            
343                            /** waiting for response from server*/
344                            LOGGING_IN(5),
345                            
346                            /** response OK. initialising account-specific lib structures*/
347                            INITIALIZING(6),
348                            
349                            /** alright, we're good to go!*/
350                            LOGGED_IN(7),
351                            
352                            /** Logout() has been called but not processed yet*/
353                            LOGGING_OUT(8);
354                            
355                            private static final Map<Integer,STATUS> lookup = new HashMap<Integer,STATUS>();
356                            
357                            static {
358                                    for(STATUS s : EnumSet.allOf(STATUS.class))
359                                            lookup.put(s.getId(), s);
360                            }
361                            
362                            private final int id;
363                            
364                            private STATUS(int value) {
365                                    this.id = value;
366                            }
367                            
368                            public int getId() { return id; }
369                            
370                            public static STATUS get(int code) {
371                                    return lookup.get(code);
372                            }
373                            
374                            public static STATUS fromString(String s) {
375                                    for (STATUS p : lookup.values()) {
376                                            if (p.toString() == s) {
377                                                    return p;
378                                            }
379                                    }
380                                    return null;
381                            }
382                    }
383                    
384                    /**
385                     * This is a legacy method. The progress argument does not return overall login progress. Instead, it used to return database mount or conversion progress in case of logging in with a newer client on an older database version. Currently, the progress value should always return 0 under normal circumstances. There is currently no functionality in the SkypeKit API to accurately guess how long the login will take, as the P2P connect times are unpredictable. The maximum progress granularity available through SkypeKit API is currently the Account.P_STATUS property values. <br>
386                     * @return GetStatusWithProgressResult
387                     */
388                    public GetStatusWithProgressResult GetStatusWithProgress() {
389                    
390                            Request request = null;
391                            try {
392                                    request = new XCallRequest(5,1);
393                            } catch (IOException e) {
394                                    e.printStackTrace();
395                                    if (skype.errorListener != null)
396                                            skype.errorListener.OnSkypeKitFatalError();
397                            }
398                            request.addParm('O',0,mObjectId);
399                            
400                            Response r = skype.XCall((XCallRequest)request);
401                            
402                            if (r.isErrCall())
403                                    return null;
404                                    
405                            GetStatusWithProgressResult result = new GetStatusWithProgressResult();
406                            
407                            STATUS status = null;
408                            status = STATUS.get(r.GetAsInt(1));
409                            result.status = status;
410                            
411                            int progress = 0;
412                            progress = r.GetAsInt(2);
413                            result.progress = progress;
414                            
415                            return result;
416                    }
417                    
418                    public class GetStatusWithProgressResult {
419                            public STATUS status; /** Current value of this account's P_STATUS property */
420                            public int progress; /** This argument returns 0. <br> */
421                    }
422                    
423                    /**
424                    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). <br><br>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. <br><br>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. <br> */
425                    public enum CBLSYNCSTATUS {
426                    
427                            /** status is not clear (yet)*/
428                            CBL_INITIALIZING(0),
429                            
430                            /** first sync with empty profile*/
431                            CBL_INITIAL_SYNC_PENDING(1),
432                            
433                            /** 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.*/
434                            CBL_SYNC_PENDING(2),
435                            
436                            /** CBL synchronization is currently taking place.*/
437                            CBL_SYNC_IN_PROGRESS(3),
438                            
439                            /** Account properties are up-to-date.*/
440                            CBL_IN_SYNC(4),
441                            
442                            /** 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.*/
443                            CBL_SYNC_FAILED(5),
444                            
445                            /** we have received a hint that there is a remote data change in CBL*/
446                            CBL_REMOTE_SYNC_PENDING(6);
447                            
448                            private static final Map<Integer,CBLSYNCSTATUS> lookup = new HashMap<Integer,CBLSYNCSTATUS>();
449                            
450                            static {
451                                    for(CBLSYNCSTATUS s : EnumSet.allOf(CBLSYNCSTATUS.class))
452                                            lookup.put(s.getId(), s);
453                            }
454                            
455                            private final int id;
456                            
457                            private CBLSYNCSTATUS(int value) {
458                                    this.id = value;
459                            }
460                            
461                            public int getId() { return id; }
462                            
463                            public static CBLSYNCSTATUS get(int code) {
464                                    return lookup.get(code);
465                            }
466                            
467                            public static CBLSYNCSTATUS fromString(String s) {
468                                    for (CBLSYNCSTATUS p : lookup.values()) {
469                                            if (p.toString() == s) {
470                                                    return p;
471                                            }
472                                    }
473                                    return null;
474                            }
475                    }
476                    
477                    /**
478                    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. <br> */
479                    public enum LOGOUTREASON {
480                    
481                            /** manual logout (or unknown reason from previous session)*/
482                            LOGOUT_CALLED(1),
483                            
484                            /** sync errors at login/registration*/
485                            HTTPS_PROXY_AUTH_FAILED(2),
486                            
487                            /** sync errors at login/registration*/
488                            SOCKS_PROXY_AUTH_FAILED(3),
489                            
490                            /** sync errors at login/registration*/
491                            P2P_CONNECT_FAILED(4),
492                            
493                            /** sync errors at login/registration*/
494                            SERVER_CONNECT_FAILED(5),
495                            
496                            /** sync errors at login/registration*/
497                            SERVER_OVERLOADED(6),
498                            
499                            /** sync errors at login/registration*/
500                            DB_IN_USE(7),
501                            
502                            /** sync errors at registration*/
503                            INVALID_SKYPENAME(8),
504                            
505                            /** sync errors at registration*/
506                            INVALID_EMAIL(9),
507                            
508                            /** sync errors at registration*/
509                            UNACCEPTABLE_PASSWORD(10),
510                            
511                            /** sync errors at registration*/
512                            SKYPENAME_TAKEN(11),
513                            
514                            /** sync errors at registration*/
515                            REJECTED_AS_UNDERAGE(12),
516                            
517                            /** sync errors at login*/
518                            NO_SUCH_IDENTITY(13),
519                            
520                            /** sync errors at login*/
521                            INCORRECT_PASSWORD(14),
522                            
523                            /** sync errors at login*/
524                            TOO_MANY_LOGIN_ATTEMPTS(15),
525                            
526                            /** async errors (can happen anytime while logged in)*/
527                            PASSWORD_HAS_CHANGED(16),
528                            
529                            /** async errors (can happen anytime while logged in)*/
530                            PERIODIC_UIC_UPDATE_FAILED(17),
531                            
532                            /** async errors (can happen anytime while logged in)*/
533                            DB_DISK_FULL(18),
534                            
535                            /** async errors (can happen anytime while logged in)*/
536                            DB_IO_ERROR(19),
537                            
538                            /** async errors (can happen anytime while logged in)*/
539                            DB_CORRUPT(20),
540                            
541                            /** deprecated (superceded by more detailed DB_* errors)*/
542                            DB_FAILURE(21),
543                            
544                            /** platform sdk*/
545                            INVALID_APP_ID(22),
546                            
547                            /** platform sdk*/
548                            APP_ID_FAILURE(23),
549                            
550                            /** forced upgrade/discontinuation*/
551                            UNSUPPORTED_VERSION(24);
552                            
553                            private static final Map<Integer,LOGOUTREASON> lookup = new HashMap<Integer,LOGOUTREASON>();
554                            
555                            static {
556                                    for(LOGOUTREASON s : EnumSet.allOf(LOGOUTREASON.class))
557                                            lookup.put(s.getId(), s);
558                            }
559                            
560                            private final int id;
561                            
562                            private LOGOUTREASON(int value) {
563                                    this.id = value;
564                            }
565                            
566                            public int getId() { return id; }
567                            
568                            public static LOGOUTREASON get(int code) {
569                                    return lookup.get(code);
570                            }
571                            
572                            public static LOGOUTREASON fromString(String s) {
573                                    for (LOGOUTREASON p : lookup.values()) {
574                                            if (p.toString() == s) {
575                                                    return p;
576                                            }
577                                    }
578                                    return null;
579                            }
580                    }
581                    
582                    /**
583                     *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. <br><br>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 <br>
584                     * @param setAvailabilityTo force this account's initial online status to the specified Contact.AVAILABILITY value.
585                     */
586                    public void Login( Contact.AVAILABILITY setAvailabilityTo) {
587                    
588                            Request request = null;
589                            try {
590                                    request = new XCallRequest(5,5);
591                            } catch (IOException e) {
592                                    e.printStackTrace();
593                                    if (skype.errorListener != null)
594                                            skype.errorListener.OnSkypeKitFatalError();
595                            }
596                            request.addParm('O',0,mObjectId);
597                            request.addParm('e',1,setAvailabilityTo.getId());
598                            
599                            skype.XCall((XCallRequest)request);
600                    }
601                    
602                    /**
603                     *  <br>Login in an account by specifying its password. To retrieve an account instance for login, invoke Skype.GetAccount. <br>
604                     * @param password Password string (plaintext) for this account, which should be pre-validated (Skype.ValidatePassword) <br>
605                     * @param savePwd <br> - true: Saves the password, ensuring that auto-login is enabled. <br> - 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).
606                     * @param saveDataLocally For internal use only.
607                     */
608                    public void LoginWithPassword( String password, boolean savePwd, boolean saveDataLocally) {
609                    
610                            Request request = null;
611                            try {
612                                    request = new XCallRequest(5,6);
613                            } catch (IOException e) {
614                                    e.printStackTrace();
615                                    if (skype.errorListener != null)
616                                            skype.errorListener.OnSkypeKitFatalError();
617                            }
618                            request.addParm('O',0,mObjectId);
619                            request.addParm('S',1,password);
620                            request.addParm('b',2,savePwd);
621                            request.addParm('b',3,saveDataLocally);
622                            
623                            skype.XCall((XCallRequest)request);
624                    }
625                    
626                    /**
627                     *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. <br>NB! You should pre-validate your P_SKYPENAME value and any email string (Skype.ValidateProfileString) prior to invoking this method. <br>
628                     * @param password Password string (plaintext) for this account, which should be pre-validated (Skype.ValidatePassword)
629                     * @param savePwd <br> - true: Saves the password and enables auto-login. <br> - false (default): Does not save the password, and the user needs to be prompted for password on the next login attempt.
630                     * @param saveDataLocally For internal use only.
631                     * @param email An email address for retrieving lost passwords and receiving news and information from Skype.
632                     * @param allowSpam enable/disable news and information from Skype being sent to account's e-mail.
633                     */
634                    public void Register( String password, boolean savePwd, boolean saveDataLocally, String email, boolean allowSpam) {
635                    
636                            Request request = null;
637                            try {
638                                    request = new XCallRequest(5,7);
639                            } catch (IOException e) {
640                                    e.printStackTrace();
641                                    if (skype.errorListener != null)
642                                            skype.errorListener.OnSkypeKitFatalError();
643                            }
644                            request.addParm('O',0,mObjectId);
645                            request.addParm('S',1,password);
646                            request.addParm('b',2,savePwd);
647                            request.addParm('b',3,saveDataLocally);
648                            request.addParm('S',4,email);
649                            request.addParm('b',5,allowSpam);
650                            
651                            skype.XCall((XCallRequest)request);
652                    }
653                    
654                    /**
655                     *Logs out current account. Note that calling this on client application exit is optional. <br>
656                     * @param clearSavedPwd <br> - true: Clears any saved password use with auto-login and so disables auto-login until you explicitly invoke Account.SetPasswordSaved(true). <br> - false (default): Does not clear any saved password and so does not affect existing auto-login behavior.
657                     */
658                    public void Logout( boolean clearSavedPwd) {
659                    
660                            Request request = null;
661                            try {
662                                    request = new XCallRequest(5,8);
663                            } catch (IOException e) {
664                                    e.printStackTrace();
665                                    if (skype.errorListener != null)
666                                            skype.errorListener.OnSkypeKitFatalError();
667                            }
668                            request.addParm('O',0,mObjectId);
669                            request.addParm('b',1,clearSavedPwd);
670                            
671                            skype.XCall((XCallRequest)request);
672                    }
673                    
674                    /**
675                    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. <br> - PWD_CHANGING - consider displaying an "in progress" indicator and continue polling <br> - PWD_OK - consider displaying an updated indicator and stop polling <br> - PWD_OK_BUT_CHANGE_SUGGESTED - consider displaying an updated indicator, along with a recommendation to change again to a stronger password. <br> */
676                    public enum PWDCHANGESTATUS {
677                    
678                            /** Password change succeeded. <br>*/
679                            PWD_OK(0),
680                            
681                            /** Password change is in progress. <br>*/
682                            PWD_CHANGING(1),
683                            
684                            /** Old password was incorrect. <br>*/
685                            PWD_INVALID_OLD_PASSWORD(2),
686                            
687                            /** Failed to verify password because of no connection to server. <br>*/
688                            PWD_SERVER_CONNECT_FAILED(3),
689                            
690                            /** Password was set but server didn't like it much. <br>*/
691                            PWD_OK_BUT_CHANGE_SUGGESTED(4),
692                            
693                            /** New password was exactly the same as old one. <br>*/
694                            PWD_MUST_DIFFER_FROM_OLD(5),
695                            
696                            /** The new password was unacceptable. (too short, too simple, etc.) <br>*/
697                            PWD_INVALID_NEW_PWD(6),
698                            
699                            /** Account was currently not logged in. <br>*/
700                            PWD_MUST_LOG_IN_TO_CHANGE(7);
701                            
702                            private static final Map<Integer,PWDCHANGESTATUS> lookup = new HashMap<Integer,PWDCHANGESTATUS>();
703                            
704                            static {
705                                    for(PWDCHANGESTATUS s : EnumSet.allOf(PWDCHANGESTATUS.class))
706                                            lookup.put(s.getId(), s);
707                            }
708                            
709                            private final int id;
710                            
711                            private PWDCHANGESTATUS(int value) {
712                                    this.id = value;
713                            }
714                            
715                            public int getId() { return id; }
716                            
717                            public static PWDCHANGESTATUS get(int code) {
718                                    return lookup.get(code);
719                            }
720                            
721                            public static PWDCHANGESTATUS fromString(String s) {
722                                    for (PWDCHANGESTATUS p : lookup.values()) {
723                                            if (p.toString() == s) {
724                                                    return p;
725                                            }
726                                    }
727                                    return null;
728                            }
729                    }
730                    
731                    /**
732                     *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. <br>
733                     * @param oldPassword "Current password string (plaintext) for this account
734                     * @param newPassword New password string (plaintext) for this account
735                     * @param savePwd <br> - true: Saves the new password and enables auto-login. <br> - false (default): Clears any existing saved password and so the user cannot effect auto-login until they explicitly invoke Account.SetPasswordSaved(true)
736                     */
737                    public void ChangePassword( String oldPassword, String newPassword, boolean savePwd) {
738                    
739                            Request request = null;
740                            try {
741                                    request = new XCallRequest(5,11);
742                            } catch (IOException e) {
743                                    e.printStackTrace();
744                                    if (skype.errorListener != null)
745                                            skype.errorListener.OnSkypeKitFatalError();
746                            }
747                            request.addParm('O',0,mObjectId);
748                            request.addParm('S',1,oldPassword);
749                            request.addParm('S',2,newPassword);
750                            request.addParm('b',3,savePwd);
751                            
752                            skype.XCall((XCallRequest)request);
753                    }
754                    
755                    /**
756                     *save or clear credentials for auto-login whilst already logged in
757                     * @param savePwd
758                     */
759                    public void SetPasswordSaved( boolean savePwd) {
760                    
761                            Request request = null;
762                            try {
763                                    request = new XCallRequest(5,25);
764                            } catch (IOException e) {
765                                    e.printStackTrace();
766                                    if (skype.errorListener != null)
767                                            skype.errorListener.OnSkypeKitFatalError();
768                            }
769                            request.addParm('O',0,mObjectId);
770                            request.addParm('b',1,savePwd);
771                            
772                            skype.XCall((XCallRequest)request);
773                    }
774                    
775                    /**
776                     *Setter for integer (and enum) server-side properties. For a list of writeable server-side properties, see the detailed description of the Account class. <br>
777                     * @param propKey
778                     * @param value
779                     */
780                    public void SetServersideIntProperty( int propKey, int value) {
781                    
782                            Request request = null;
783                            try {
784                                    request = new XCallRequest(5,12);
785                            } catch (IOException e) {
786                                    e.printStackTrace();
787                                    if (skype.errorListener != null)
788                                            skype.errorListener.OnSkypeKitFatalError();
789                            }
790                            request.addParm('O',0,mObjectId);
791                            request.addParm('e',1,propKey);
792                            request.addParm('u',2,value);
793                            
794                            skype.XCall((XCallRequest)request);
795                    }
796                    
797                    /**
798                     *Setter for String server-side properties. For a list of writeable server-side properties, see the detailed description of the Account class. <br>
799                     * @param propKey
800                     * @param value
801                     */
802                    public void SetServersideStrProperty( int propKey, String value) {
803                    
804                            Request request = null;
805                            try {
806                                    request = new XCallRequest(5,13);
807                            } catch (IOException e) {
808                                    e.printStackTrace();
809                                    if (skype.errorListener != null)
810                                            skype.errorListener.OnSkypeKitFatalError();
811                            }
812                            request.addParm('O',0,mObjectId);
813                            request.addParm('e',1,propKey);
814                            request.addParm('S',2,value);
815                            
816                            skype.XCall((XCallRequest)request);
817                    }
818                    
819                    /**
820                    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. <br> */
821                    public enum COMMITSTATUS {
822                    
823                            /** No pending updates to the server. <br>*/
824                            COMMITTED(1),
825                            
826                            /** Update to the server in progress. <br>*/
827                            COMMITTING_TO_SERVER(2),
828                            
829                            /** Server update has failed. <br>*/
830                            COMMIT_FAILED(3);
831                            
832                            private static final Map<Integer,COMMITSTATUS> lookup = new HashMap<Integer,COMMITSTATUS>();
833                            
834                            static {
835                                    for(COMMITSTATUS s : EnumSet.allOf(COMMITSTATUS.class))
836                                            lookup.put(s.getId(), s);
837                            }
838                            
839                            private final int id;
840                            
841                            private COMMITSTATUS(int value) {
842                                    this.id = value;
843                            }
844                            
845                            public int getId() { return id; }
846                            
847                            public static COMMITSTATUS get(int code) {
848                                    return lookup.get(code);
849                            }
850                            
851                            public static COMMITSTATUS fromString(String s) {
852                                    for (COMMITSTATUS p : lookup.values()) {
853                                            if (p.toString() == s) {
854                                                    return p;
855                                            }
856                                    }
857                                    return null;
858                            }
859                    }
860                    
861                    /**
862                     *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. <br>
863                     */
864                    public void CancelServerCommit() {
865                    
866                            Request request = null;
867                            try {
868                                    request = new XCallRequest(5,15);
869                            } catch (IOException e) {
870                                    e.printStackTrace();
871                                    if (skype.errorListener != null)
872                                            skype.errorListener.OnSkypeKitFatalError();
873                            }
874                            request.addParm('O',0,mObjectId);
875                            
876                            skype.XCall((XCallRequest)request);
877                    }
878                    
879                    /**
880                    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 <br> */
881                    public enum CHATPOLICY {
882                    
883                            /** Unauthorized contacts can initiate text chat. <br>*/
884                            EVERYONE_CAN_ADD(0),
885                            
886                            /** Only authorized contacts can initiate chat (default policy). <br>*/
887                            BUDDIES_OR_AUTHORIZED_CAN_ADD(2);
888                            
889                            private static final Map<Integer,CHATPOLICY> lookup = new HashMap<Integer,CHATPOLICY>();
890                            
891                            static {
892                                    for(CHATPOLICY s : EnumSet.allOf(CHATPOLICY.class))
893                                            lookup.put(s.getId(), s);
894                            }
895                            
896                            private final int id;
897                            
898                            private CHATPOLICY(int value) {
899                                    this.id = value;
900                            }
901                            
902                            public int getId() { return id; }
903                            
904                            public static CHATPOLICY get(int code) {
905                                    return lookup.get(code);
906                            }
907                            
908                            public static CHATPOLICY fromString(String s) {
909                                    for (CHATPOLICY p : lookup.values()) {
910                                            if (p.toString() == s) {
911                                                    return p;
912                                            }
913                                    }
914                                    return null;
915                            }
916                    }
917                    
918                    /**
919                    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. <br> */
920                    public enum SKYPECALLPOLICY {
921                    
922                            /** Skype calls accepted from unauthorized contacts.*/
923                            EVERYONE_CAN_CALL(0),
924                            
925                            /** Skype calls not accepted from unauthorized contacts.*/
926                            BUDDIES_OR_AUTHORIZED_CAN_CALL(2);
927                            
928                            private static final Map<Integer,SKYPECALLPOLICY> lookup = new HashMap<Integer,SKYPECALLPOLICY>();
929                            
930                            static {
931                                    for(SKYPECALLPOLICY s : EnumSet.allOf(SKYPECALLPOLICY.class))
932                                            lookup.put(s.getId(), s);
933                            }
934                            
935                            private final int id;
936                            
937                            private SKYPECALLPOLICY(int value) {
938                                    this.id = value;
939                            }
940                            
941                            public int getId() { return id; }
942                            
943                            public static SKYPECALLPOLICY get(int code) {
944                                    return lookup.get(code);
945                            }
946                            
947                            public static SKYPECALLPOLICY fromString(String s) {
948                                    for (SKYPECALLPOLICY p : lookup.values()) {
949                                            if (p.toString() == s) {
950                                                    return p;
951                                            }
952                                    }
953                                    return null;
954                            }
955                    }
956                    
957                    /**
958                    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 <br> */
959                    public enum PSTNCALLPOLICY {
960                    
961                            /** All incoming PSTN calls are accepted.*/
962                            ALL_NUMBERS_CAN_CALL(0),
963                            
964                            /** Only PSTN calls that report caller ID are accepted.*/
965                            DISCLOSED_NUMBERS_CAN_CALL(1),
966                            
967                            /** Only calls from PSTN numbers found in local contact list are accepted.*/
968                            BUDDY_NUMBERS_CAN_CALL(2);
969                            
970                            private static final Map<Integer,PSTNCALLPOLICY> lookup = new HashMap<Integer,PSTNCALLPOLICY>();
971                            
972                            static {
973                                    for(PSTNCALLPOLICY s : EnumSet.allOf(PSTNCALLPOLICY.class))
974                                            lookup.put(s.getId(), s);
975                            }
976                            
977                            private final int id;
978                            
979                            private PSTNCALLPOLICY(int value) {
980                                    this.id = value;
981                            }
982                            
983                            public int getId() { return id; }
984                            
985                            public static PSTNCALLPOLICY get(int code) {
986                                    return lookup.get(code);
987                            }
988                            
989                            public static PSTNCALLPOLICY fromString(String s) {
990                                    for (PSTNCALLPOLICY p : lookup.values()) {
991                                            if (p.toString() == s) {
992                                                    return p;
993                                            }
994                                    }
995                                    return null;
996                            }
997                    }
998                    
999                    /**
1000                    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. <br>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. <br> */
1001                    public enum AVATARPOLICY {
1002                    
1003                            /** Only authorized remote users can see this user's avatar image*/
1004                            BUDDIES_OR_AUTHORIZED_CAN_SEE(0),
1005                            
1006                            /** 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.*/
1007                            EVERYONE_CAN_SEE(2);
1008                            
1009                            private static final Map<Integer,AVATARPOLICY> lookup = new HashMap<Integer,AVATARPOLICY>();
1010                            
1011                            static {
1012                                    for(AVATARPOLICY s : EnumSet.allOf(AVATARPOLICY.class))
1013                                            lookup.put(s.getId(), s);
1014                            }
1015                            
1016                            private final int id;
1017                            
1018                            private AVATARPOLICY(int value) {
1019                                    this.id = value;
1020                            }
1021                            
1022                            public int getId() { return id; }
1023                            
1024                            public static AVATARPOLICY get(int code) {
1025                                    return lookup.get(code);
1026                            }
1027                            
1028                            public static AVATARPOLICY fromString(String s) {
1029                                    for (AVATARPOLICY p : lookup.values()) {
1030                                            if (p.toString() == s) {
1031                                                    return p;
1032                                            }
1033                                    }
1034                                    return null;
1035                            }
1036                    }
1037                    
1038                    /**
1039                    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: <br>account->SetServersideIntProperty(Account.P_BUDDYCOUNT_POLICY, Account.DISCLOSE_TO_AUTHORIZED); <br>account->SetServersideIntProperty(Account.P_BUDDYCOUNT_POLICY, Account.DISCLOSE_TO_NOONE ); <br> */
1040                    public enum BUDDYCOUNTPOLICY {
1041                    
1042                            /** Authorized remote users can retrieve the number of this user's authorized contacts (Contact.P_NROF_AUTHED_BUDDIES)*/
1043                            DISCLOSE_TO_AUTHORIZED(0),
1044                            
1045                            /** 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*/
1046                            DISCLOSE_TO_NOONE(1);
1047                            
1048                            private static final Map<Integer,BUDDYCOUNTPOLICY> lookup = new HashMap<Integer,BUDDYCOUNTPOLICY>();
1049                            
1050                            static {
1051                                    for(BUDDYCOUNTPOLICY s : EnumSet.allOf(BUDDYCOUNTPOLICY.class))
1052                                            lookup.put(s.getId(), s);
1053                            }
1054                            
1055                            private final int id;
1056                            
1057                            private BUDDYCOUNTPOLICY(int value) {
1058                                    this.id = value;
1059                            }
1060                            
1061                            public int getId() { return id; }
1062                            
1063                            public static BUDDYCOUNTPOLICY get(int code) {
1064                                    return lookup.get(code);
1065                            }
1066                            
1067                            public static BUDDYCOUNTPOLICY fromString(String s) {
1068                                    for (BUDDYCOUNTPOLICY p : lookup.values()) {
1069                                            if (p.toString() == s) {
1070                                                    return p;
1071                                            }
1072                                    }
1073                                    return null;
1074                            }
1075                    }
1076                    
1077                    /**
1078                    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. */
1079                    public enum TIMEZONEPOLICY {
1080                    
1081                            /** Account's timezone setting is determined automatically. <br>*/
1082                            TZ_AUTOMATIC(0),
1083                            
1084                            /** Account's timezone setting is set manually. <br>*/
1085                            TZ_MANUAL(1),
1086                            
1087                            /** Remote users will have no idea what your local time is. <br>*/
1088                            TZ_UNDISCLOSED(2);
1089                            
1090                            private static final Map<Integer,TIMEZONEPOLICY> lookup = new HashMap<Integer,TIMEZONEPOLICY>();
1091                            
1092                            static {
1093                                    for(TIMEZONEPOLICY s : EnumSet.allOf(TIMEZONEPOLICY.class))
1094                                            lookup.put(s.getId(), s);
1095                            }
1096                            
1097                            private final int id;
1098                            
1099                            private TIMEZONEPOLICY(int value) {
1100                                    this.id = value;
1101                            }
1102                            
1103                            public int getId() { return id; }
1104                            
1105                            public static TIMEZONEPOLICY get(int code) {
1106                                    return lookup.get(code);
1107                            }
1108                            
1109                            public static TIMEZONEPOLICY fromString(String s) {
1110                                    for (TIMEZONEPOLICY p : lookup.values()) {
1111                                            if (p.toString() == s) {
1112                                                    return p;
1113                                            }
1114                                    }
1115                                    return null;
1116                            }
1117                    }
1118                    
1119                    /**
1120                    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. <br> */
1121                    public enum WEBPRESENCEPOLICY {
1122                    
1123                            /** Disable displaying online status on web for this account.*/
1124                            WEBPRESENCE_DISABLED(0),
1125                            
1126                            /** Enable displaying online status on web for this account.*/
1127                            WEBPRESENCE_ENABLED(1);
1128                            
1129                            private static final Map<Integer,WEBPRESENCEPOLICY> lookup = new HashMap<Integer,WEBPRESENCEPOLICY>();
1130                            
1131                            static {
1132                                    for(WEBPRESENCEPOLICY s : EnumSet.allOf(WEBPRESENCEPOLICY.class))
1133                                            lookup.put(s.getId(), s);
1134                            }
1135                            
1136                            private final int id;
1137                            
1138                            private WEBPRESENCEPOLICY(int value) {
1139                                    this.id = value;
1140                            }
1141                            
1142                            public int getId() { return id; }
1143                            
1144                            public static WEBPRESENCEPOLICY get(int code) {
1145                                    return lookup.get(code);
1146                            }
1147                            
1148                            public static WEBPRESENCEPOLICY fromString(String s) {
1149                                    for (WEBPRESENCEPOLICY p : lookup.values()) {
1150                                            if (p.toString() == s) {
1151                                                    return p;
1152                                            }
1153                                    }
1154                                    return null;
1155                            }
1156                    }
1157                    
1158                    /**
1159                    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 <br> */
1160                    public enum PHONENUMBERSPOLICY {
1161                    
1162                            /** Only authorized contacts can see the phone numbers.*/
1163                            PHONENUMBERS_VISIBLE_FOR_BUDDIES(0),
1164                            
1165                            /** Everyone can see the phone numbers.*/
1166                            PHONENUMBERS_VISIBLE_FOR_EVERYONE(1);
1167                            
1168                            private static final Map<Integer,PHONENUMBERSPOLICY> lookup = new HashMap<Integer,PHONENUMBERSPOLICY>();
1169                            
1170                            static {
1171                                    for(PHONENUMBERSPOLICY s : EnumSet.allOf(PHONENUMBERSPOLICY.class))
1172                                            lookup.put(s.getId(), s);
1173                            }
1174                            
1175                            private final int id;
1176                            
1177                            private PHONENUMBERSPOLICY(int value) {
1178                                    this.id = value;
1179                            }
1180                            
1181                            public int getId() { return id; }
1182                            
1183                            public static PHONENUMBERSPOLICY get(int code) {
1184                                    return lookup.get(code);
1185                            }
1186                            
1187                            public static PHONENUMBERSPOLICY fromString(String s) {
1188                                    for (PHONENUMBERSPOLICY p : lookup.values()) {
1189                                            if (p.toString() == s) {
1190                                                    return p;
1191                                            }
1192                                    }
1193                                    return null;
1194                            }
1195                    }
1196                    
1197                    /**
1198                    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. <br> */
1199                    public enum VOICEMAILPOLICY {
1200                    
1201                            /** Incoming voicemails enabled.*/
1202                            VOICEMAIL_ENABLED(0),
1203                            
1204                            /** Incoming voicemails disabled.*/
1205                            VOICEMAIL_DISABLED(1);
1206                            
1207                            private static final Map<Integer,VOICEMAILPOLICY> lookup = new HashMap<Integer,VOICEMAILPOLICY>();
1208                            
1209                            static {
1210                                    for(VOICEMAILPOLICY s : EnumSet.allOf(VOICEMAILPOLICY.class))
1211                                            lookup.put(s.getId(), s);
1212                            }
1213                            
1214                            private final int id;
1215                            
1216                            private VOICEMAILPOLICY(int value) {
1217                                    this.id = value;
1218                            }
1219                            
1220                            public int getId() { return id; }
1221                            
1222                            public static VOICEMAILPOLICY get(int code) {
1223                                    return lookup.get(code);
1224                            }
1225                            
1226                            public static VOICEMAILPOLICY fromString(String s) {
1227                                    for (VOICEMAILPOLICY p : lookup.values()) {
1228                                            if (p.toString() == s) {
1229                                                    return p;
1230                                            }
1231                                    }
1232                                    return null;
1233                            }
1234                    }
1235                    
1236                    /**
1237                     *Setter for integer properties. For a list of writeable account profile properties, see the detailed description of the Account class. <br>
1238                     * @param propKey
1239                     * @param value
1240                     */
1241                    public void SetIntProperty( int propKey, int value) {
1242                    
1243                            Request request = null;
1244                            try {
1245                                    request = new XCallRequest(5,16);
1246                            } catch (IOException e) {
1247                                    e.printStackTrace();
1248                                    if (skype.errorListener != null)
1249                                            skype.errorListener.OnSkypeKitFatalError();
1250                            }
1251                            request.addParm('O',0,mObjectId);
1252                            request.addParm('e',1,propKey);
1253                            request.addParm('u',2,value);
1254                            
1255                            skype.XCall((XCallRequest)request);
1256                    }
1257                    
1258                    /**
1259                     *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. <br>
1260                     * @param propKey
1261                     * @param value
1262                     */
1263                    public void SetStrProperty( int propKey, String value) {
1264                    
1265                            Request request = null;
1266                            try {
1267                                    request = new XCallRequest(5,17);
1268                            } catch (IOException e) {
1269                                    e.printStackTrace();
1270                                    if (skype.errorListener != null)
1271                                            skype.errorListener.OnSkypeKitFatalError();
1272                            }
1273                            request.addParm('O',0,mObjectId);
1274                            request.addParm('e',1,propKey);
1275                            request.addParm('S',2,value);
1276                            
1277                            skype.XCall((XCallRequest)request);
1278                    }
1279                    
1280                    /**
1281                     *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. <br>
1282                     * @param propKey
1283                     * @param value
1284                     */
1285                    public void SetBinProperty( int propKey, byte[] value) {
1286                    
1287                            Request request = null;
1288                            try {
1289                                    request = new XCallRequest(5,18);
1290                            } catch (IOException e) {
1291                                    e.printStackTrace();
1292                                    if (skype.errorListener != null)
1293                                            skype.errorListener.OnSkypeKitFatalError();
1294                            }
1295                            request.addParm('O',0,mObjectId);
1296                            request.addParm('e',1,propKey);
1297                            request.addParm('B',2,value);
1298                            
1299                            skype.XCall((XCallRequest)request);
1300                    }
1301                    
1302                    /**
1303                     *Sets online status of the currently logged in account to one of the values from Contact class AVAILABILITY enumerator. <br>
1304                     * @param availability only subset of all contact availabilities allowed
1305                     */
1306                    public void SetAvailability( Contact.AVAILABILITY availability) {
1307                    
1308                            Request request = null;
1309                            try {
1310                                    request = new XCallRequest(5,19);
1311                            } catch (IOException e) {
1312                                    e.printStackTrace();
1313                                    if (skype.errorListener != null)
1314                                            skype.errorListener.OnSkypeKitFatalError();
1315                            }
1316                            request.addParm('O',0,mObjectId);
1317                            request.addParm('e',1,availability.getId());
1318                            
1319                            skype.XCall((XCallRequest)request);
1320                    }
1321                    
1322                    /**
1323                     *Transitions the availability of this account's associated user, who is assumed to be logged in. <br>
1324                     * @param standby <br> - true: Saves the user's current availability, then sets it to CONTACT.AVAILABILITY.OFFLINE <br> - false: Reconnects the user and restores their previous availability
1325                     */
1326                    public void SetStandby( boolean standby) {
1327                    
1328                            Request request = null;
1329                            try {
1330                                    request = new XCallRequest(5,10);
1331                            } catch (IOException e) {
1332                                    e.printStackTrace();
1333                                    if (skype.errorListener != null)
1334                                            skype.errorListener.OnSkypeKitFatalError();
1335                            }
1336                            request.addParm('O',0,mObjectId);
1337                            request.addParm('b',1,standby);
1338                            
1339                            skype.XCall((XCallRequest)request);
1340                    }
1341                    
1342                    /**
1343                    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. <br> */
1344                    public enum CAPABILITYSTATUS {
1345                    
1346                            /** Capability is not supported by the currently logged in SkypeKit client.*/
1347                            NO_CAPABILITY(0),
1348                            
1349                            /** Capability is supported by the currently logged in SkypeKit client. <br>*/
1350                            CAPABILITY_EXISTS(1),
1351                            
1352                            /** Support for this capability ends this month (within 30 days) <br>*/
1353                            FIRST_EXPIRY_WARNING(2),
1354                            
1355                            /** Support for this capability ends this week (within 7 days)  <br>*/
1356                            SECOND_EXPIRY_WARNING(3),
1357                            
1358                            /** Support for this capability ends today <br>*/
1359                            FINAL_EXPIRY_WARNING(4);
1360                            
1361                            private static final Map<Integer,CAPABILITYSTATUS> lookup = new HashMap<Integer,CAPABILITYSTATUS>();
1362                            
1363                            static {
1364                                    for(CAPABILITYSTATUS s : EnumSet.allOf(CAPABILITYSTATUS.class))
1365                                            lookup.put(s.getId(), s);
1366                            }
1367                            
1368                            private final int id;
1369                            
1370                            private CAPABILITYSTATUS(int value) {
1371                                    this.id = value;
1372                            }
1373                            
1374                            public int getId() { return id; }
1375                            
1376                            public static CAPABILITYSTATUS get(int code) {
1377                                    return lookup.get(code);
1378                            }
1379                            
1380                            public static CAPABILITYSTATUS fromString(String s) {
1381                                    for (CAPABILITYSTATUS p : lookup.values()) {
1382                                            if (p.toString() == s) {
1383                                                    return p;
1384                                            }
1385                                    }
1386                                    return null;
1387                            }
1388                    }
1389                    
1390                    /**
1391                     *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. <br>
1392                     * @param capability
1393                     * @return GetCapabilityStatusResult
1394                     */
1395                    public GetCapabilityStatusResult GetCapabilityStatus( Contact.CAPABILITY capability) {
1396                    
1397                            Request request = null;
1398                            try {
1399                                    request = new XCallRequest(5,21);
1400                            } catch (IOException e) {
1401                                    e.printStackTrace();
1402                                    if (skype.errorListener != null)
1403                                            skype.errorListener.OnSkypeKitFatalError();
1404                            }
1405                            request.addParm('O',0,mObjectId);
1406                            request.addParm('e',1,capability.getId());
1407                            
1408                            Response r = skype.XCall((XCallRequest)request);
1409                            
1410                            if (r.isErrCall())
1411                                    return null;
1412                                    
1413                            GetCapabilityStatusResult result = new GetCapabilityStatusResult();
1414                            
1415                            CAPABILITYSTATUS capabilitystatus = null;
1416                            capabilitystatus = CAPABILITYSTATUS.get(r.GetAsInt(1));
1417                            result.status = capabilitystatus;
1418                            
1419                            int expiryTimestamp = 0;
1420                            expiryTimestamp = r.GetAsInt(2);
1421                            result.expiryTimestamp = expiryTimestamp;
1422                            
1423                            return result;
1424                    }
1425                    
1426                    public class GetCapabilityStatusResult {
1427                            public CAPABILITYSTATUS status;
1428                            public int expiryTimestamp;
1429                    }
1430                    
1431                    /**
1432                     *Response is empty when called with an inactive or invalid account
1433                     * @return skypenameHash
1434                     */
1435                    public String GetSkypenameHash() {
1436                    
1437                            Request request = null;
1438                            try {
1439                                    request = new XCallRequest(5,22);
1440                            } catch (IOException e) {
1441                                    e.printStackTrace();
1442                                    if (skype.errorListener != null)
1443                                            skype.errorListener.OnSkypeKitFatalError();
1444                            }
1445                            request.addParm('O',0,mObjectId);
1446                            
1447                            Response r = skype.XCall((XCallRequest)request);
1448                            
1449                            if (r.isErrCall())
1450                                    return null;
1451                                    
1452                            String skypenameHash = null;
1453                            skypenameHash = r.GetAsString(1);
1454                            return skypenameHash;
1455                    }
1456                    
1457                    /**
1458                     *returns verified-by-Skype e-mail for this account if exists and verifiable
1459                     * @return email
1460                     */
1461                    public String GetVerifiedEmail() {
1462                    
1463                            Request request = null;
1464                            try {
1465                                    request = new XCallRequest(5,2);
1466                            } catch (IOException e) {
1467                                    e.printStackTrace();
1468                                    if (skype.errorListener != null)
1469                                            skype.errorListener.OnSkypeKitFatalError();
1470                            }
1471                            request.addParm('O',0,mObjectId);
1472                            
1473                            Response r = skype.XCall((XCallRequest)request);
1474                            
1475                            if (r.isErrCall())
1476                                    return null;
1477                                    
1478                            String email = null;
1479                            email = r.GetAsString(1);
1480                            return email;
1481                    }
1482                    
1483                    /**
1484                     *returns verified-by-Skype company for this account if exists and verifiable
1485                     * @return company
1486                     */
1487                    public String GetVerifiedCompany() {
1488                    
1489                            Request request = null;
1490                            try {
1491                                    request = new XCallRequest(5,3);
1492                            } catch (IOException e) {
1493                                    e.printStackTrace();
1494                                    if (skype.errorListener != null)
1495                                            skype.errorListener.OnSkypeKitFatalError();
1496                            }
1497                            request.addParm('O',0,mObjectId);
1498                            
1499                            Response r = skype.XCall((XCallRequest)request);
1500                            
1501                            if (r.isErrCall())
1502                                    return null;
1503                                    
1504                            String company = null;
1505                            company = r.GetAsString(1);
1506                            return company;
1507                    }
1508                    
1509                    /**
1510                     *Deletes all account data stored locally. Does not remove any account data from the server! <br>
1511                     */
1512                    public void Delete() {
1513                    
1514                            Request request = null;
1515                            try {
1516                                    request = new XCallRequest(5,24);
1517                            } catch (IOException e) {
1518                                    e.printStackTrace();
1519                                    if (skype.errorListener != null)
1520                                            skype.errorListener.OnSkypeKitFatalError();
1521                            }
1522                            request.addParm('O',0,mObjectId);
1523                            
1524                            skype.XCall((XCallRequest)request);
1525                    }
1526                    
1527            
1528            }