    001    package com.skype.api;
    002
    003    import java.io.IOException;
    004    import java.util.Collections;
    005    import java.util.EnumSet;
    006    import java.util.HashMap;
    007    import java.util.Iterator;
    008    import java.util.Map;
    009    import java.util.Vector;
    010
    011    import com.skype.api.Account.AccountListener;
    012    import com.skype.api.Contact.ContactListener;
    013    import com.skype.api.ContactGroup.ContactGroupListener;
    014    import com.skype.api.ContactSearch.ContactSearchListener;
    015    import com.skype.api.Conversation.ConversationListener;
    016    import com.skype.api.Message.MessageListener;
    017    import com.skype.api.Participant.DTMF;
    018    import com.skype.api.Participant.ParticipantListener;
    019    import com.skype.api.Sms.SmsListener;
    020    import com.skype.api.Transfer.TransferListener;
    021    import com.skype.api.Video.VideoListener;
    022    import com.skype.api.Voicemail.VoicemailListener;
    023    import com.skype.ipc.AbstractDecoder;
    024    import com.skype.ipc.Event;
    025    import com.skype.ipc.PropertyChange;
    026    import com.skype.ipc.Request;
    027    import com.skype.ipc.Response;
    028    import com.skype.ipc.RootObject;
    029    import com.skype.ipc.XCallRequest;
    030
    031    public class Skype extends RootObject {
    032
    033
    034            public interface SkypeListener {
    035                    public void OnNewCustomContactGroup(ContactGroup group);
    036
    037                    /**This contact has appeared online. display alert*/
    038                    public void OnContactOnlineAppearance(Contact contact);
    039
    040                    /**This contact has gone offline. display alert*/
    041                    public void OnContactGoneOffline(Contact contact);
    042
    043                    /**This event gets fired when a Conversation item is added or removed from the list specified in the type argument. The primary use of this event is to detect creation of new Conversation objects. It can also be used for detecting occurance of live sessions - by monitoring added = true in Conversation.LIVE_CONVERSATIONS. Note that this method is not entirely sufficient for detecting live session termination (added = false and type = Conversation.LIVE_CONVERSATIONS). When the live session goes down, the default behaviour is that the Conversation object remains in the LIVE_CONVERSATIONS list for approximately 10 seconds. When another live session comes up within the same Conversation, the OnConversationListChange event will not fire - because the conversation was already in that list. There are two ways of getting around that. Firstly you can have all the conversations referenced at all times and then monitor Conversation.P_LOCAL_LIVESTATUS property changes, in which case you can pick up incoming live sessions from there. Alternatively, you can remove the delay between live session termination and conversation's removal from the LIVE_CONVERSATIONS list. This delay is controlled by the SETUPKEY_RECENTLY_LIVE_TIMEOUT setup key. To remove the delay, use Skype.SetInt(SETUPKEY_RECENTLY_LIVE_TIMEOUT, 0). Note that this setup key is account-based. You will need to have an account logged in in order to modify its value. <br>*/
    044                    public void OnConversationListChange(Conversation conversation, Conversation.LIST_TYPE type, boolean added);
    045
    046                    public void OnMessage(Message message, boolean changesInboxTimestamp, Message supersedesHistoryMessage, Conversation conversation);
    047
    048                    /**This callback gets fired when there are changes in the system video device list (USB webcam gets plugged in or is detached.) <br>*/
    049                    public void OnAvailableVideoDeviceListChange();
    050
    051                    /**This callback gets fired when there are changes in the system audio device list (USB headset gets plugged in or is detached.) <br>*/
    052                    public void OnAvailableDeviceListChange();
    053
    054                    /**This callback gets fired when the audio strength changes in either playback or recording audio streams. Useful for providing visual indicators of audio activity in your UI. <br>*/
    055                    public void OnNrgLevelsChange();
    056
    057                    public void OnProxyAuthFailure(PROXYTYPE type);
    058
    059            }
    060
    061            public HashMap<Integer, SkypeObject> object_list_base;
    062            public HashMap<Integer, Object> listeners_base;
    063            public Map<Integer, SkypeObject> object_list;
    064            public Map<Integer, Object> listeners;
    065
    066            private Skype skype;
    067
    068            public Skype() {
    069                    object_list_base = new HashMap<Integer, SkypeObject>();
    070                    listeners_base = new HashMap<Integer, Object>();
    071
    072                    object_list = Collections.synchronizedMap(object_list_base);
    073                    listeners = Collections.synchronizedMap(listeners_base);
    074                    skype = this;
    075            }
    076
    077            private static final int module_id = 0;
    078
    079            public static final int getmoduleid() {
    080                    return module_id;
    081            }
    082
    083            /** Register listener interface, need to pass module id as first param*/
    084            public void RegisterListener(int modid, Object listener)
    085            {
    086                    listeners.put(modid, listener);
    087            }
    088
    089            /** Remove listener interface, need to pass module id as first param*/
    090            public void UnRegisterListener(int modid, Object listener)
    091            {
    092                    if (listeners.containsKey(modid))
    093                            listeners.remove(modid);
    094            }
    095
    096            public void HandlePropertyChange(PropertyChange pc){
    097                    SkypeObject obj = null;
    098                    Object val = null;
    099                    Object prop = null;
    100
    101                    //check object exists in list and get value
    102                    if (object_list.containsKey(pc.oid))
    103                    {
    104                            obj = object_list.get(pc.oid);
    105                            int kind = pc.GetKind();
    106
    107                            switch (kind) {
    108                                    case 'i':
    109                                    case 'u':
    110                                    case 'e':
    111                                            try {
    112                                                    val = new Integer(pc.GetAsInt());
    113                                            } catch (IOException e) {
    114                                                    e.printStackTrace();
    115                                                    if (errorListener!=null)
    116                                                            errorListener.OnSkypeKitFatalError();
    117                                            }
    118                                            break;
    119                                    case 'T':
    120                                    case 'F':
    121                                            try {
    122                                                    val = new Boolean(pc.GetAsBoolean());
    123                                            } catch (IOException e) {
    124                                                    e.printStackTrace();
    125                                                    if (errorListener!=null)
    126                                                            errorListener.OnSkypeKitFatalError();
    127                                            }
    128                                            break;
    129                                    case 'S':
    130                                    case 'X':
    131                                    case 'f':
    132                                            try {
    133                                                    val = new String(pc.GetAsString());
    134                                            } catch (IOException e) {
    135                                                    e.printStackTrace();
    136                                                    if (errorListener!=null)
    137                                                            errorListener.OnSkypeKitFatalError();
    138                                            }
    139                                            break;
    140                                    case 'B':
    141                                            if (pc.hasValue()){
    142                                                    try {
    143                                                            val = new String(pc.GetAsBinary(0));
    144                                                    } catch (IOException e) {
    145                                                            e.printStackTrace();
    146                                                            if (errorListener!=null)
    147                                                                    errorListener.OnSkypeKitFatalError();
    148                                                    }
    149                                            }
    150                                            break;
    151                                    default:
    152                                            break;
    153                            }
    154
    155                            //update the property cache
    156                            if (val!=null) {
    157                                    obj.mPropCache.put(pc.propid, val);
    158                            }
    159                            else {
    160                                    obj.mPropCache.remove(pc.propid);
    161                            }
    162                            //call listener if this exists?
    163                            if (listeners.containsKey(pc.moid))
    164                             {
    165                                    Object listener = listeners.get(pc.moid);
    166                                    if (listener != null){
    167                                            prop = obj.GetPropertyAsEnum(pc.propid);
    168
    169                                            switch (pc.moid)
    170                                            {
    171                                            case 5: //Account
    172                                                    ((AccountListener) listener).OnPropertyChange(obj, (Account.PROPERTY)prop, val);
    173                                                    break;
    174
    175                                            case 2: //Contact
    176                                                    ((ContactListener) listener).OnPropertyChange(obj, (Contact.PROPERTY)prop, val);
    177                                                    break;
    178
    179                                            case 10: //ContactGroup
    180                                                    ((ContactGroupListener) listener).OnPropertyChange(obj, (ContactGroup.PROPERTY)prop, val);
    181                                                    break;
    182
    183                                            case 1: //ContactSearch
    184                                                    ((ContactSearchListener) listener).OnPropertyChange(obj, (ContactSearch.PROPERTY)prop, val);
    185                                                    break;
    186
    187                                            case 18: //Conversation
    188                                                    ((ConversationListener) listener).OnPropertyChange(obj, (Conversation.PROPERTY)prop, val);
    189                                                    break;
    190
    191                                            case 9: //Message
    192                                                    ((MessageListener) listener).OnPropertyChange(obj, (Message.PROPERTY)prop, val);
    193                                                    break;
    194
    195                                            case 19: //Participant
    196                                                    ((ParticipantListener) listener).OnPropertyChange(obj, (Participant.PROPERTY)prop, val);
    197                                                    break;
    198
    199                                            case 12: //Sms
    200                                                    ((SmsListener) listener).OnPropertyChange(obj, (Sms.PROPERTY)prop, val);
    201                                                    break;
    202
    203                                            case 6: //Transfer
    204                                                    ((TransferListener) listener).OnPropertyChange(obj, (Transfer.PROPERTY)prop, val);
    205                                                    break;
    206
    207                                            case 11: //Video
    208                                                    ((VideoListener) listener).OnPropertyChange(obj, (Video.PROPERTY)prop, val);
    209                                                    break;
    210
    211                                            case 7: //Voicemail
    212                                                    ((VoicemailListener) listener).OnPropertyChange(obj, (Voicemail.PROPERTY)prop, val);
    213                                                    break;
    214
    215                                            default:
    216                                                    break;
    217                                            }
    218                                    }
    219                            }
    220                    }
    221            }
    222
    223            @Override
    224            public void Close() throws IOException {
    225                    FlushObjects();
    226                    super.Close();
    227            }
    228
    229            /**Clear all Skypekit Objects and PROPERTIES in object cache */
    230            public void FlushObjects()
    231            {
    232                    Iterator<Integer> iter = object_list.keySet().iterator();
    233                    while (iter.hasNext()) {
    234                            Integer key = iter.next();
    235                            SkypeObject obj  = object_list.get(key);
    236                            obj.flush_cache();
    237                    }
    238                    object_list.clear();
    239            }
    240
    241            /** Mobile Mode related keys for Skypekit runtime*/
    242            private static final String mobileModeEnabled        = "*Lib/PM/MobileModeEnabled";
    243            private static final String superNodeKeepalivePeriod = "*Lib/Connection/SupernodeKeepalivePeriod";
    244            private static final String statsUpdatePeriod        = "*Lib/Connection/StatsUpdatePeriod";
    245
    246            private static final String IgnoreReadChatMsg     = "*Lib/Chat/IgnoreReadChatMsg";
    247
    248            /** Turn on Mobile Optimisations in Skypekit runtime and configure Skypekit not to send already read messages*/
    249            public void SetMobileMode () {
    250                    SetInt(mobileModeEnabled, 1);
    251                    SetInt(superNodeKeepalivePeriod, 600);
    252                    SetInt(statsUpdatePeriod, 600);
    253                    SetInt(IgnoreReadChatMsg, 1);}
    254
    255            /**Static method to retrieve Voicemail object from object id*/
    256            public Voicemail GetVoiceMailFromId(int oid, Skype skype)
    257            {
    258                    Voicemail vm = null;
    259                    if (skype.object_list.containsKey(oid))
    260                    {
    261                            vm = (Voicemail) skype.object_list.get(oid);
    262                    }
    263                    else
    264                    {
    265                            vm = new Voicemail(oid,skype);
    266                    }
    267                    return vm;
    268            }
    269
    270
    271            @Override
    272            public void HandleEvent(Event e) {
    273
    274                    HandleEvent_inner(e);
    275
    276            }
    277            public void HandleEvent_inner(Event e) {
    278                    if (listeners.containsKey(e.getModuleId())) {
    279
    280                            switch (e.getModuleId()) {
    281                            case 0: // Skype Listener Events
    282                                    SkypeListener skypelistener = (SkypeListener) listeners.get(e.getModuleId());
    283                                    if (skypelistener != null) {
    284
    285                                            switch (e.getEventId()) {
    286                                            case 1:  // OnNewCustomContactGroup
    287                                                    int  group01_oid = 0;
    288                                                    ContactGroup group01 = null;
    289                                                    group01_oid = e.GetOid(1);
    290                                                    if (group01_oid != AbstractDecoder.NULL_VALUE) {
    291                                                            group01 = (ContactGroup)skype.factory(ContactGroup.moduleID(), group01_oid, skype);
    292                                                    }
    293                                                    skypelistener.OnNewCustomContactGroup(group01);
    294                                                    break;
    295
    296                                            case 2:  // OnContactOnlineAppearance
    297                                                    int  contact02_oid = 0;
    298                                                    Contact contact02 = null;
    299                                                    contact02_oid = e.GetOid(1);
    300                                                    if (contact02_oid != AbstractDecoder.NULL_VALUE) {
    301                                                            contact02 = (Contact)skype.factory(Contact.moduleID(), contact02_oid, skype);
    302                                                    }
    303                                                    skypelistener.OnContactOnlineAppearance(contact02);
    304                                                    break;
    305
    306                                            case 3:  // OnContactGoneOffline
    307                                                    int  contact03_oid = 0;
    308                                                    Contact contact03 = null;
    309                                                    contact03_oid = e.GetOid(1);
    310                                                    if (contact03_oid != AbstractDecoder.NULL_VALUE) {
    311                                                            contact03 = (Contact)skype.factory(Contact.moduleID(), contact03_oid, skype);
    312                                                    }
    313                                                    skypelistener.OnContactGoneOffline(contact03);
    314                                                    break;
    315
    316                                            case 4:  // OnConversationListChange
    317                                                    int  conversation04_oid = 0;
    318                                                    Conversation conversation04 = null;
    319                                                    conversation04_oid = e.GetOid(1);
    320                                                    if (conversation04_oid != AbstractDecoder.NULL_VALUE) {
    321                                                            conversation04 = (Conversation)skype.factory(Conversation.moduleID(), conversation04_oid, skype);
    322                                                    }
    323                                                    Conversation.LIST_TYPE type04 = null;
    324                                                    type04 = Conversation.LIST_TYPE.get(e.GetAsInt(2));
    325                                                    boolean added04 = false;
    326                                                    added04 = e.GetAsBoolean(3);
    327                                                    skypelistener.OnConversationListChange(conversation04, type04, added04);
    328                                                    break;
    329
    330                                            case 5:  // OnMessage
    331                                                    int  message05_oid = 0;
    332                                                    Message message05 = null;
    333                                                    message05_oid = e.GetOid(1);
    334                                                    if (message05_oid != AbstractDecoder.NULL_VALUE) {
    335                                                            message05 = (Message)skype.factory(Message.moduleID(), message05_oid, skype);
    336                                                    }
    337                                                    boolean changesInboxTimestamp05 = false;
    338                                                    changesInboxTimestamp05 = e.GetAsBoolean(2);
    339                                                    int  supersedesHistoryMessage05_oid = 0;
    340                                                    Message supersedesHistoryMessage05 = null;
    341                                                    supersedesHistoryMessage05_oid = e.GetOid(3);
    342                                                    if (supersedesHistoryMessage05_oid != AbstractDecoder.NULL_VALUE) {
    343                                                            supersedesHistoryMessage05 = (Message)skype.factory(Message.moduleID(), supersedesHistoryMessage05_oid, skype);
    344                                                    }
    345                                                    int  conversation05_oid = 0;
    346                                                    Conversation conversation05 = null;
    347                                                    conversation05_oid = e.GetOid(4);
    348                                                    if (conversation05_oid != AbstractDecoder.NULL_VALUE) {
    349                                                            conversation05 = (Conversation)skype.factory(Conversation.moduleID(), conversation05_oid, skype);
    350                                                    }
    351                                                    skypelistener.OnMessage(message05, changesInboxTimestamp05, supersedesHistoryMessage05, conversation05);
    352                                                    ConversationListener cl = (ConversationListener)listeners.get(18);
    353                                                    if (cl != null) {
    354                                                            cl.OnMessage(conversation05, message05);
    355                                                    };
    356                                                    break;
    357
    358                                            case 7:  // OnAvailableVideoDeviceListChange
    359                                                    skypelistener.OnAvailableVideoDeviceListChange();
    360                                                    break;
    361
    362                                            case 10:  // OnAvailableDeviceListChange
    363                                                    skypelistener.OnAvailableDeviceListChange();
    364                                                    break;
    365
    366                                            case 11:  // OnNrgLevelsChange
    367                                                    skypelistener.OnNrgLevelsChange();
    368                                                    break;
    369
    370                                            case 12:  // OnProxyAuthFailure
    371                                                    PROXYTYPE type012 = null;
    372                                                    type012 = PROXYTYPE.get(e.GetAsInt(1));
    373                                                    skypelistener.OnProxyAuthFailure(type012);
    374                                                    break;
    375
    376                                            default:
    377                                                    break;
    378
    379                                            }
    380                                    }
    381                                    break;
    382
    383                                    case 10: // Module ContactGroup
    384                                            ContactGroupListener contactgrouplistener = (ContactGroupListener)listeners.get(e.getModuleId());
    385                                            if (contactgrouplistener != null) {
    386                                                    int contactgroup_oid = e.GetOid(0);
    387                                                    SkypeObject obj = skype.factory(e.getModuleId(), contactgroup_oid, skype);
    388
    389                                                    switch (e.getEventId()){
    390                                                    case 1: // Event OnChangeConversation
    391                                                            int conversation101_oid = 0;
    392                                                            Conversation conversation101 = null;
    393                                                            conversation101_oid = e.GetOid(1);
    394                                                            if (conversation101_oid != AbstractDecoder.NULL_VALUE) {
    395                                                                    conversation101 = (Conversation)skype.factory(Conversation.moduleID(), conversation101_oid, skype);
    396                                                            }
    397                                                            contactgrouplistener.OnChangeConversation(obj, conversation101);
    398                                                            break;
    399
    400                                                    case 2: // Event OnChange
    401                                                            int contact102_oid = 0;
    402                                                            Contact contact102 = null;
    403                                                            contact102_oid = e.GetOid(1);
    404                                                            if (contact102_oid != AbstractDecoder.NULL_VALUE) {
    405                                                                    contact102 = (Contact)skype.factory(Contact.moduleID(), contact102_oid, skype);
    406                                                            }
    407                                                            contactgrouplistener.OnChange(obj, contact102);
    408                                                            break;
    409
    410                                                    default:
    411                                                            break;
    412
    413                                                    }
    414                                            }
    415                                            break;
    416
    417                                    case 1: // Module ContactSearch
    418                                            ContactSearchListener contactsearchlistener = (ContactSearchListener)listeners.get(e.getModuleId());
    419                                            if (contactsearchlistener != null) {
    420                                                    int contactsearch_oid = e.GetOid(0);
    421                                                    SkypeObject obj = skype.factory(e.getModuleId(), contactsearch_oid, skype);
    422
    423                                                    switch (e.getEventId()){
    424                                                    case 1: // Event OnNewResult
    425                                                            int contact11_oid = 0;
    426                                                            Contact contact11 = null;
    427                                                            contact11_oid = e.GetOid(1);
    428                                                            if (contact11_oid != AbstractDecoder.NULL_VALUE) {
    429                                                                    contact11 = (Contact)skype.factory(Contact.moduleID(), contact11_oid, skype);
    430                                                            }
    431                                                            int rankValue11 = 0;
    432                                                            rankValue11 = e.GetAsInt(2);
    433                                                            contactsearchlistener.OnNewResult(obj, contact11, rankValue11);
    434                                                            break;
    435
    436                                                    default:
    437                                                            break;
    438
    439                                                    }
    440                                            }
    441                                            break;
    442
    443                                    case 19: // Module Participant
    444                                            ParticipantListener participantlistener = (ParticipantListener)listeners.get(e.getModuleId());
    445                                            if (participantlistener != null) {
    446                                                    int participant_oid = e.GetOid(0);
    447                                                    SkypeObject obj = skype.factory(e.getModuleId(), participant_oid, skype);
    448
    449                                                    switch (e.getEventId()){
    450                                                    case 1: // Event OnIncomingDTMF
    451                                                            DTMF dtmf191 = null;
    452                                                            dtmf191 = DTMF.get(e.GetAsInt(1));
    453                                                            participantlistener.OnIncomingDTMF(obj, dtmf191);
    454                                                            break;
    455
    456                                                    default:
    457                                                            break;
    458
    459                                                    }
    460                                            }
    461                                            break;
    462
    463                                    case 18: // Module Conversation
    464                                            ConversationListener conversationlistener = (ConversationListener)listeners.get(e.getModuleId());
    465                                            if (conversationlistener != null) {
    466                                                    int conversation_oid = e.GetOid(0);
    467                                                    SkypeObject obj = skype.factory(e.getModuleId(), conversation_oid, skype);
    468
    469                                                    switch (e.getEventId()){
    470                                                    case 1: // Event OnParticipantListChange
    471                                                            conversationlistener.OnParticipantListChange(obj);
    472                                                            break;
    473
    474                                                    case 2: // Event OnMessage
    475                                                            int message182_oid = 0;
    476                                                            Message message182 = null;
    477                                                            message182_oid = e.GetOid(1);
    478                                                            if (message182_oid != AbstractDecoder.NULL_VALUE) {
    479                                                                    message182 = (Message)skype.factory(Message.moduleID(), message182_oid, skype);
    480                                                            }
    481                                                            conversationlistener.OnMessage(obj, message182);
    482                                                            break;
    483
    484                                                    case 3: // Event OnSpawnConference
    485                                                            int spawned183_oid = 0;
    486                                                            Conversation spawned183 = null;
    487                                                            spawned183_oid = e.GetOid(1);
    488                                                            if (spawned183_oid != AbstractDecoder.NULL_VALUE) {
    489                                                                    spawned183 = (Conversation)skype.factory(Conversation.moduleID(), spawned183_oid, skype);
    490                                                            }
    491                                                            conversationlistener.OnSpawnConference(obj, spawned183);
    492                                                            break;
    493
    494                                                    default:
    495                                                            break;
    496
    497                                                    }
    498                                            }
    499                                            break;
    500
    501                                    case 11: // Module Video
    502                                            VideoListener videolistener = (VideoListener)listeners.get(e.getModuleId());
    503                                            if (videolistener != null) {
    504                                                    int video_oid = e.GetOid(0);
    505                                                    SkypeObject obj = skype.factory(e.getModuleId(), video_oid, skype);
    506
    507                                                    switch (e.getEventId()){
    508                                                    case 2: // Event OnCaptureRequestCompleted
    509                                                            int requestId112 = 0;
    510                                                            requestId112 = e.GetAsInt(1);
    511                                                            boolean isSuccessful112 = false;
    512                                                            isSuccessful112 = e.GetAsBoolean(2);
    513                                                            byte[] image112 = null;
    514                                                            image112 = e.GetAsBinary(3);
    515                                                            int width112 = 0;
    516                                                            width112 = e.GetAsInt(4);
    517                                                            int height112 = 0;
    518                                                            height112 = e.GetAsInt(5);
    519                                                            videolistener.OnCaptureRequestCompleted(obj, requestId112, isSuccessful112, image112, width112, height112);
    520                                                            break;
    521
    522                                                    case 1: // Event OnLastFrameCapture
    523                                                            byte[] image111 = null;
    524                                                            image111 = e.GetAsBinary(1);
    525                                                            int width111 = 0;
    526                                                            width111 = e.GetAsInt(2);
    527                                                            int height111 = 0;
    528                                                            height111 = e.GetAsInt(3);
    529                                                            videolistener.OnLastFrameCapture(obj, image111, width111, height111);
    530                                                            break;
    531
    532                                                    default:
    533                                                            break;
    534
    535                                                    }
    536                                            }
    537                                            break;
    538
    539                                    default:
    540                                            break;
    541
    542                            }
    543                    }
    544            }
    545
    546            /**
    547             * @return started
    548             */
    549            public boolean Start() {
    550
    551                    Request request = null;
    552                    try {
    553                            request = new XCallRequest(0,145);
    554                    } catch (IOException e) {
    555                            e.printStackTrace();
    556                            if (errorListener != null)
    557                                    errorListener.OnSkypeKitFatalError();
    558                    }
    559
    560                    Response r = XCall((XCallRequest)request);
    561
    562                    if (r.isErrCall())
    563                            return false;
    564
    565                    boolean started = false;
    566                    started = r.GetAsBoolean(1);
    567                    return started;
    568            }
    569
    570            /** Setupkey SETUPKEY_DB_STORAGE_QUOTA_KB type:int default value:"0" <br>Use this key to limit the size of the main.db file. Value is in KB. Quota are disabled by default. <br>This setup key is machine-specific and affects all local accounts. <br> */
    571            public static final String DB_STORAGE_QUOTA_KB = "*Lib/DbManager/StorageQuotaKb";
    572
    573            /**
    574             *returns the runtime version as a string
    575             * @return version
    576             */
    577            public String GetVersionString() {
    578
    579                    Request request = null;
    580                    try {
    581                            request = new XCallRequest(0,28);
    582                    } catch (IOException e) {
    583                            e.printStackTrace();
    584                            if (errorListener != null)
    585                                    errorListener.OnSkypeKitFatalError();
    586                    }
    587
    588                    Response r = XCall((XCallRequest)request);
    589
    590                    if (r.isErrCall())
    591                            return null;
    592
    593                    String version = null;
    594                    version = r.GetAsString(1);
    595                    return version;
    596            }
    597
    598            /**
    599             *Takes TYPE argument (TYPE comes from ContactGroup class) and returns reference to the corresponding hardwired contact group. For example (C++): skype->GetHardwiredContactGroup(ContactGroup.ONLINE_BUDDIES, GroupRef) would return the list of all contacts that are currently online. <br>
    600             * @param type
    601             * @return contactGroup
    602             */
    603            public ContactGroup GetHardwiredContactGroup( ContactGroup.TYPE type) {
    604
    605                    Request request = null;
    606                    try {
    607                            request = new XCallRequest(0,1);
    608                    } catch (IOException e) {
    609                            e.printStackTrace();
    610                            if (errorListener != null)
    611                                    errorListener.OnSkypeKitFatalError();
    612                    }
    613                    request.addParm('e',1,type.getId());
    614
    615                    Response r = XCall((XCallRequest)request);
    616
    617                    if (r.isErrCall())
    618                            return null;
    619
    620                    int oid = 0;
    621                    ContactGroup contactGroup = null;
    622                    oid = r.GetOid(1);
    623                    if (oid != AbstractDecoder.NULL_VALUE) {
    624                            contactGroup = (ContactGroup)skype.factory(ContactGroup.moduleID(), oid, skype);
    625                    }
    626                    return contactGroup;
    627            }
    628
    629            /**
    630             *Returns a list of custom contact group references, i.e. all contact groups that are not hardwired. <br>
    631             * @return groups
    632             */
    633            public ContactGroup [] GetCustomContactGroups() {
    634
    635                    Request request = null;
    636                    try {
    637                            request = new XCallRequest(0,2);
    638                    } catch (IOException e) {
    639                            e.printStackTrace();
    640                            if (errorListener != null)
    641                                    errorListener.OnSkypeKitFatalError();
    642                    }
    643
    644                    Response r = XCall((XCallRequest)request);
    645
    646                    if (r.isErrCall())
    647                            return null;
    648
    649                    Vector<ContactGroup> groups = new Vector<ContactGroup>();
    650                    while (r.HasMore(1))
    651                    {
    652                            int oid = 0;
    653                            ContactGroup contactgroup = null;
    654                            oid = r.GetOid(1);
    655                            if (oid != AbstractDecoder.NULL_VALUE) {
    656                                    contactgroup = (ContactGroup)skype.factory(ContactGroup.moduleID(), oid, skype);
    657                            }
    658                            groups.add(contactgroup);
    659                    }
    660                    return groups.toArray(new ContactGroup[groups.size()]);
    661
    662            }
    663
    664            /**
    665             *Creates a new empty contact group object and returns a reference to it. The group will then show up in the custom group list that you can get with Skype class GetCustomContactGroups method. Existing contacts can be added to the new group with ContactGroup class AddContact method and a custom name can be given to it with GiveDisplayName method. <br>Note that no check is made for existing of displaynames with the same name - if you wish to force uniqueness in custom group names you will have to check that yourself before creating the group. <br>
    666             * @return group
    667             */
    668            public ContactGroup CreateCustomContactGroup() {
    669
    670                    Request request = null;
    671                    try {
    672                            request = new XCallRequest(0,3);
    673                    } catch (IOException e) {
    674                            e.printStackTrace();
    675                            if (errorListener != null)
    676                                    errorListener.OnSkypeKitFatalError();
    677                    }
    678
    679                    Response r = XCall((XCallRequest)request);
    680
    681                    if (r.isErrCall())
    682                            return null;
    683
    684                    int oid = 0;
    685                    ContactGroup group = null;
    686                    oid = r.GetOid(1);
    687                    if (oid != AbstractDecoder.NULL_VALUE) {
    688                            group = (ContactGroup)skype.factory(ContactGroup.moduleID(), oid, skype);
    689                    }
    690                    return group;
    691            }
    692
    693            /**
    694             *analyzes the identity for contact type
    695             * @param identity
    696             * @return type
    697             */
    698            public Contact.TYPE GetContactType( String identity) {
    699
    700                    Request request = null;
    701                    try {
    702                            request = new XCallRequest(0,5);
    703                    } catch (IOException e) {
    704                            e.printStackTrace();
    705                            if (errorListener != null)
    706                                    errorListener.OnSkypeKitFatalError();
    707                    }
    708                    request.addParm('S',1,identity);
    709
    710                    Response r = XCall((XCallRequest)request);
    711
    712                    if (r.isErrCall())
    713                            return null;
    714
    715                    Contact.TYPE type = null;
    716                    type = Contact.TYPE.get(r.GetAsInt(1));
    717                    return type;
    718            }
    719
    720            /**
    721             *Returns a Contact object reference. If a matching contact is not found in the existing contact list, a new Contact object will be created. Note that if you pass in a phone number in the identity argument, the type for the newly created Contact will be automatically set to Contact.PSTN (Contact.SKYPE otherwise). <br>
    722             * @param identity Either skypename or a phone number <br>
    723             * @return contact Returns a contact object. <br>
    724             */
    725            public Contact GetContact( String identity) {
    726
    727                    Request request = null;
    728                    try {
    729                            request = new XCallRequest(0,6);
    730                    } catch (IOException e) {
    731                            e.printStackTrace();
    732                            if (errorListener != null)
    733                                    errorListener.OnSkypeKitFatalError();
    734                    }
    735                    request.addParm('S',1,identity);
    736
    737                    Response r = XCall((XCallRequest)request);
    738
    739                    if (r.isErrCall())
    740                            return null;
    741
    742                    int oid = 0;
    743                    Contact contact = null;
    744                    oid = r.GetOid(2);
    745                    if (oid != AbstractDecoder.NULL_VALUE) {
    746                            contact = (Contact)skype.factory(Contact.moduleID(), oid, skype);
    747                    }
    748                    return contact;
    749            }
    750
    751            /**
    752             * @param number
    753             * @return FindContactByPstnNumberResult
    754             */
    755            public FindContactByPstnNumberResult FindContactByPstnNumber( String number) {
    756
    757                    Request request = null;
    758                    try {
    759                            request = new XCallRequest(0,8);
    760                    } catch (IOException e) {
    761                            e.printStackTrace();
    762                            if (errorListener != null)
    763                                    errorListener.OnSkypeKitFatalError();
    764                    }
    765                    request.addParm('S',1,number);
    766
    767                    Response r = XCall((XCallRequest)request);
    768
    769                    if (r.isErrCall())
    770                            return null;
    771
    772                    FindContactByPstnNumberResult result = new FindContactByPstnNumberResult();
    773
    774                    boolean found = false;
    775                    found = r.GetAsBoolean(1);
    776                    result.found = found;
    777
    778                    int oid = 0;
    779                    Contact contact = null;
    780                    oid = r.GetOid(2);
    781                    if (oid != AbstractDecoder.NULL_VALUE) {
    782                            contact = (Contact)skype.factory(Contact.moduleID(), oid, skype);
    783                    }
    784                    result.contact = contact;
    785
    786                    int foundInKey = 0;
    787                    foundInKey = r.GetAsInt(3);
    788                    result.foundInKey = foundInKey;
    789
    790                    return result;
    791            }
    792
    793            public class FindContactByPstnNumberResult {
    794                    public boolean found;
    795                    public Contact contact;
    796                    public int foundInKey; /** type is actually PROPKEY */
    797            }
    798
    799            /**
    800             */
    801            public enum IDENTITYTYPE {
    802
    803                    /** */
    804                    UNRECOGNIZED(0),
    805
    806                    /** */
    807                    SKYPE(1),
    808
    809                    /** */
    810                    SKYPE_MYSELF(2),
    811
    812                    /** */
    813                    SKYPE_UNDISCLOSED(3),
    814
    815                    /** */
    816                    PSTN(4),
    817
    818                    /** */
    819                    PSTN_EMERGENCY(5),
    820
    821                    /** */
    822                    PSTN_FREE(6),
    823
    824                    /** */
    825                    PSTN_UNDISCLOSED(7),
    826
    827                    /** */
    828                    CONFERENCE(8),
    829
    830                    /** */
    831                    EXTERNAL(9);
    832
    833                    private static final Map<Integer,IDENTITYTYPE> lookup = new HashMap<Integer,IDENTITYTYPE>();
    834
    835                    static {
    836                            for(IDENTITYTYPE s : EnumSet.allOf(IDENTITYTYPE.class))
    837                                    lookup.put(s.getId(), s);
    838                    }
    839
    840                    private final int id;
    841
    842                    private IDENTITYTYPE(int value) {
    843                            this.id = value;
    844                    }
    845
    846                    public int getId() { return id; }
    847
    848                    public static IDENTITYTYPE get(int code) {
    849                            return lookup.get(code);
    850                    }
    851
    852                    public static IDENTITYTYPE fromString(String s) {
    853                            for (IDENTITYTYPE p : lookup.values()) {
    854                                    if (p.toString() == s) {
    855                                            return p;
    856                                    }
    857                            }
    858                            return null;
    859                    }
    860            }
    861
    862            /**
    863             *This takes skypename or a phone number string as argument and returns corresponding identity type (SKYPE, SKYPE_MYSELF, PSTN, etc.) <br>
    864             * @param identity
    865             * @return type
    866             */
    867            public IDENTITYTYPE GetIdentityType( String identity) {
    868
    869                    Request request = null;
    870                    try {
    871                            request = new XCallRequest(0,19);
    872                    } catch (IOException e) {
    873                            e.printStackTrace();
    874                            if (errorListener != null)
    875                                    errorListener.OnSkypeKitFatalError();
    876                    }
    877                    request.addParm('S',1,identity);
    878
    879                    Response r = XCall((XCallRequest)request);
    880
    881                    if (r.isErrCall())
    882                            return null;
    883
    884                    IDENTITYTYPE identitytype = null;
    885                    identitytype = IDENTITYTYPE.get(r.GetAsInt(1));
    886                    return identitytype;
    887            }
    888
    889            /**
    890             */
    891            public enum NORMALIZERESULT {
    892
    893                    /** */
    894                    IDENTITY_OK(0),
    895
    896                    /** */
    897                    IDENTITY_EMPTY(1),
    898
    899                    /** */
    900                    IDENTITY_TOO_LONG(2),
    901
    902                    /** */
    903                    IDENTITY_CONTAINS_INVALID_CHAR(3),
    904
    905                    /** */
    906                    PSTN_NUMBER_TOO_SHORT(4),
    907
    908                    /** identity looks like pstn number but does not start with +/00/011*/
    909                    PSTN_NUMBER_HAS_INVALID_PREFIX(5),
    910
    911                    /** */
    912                    SKYPENAME_STARTS_WITH_NONALPHA(6),
    913
    914                    /** returned only when isNewSkypeName*/
    915                    SKYPENAME_SHORTER_THAN_6_CHARS(7);
    916
    917                    private static final Map<Integer,NORMALIZERESULT> lookup = new HashMap<Integer,NORMALIZERESULT>();
    918
    919                    static {
    920                            for(NORMALIZERESULT s : EnumSet.allOf(NORMALIZERESULT.class))
    921                                    lookup.put(s.getId(), s);
    922                    }
    923
    924                    private final int id;
    925
    926                    private NORMALIZERESULT(int value) {
    927                            this.id = value;
    928                    }
    929
    930                    public int getId() { return id; }
    931
    932                    public static NORMALIZERESULT get(int code) {
    933                            return lookup.get(code);
    934                    }
    935
    936                    public static NORMALIZERESULT fromString(String s) {
    937                            for (NORMALIZERESULT p : lookup.values()) {
    938                                    if (p.toString() == s) {
    939                                            return p;
    940                                    }
    941                            }
    942                            return null;
    943                    }
    944            }
    945
    946            /**
    947             *compares two identities to see if they match
    948             * @param identityA
    949             * @param identityB
    950             * @return result
    951             */
    952            public boolean IdentitiesMatch( String identityA, String identityB) {
    953
    954                    Request request = null;
    955                    try {
    956                            request = new XCallRequest(0,88);
    957                    } catch (IOException e) {
    958                            e.printStackTrace();
    959                            if (errorListener != null)
    960                                    errorListener.OnSkypeKitFatalError();
    961                    }
    962                    request.addParm('S',1,identityA);
    963                    request.addParm('S',2,identityB);
    964
    965                    Response r = XCall((XCallRequest)request);
    966
    967                    if (r.isErrCall())
    968                            return false;
    969
    970                    boolean result = false;
    971                    result = r.GetAsBoolean(1);
    972                    return result;
    973            }
    974
    975            /**
    976             *This method is deprecated. Use ValidateProfileString method instead. <br>
    977             * @param original
    978             * @param isNewSkypeName
    979             * @return NormalizeIdentityResult
    980             */
    981            public NormalizeIdentityResult NormalizeIdentity( String original, boolean isNewSkypeName) {
    982
    983                    Request request = null;
    984                    try {
    985                            request = new XCallRequest(0,9);
    986                    } catch (IOException e) {
    987                            e.printStackTrace();
    988                            if (errorListener != null)
    989                                    errorListener.OnSkypeKitFatalError();
    990                    }
    991                    request.addParm('S',1,original);
    992                    request.addParm('b',2,isNewSkypeName);
    993
    994                    Response r = XCall((XCallRequest)request);
    995
    996                    if (r.isErrCall())
    997                            return null;
    998
    999                    NormalizeIdentityResult result = new NormalizeIdentityResult();
    1000
    1001                    NORMALIZERESULT normalizeresult = null;
    1002                    normalizeresult = NORMALIZERESULT.get(r.GetAsInt(1));
    1003                    result.result = normalizeresult;
    1004
    1005                    String normalized = null;
    1006                    normalized = r.GetAsString(2);
    1007                    result.normalized = normalized;
    1008
    1009                    return result;
    1010            }
    1011
    1012            public class NormalizeIdentityResult {
    1013                    public NORMALIZERESULT result;
    1014                    public String normalized;
    1015            }
    1016
    1017            /**
    1018             *NormalizePSTNWithCountry checks if the phone number starts with + if it doesn't, it prefixes the output with +XXX (where XXX is the country code). It also converts letters to numbers based on the standard phone keypad, so that the phone number string 212CALLME1 with country code 372 (Estonia) would be normalized to +3722122255631. If the method cannot normalize the phone number (because it's too long, too short, etc.), it returns an error code in &result. <br>
    1019             * @param original
    1020             * @param countryPrefix
    1021             * @return NormalizePSTNWithCountryResult
    1022             */
    1023            public NormalizePSTNWithCountryResult NormalizePSTNWithCountry( String original, int countryPrefix) {
    1024
    1025                    Request request = null;
    1026                    try {
    1027                            request = new XCallRequest(0,205);
    1028                    } catch (IOException e) {
    1029                            e.printStackTrace();
    1030                            if (errorListener != null)
    1031                                    errorListener.OnSkypeKitFatalError();
    1032                    }
    1033                    request.addParm('S',1,original);
    1034                    request.addParm('u',2,countryPrefix);
    1035
    1036                    Response r = XCall((XCallRequest)request);
    1037
    1038                    if (r.isErrCall())
    1039                            return null;
    1040
    1041                    NormalizePSTNWithCountryResult result = new NormalizePSTNWithCountryResult();
    1042
    1043                    NORMALIZERESULT normalizeresult = null;
    1044                    normalizeresult = NORMALIZERESULT.get(r.GetAsInt(1));
    1045                    result.result = normalizeresult;
    1046
    1047                    String normalized = null;
    1048                    normalized = r.GetAsString(2);
    1049                    result.normalized = normalized;
    1050
    1051                    return result;
    1052            }
    1053
    1054            public class NormalizePSTNWithCountryResult {
    1055                    public NORMALIZERESULT result;
    1056                    public String normalized;
    1057            }
    1058
    1059            /**
    1060             *list of (min,max) pairs
    1061             * @return rangeList
    1062             */
    1063            public int [] GetOptimalAgeRanges() {
    1064
    1065                    Request request = null;
    1066                    try {
    1067                            request = new XCallRequest(0,77);
    1068                    } catch (IOException e) {
    1069                            e.printStackTrace();
    1070                            if (errorListener != null)
    1071                                    errorListener.OnSkypeKitFatalError();
    1072                    }
    1073
    1074                    Response r = XCall((XCallRequest)request);
    1075
    1076                    if (r.isErrCall())
    1077                            return null;
    1078
    1079                    Vector<Integer> rangeList = new Vector<Integer>();
    1080                    while (r.HasMore(1))
    1081                    {
    1082                            Integer integer = null;
    1083                            integer = new Integer(r.GetAsInt(1));
    1084                            rangeList.add(integer);
    1085                    }
    1086
    1087                    int[] intArray = new int[rangeList.size()];
    1088                    for (int i = 0; i < rangeList.size(); i++) {
    1089                            intArray[i] = rangeList.get(i);
    1090                    }
    1091                    return intArray;
    1092            }
    1093
    1094            /**
    1095             *Creates a blank contact search object, in which you can add your custom search terms. For more information how asynchronous contact search works, see ContactSearch class details. <br>
    1096             * @return search Returns blank ContactSearch object. <br>
    1097             */
    1098            public ContactSearch CreateContactSearch() {
    1099
    1100                    Request request = null;
    1101                    try {
    1102                            request = new XCallRequest(0,10);
    1103                    } catch (IOException e) {
    1104                            e.printStackTrace();
    1105                            if (errorListener != null)
    1106                                    errorListener.OnSkypeKitFatalError();
    1107                    }
    1108
    1109                    Response r = XCall((XCallRequest)request);
    1110
    1111                    if (r.isErrCall())
    1112                            return null;
    1113
    1114                    int oid = 0;
    1115                    ContactSearch search = null;
    1116                    oid = r.GetOid(1);
    1117                    if (oid != AbstractDecoder.NULL_VALUE) {
    1118                            search = (ContactSearch)skype.factory(ContactSearch.moduleID(), oid, skype);
    1119                    }
    1120                    return search;
    1121            }
    1122
    1123            /**
    1124             *searches skypenames, aliases, fullnames, emails. false if not valid
    1125             * @param text
    1126             * @return search
    1127             */
    1128            public ContactSearch CreateBasicContactSearch( String text) {
    1129
    1130                    Request request = null;
    1131                    try {
    1132                            request = new XCallRequest(0,11);
    1133                    } catch (IOException e) {
    1134                            e.printStackTrace();
    1135                            if (errorListener != null)
    1136                                    errorListener.OnSkypeKitFatalError();
    1137                    }
    1138                    request.addParm('S',1,text);
    1139
    1140                    Response r = XCall((XCallRequest)request);
    1141
    1142                    if (r.isErrCall())
    1143                            return null;
    1144
    1145                    int oid = 0;
    1146                    ContactSearch search = null;
    1147                    oid = r.GetOid(1);
    1148                    if (oid != AbstractDecoder.NULL_VALUE) {
    1149                            search = (ContactSearch)skype.factory(ContactSearch.moduleID(), oid, skype);
    1150                    }
    1151                    return search;
    1152            }
    1153
    1154            /**
    1155             *searches skypenames and aliases. returns 0 or 1 results. false if not valid
    1156             * @param identity
    1157             * @return search
    1158             */
    1159            public ContactSearch CreateIdentitySearch( String identity) {
    1160
    1161                    Request request = null;
    1162                    try {
    1163                            request = new XCallRequest(0,12);
    1164                    } catch (IOException e) {
    1165                            e.printStackTrace();
    1166                            if (errorListener != null)
    1167                                    errorListener.OnSkypeKitFatalError();
    1168                    }
    1169                    request.addParm('S',1,identity);
    1170
    1171                    Response r = XCall((XCallRequest)request);
    1172
    1173                    if (r.isErrCall())
    1174                            return null;
    1175
    1176                    int oid = 0;
    1177                    ContactSearch search = null;
    1178                    oid = r.GetOid(1);
    1179                    if (oid != AbstractDecoder.NULL_VALUE) {
    1180                            search = (ContactSearch)skype.factory(ContactSearch.moduleID(), oid, skype);
    1181                    }
    1182                    return search;
    1183            }
    1184
    1185            /**
    1186            sync failure reasons when starting a transfer */
    1187            public enum TRANSFER_SENDFILE_ERROR {
    1188
    1189                    /** */
    1190                    TRANSFER_OPEN_SUCCESS(0),
    1191
    1192                    /** */
    1193                    TRANSFER_BAD_FILENAME(1),
    1194
    1195                    /** */
    1196                    TRANSFER_OPEN_FAILED(2),
    1197
    1198                    /** */
    1199                    TRANSFER_TOO_MANY_PARALLEL(3);
    1200
    1201                    private static final Map<Integer,TRANSFER_SENDFILE_ERROR> lookup = new HashMap<Integer,TRANSFER_SENDFILE_ERROR>();
    1202
    1203                    static {
    1204                            for(TRANSFER_SENDFILE_ERROR s : EnumSet.allOf(TRANSFER_SENDFILE_ERROR.class))
    1205                                    lookup.put(s.getId(), s);
    1206                    }
    1207
    1208                    private final int id;
    1209
    1210                    private TRANSFER_SENDFILE_ERROR(int value) {
    1211                            this.id = value;
    1212                    }
    1213
    1214                    public int getId() { return id; }
    1215
    1216                    public static TRANSFER_SENDFILE_ERROR get(int code) {
    1217                            return lookup.get(code);
    1218                    }
    1219
    1220                    public static TRANSFER_SENDFILE_ERROR fromString(String s) {
    1221                            for (TRANSFER_SENDFILE_ERROR p : lookup.values()) {
    1222                                    if (p.toString() == s) {
    1223                                            return p;
    1224                                    }
    1225                            }
    1226                            return null;
    1227                    }
    1228            }
    1229
    1230            /**
    1231             *Creates a new empty conversation object and returns a reference to it. <br>
    1232             * @return conference
    1233             */
    1234            public Conversation CreateConference() {
    1235
    1236                    Request request = null;
    1237                    try {
    1238                            request = new XCallRequest(0,13);
    1239                    } catch (IOException e) {
    1240                            e.printStackTrace();
    1241                            if (errorListener != null)
    1242                                    errorListener.OnSkypeKitFatalError();
    1243                    }
    1244
    1245                    Response r = XCall((XCallRequest)request);
    1246
    1247                    if (r.isErrCall())
    1248                            return null;
    1249
    1250                    int oid = 0;
    1251                    Conversation conference = null;
    1252                    oid = r.GetOid(1);
    1253                    if (oid != AbstractDecoder.NULL_VALUE) {
    1254                            conference = (Conversation)skype.factory(Conversation.moduleID(), oid, skype);
    1255                    }
    1256                    return conference;
    1257            }
    1258
    1259            /**
    1260             *Returns reference tp conversation object by conversation ID string (equivalent of old chat ID). NB! ID here is that of conversation, rather than skypename of dialog partner. If you want to retrieve a conversation object with any particular person, then Skype class GetConversationByParticipants method is what you are looking for. <br>
    1261             * @param convoIdentity
    1262             * @return conversation
    1263             */
    1264            public Conversation GetConversationByIdentity( String convoIdentity) {
    1265
    1266                    Request request = null;
    1267                    try {
    1268                            request = new XCallRequest(0,15);
    1269                    } catch (IOException e) {
    1270                            e.printStackTrace();
    1271                            if (errorListener != null)
    1272                                    errorListener.OnSkypeKitFatalError();
    1273                    }
    1274                    request.addParm('S',1,convoIdentity);
    1275
    1276                    Response r = XCall((XCallRequest)request);
    1277
    1278                    if (r.isErrCall())
    1279                            return null;
    1280
    1281                    int oid = 0;
    1282                    Conversation conversation = null;
    1283                    oid = r.GetOid(1);
    1284                    if (oid != AbstractDecoder.NULL_VALUE) {
    1285                            conversation = (Conversation)skype.factory(Conversation.moduleID(), oid, skype);
    1286                    }
    1287                    return conversation;
    1288            }
    1289
    1290            /**
    1291             *myself not included
    1292             * @param participantIdentities
    1293             * @param createIfNonExisting
    1294             * @param ignoreBookmarkedOrNamed
    1295             * @return conversation
    1296             */
    1297            public Conversation GetConversationByParticipants( String [] participantIdentities, boolean createIfNonExisting, boolean ignoreBookmarkedOrNamed) {
    1298
    1299                    Request request = null;
    1300                    try {
    1301                            request = new XCallRequest(0,16);
    1302                    } catch (IOException e) {
    1303                            e.printStackTrace();
    1304                            if (errorListener != null)
    1305                                    errorListener.OnSkypeKitFatalError();
    1306                    }
    1307                    request.addListStart(1);
    1308                    for (int i=0;i<participantIdentities.length;i++) {
    1309                            request.addParm('S',participantIdentities[i]);
    1310                    }
    1311                    request.addParm('b',2,createIfNonExisting);
    1312                    request.addParm('b',3,ignoreBookmarkedOrNamed);
    1313
    1314                    Response r = XCall((XCallRequest)request);
    1315
    1316                    if (r.isErrCall())
    1317                            return null;
    1318
    1319                    int oid = 0;
    1320                    Conversation conversation = null;
    1321                    oid = r.GetOid(1);
    1322                    if (oid != AbstractDecoder.NULL_VALUE) {
    1323                            conversation = (Conversation)skype.factory(Conversation.moduleID(), oid, skype);
    1324                    }
    1325                    return conversation;
    1326            }
    1327
    1328            /**
    1329             *Retrieves a Conversation object by Public Conversation BLOB. Public conversation blobs are globally unique conversation IDs that provide a method for joining conversation without explicitly being added to the conversation by someone already in it. Programmatically, a Conversation BLOB can be retrieved with Conversation.GetJoinBlob method. In Skype desktop clients, the BLOB can be retrieved by typing "/get uri" in a conversation. The conversation can then be joined by people who have somehow received that BLOB. <br>
    1330             * @param joinBlob The BLOB string. <br>
    1331             * @param alsoJoin If set to true, automatically joins current user into the Conversation. <br>
    1332             * @return conversation Returns Conversation object if successful. <br>
    1333             */
    1334            public Conversation GetConversationByBlob( String joinBlob, boolean alsoJoin) {
    1335
    1336                    Request request = null;
    1337                    try {
    1338                            request = new XCallRequest(0,17);
    1339                    } catch (IOException e) {
    1340                            e.printStackTrace();
    1341                            if (errorListener != null)
    1342                                    errorListener.OnSkypeKitFatalError();
    1343                    }
    1344                    request.addParm('S',1,joinBlob);
    1345                    request.addParm('b',2,alsoJoin);
    1346
    1347                    Response r = XCall((XCallRequest)request);
    1348
    1349                    if (r.isErrCall())
    1350                            return null;
    1351
    1352                    int oid = 0;
    1353                    Conversation conversation = null;
    1354                    oid = r.GetOid(1);
    1355                    if (oid != AbstractDecoder.NULL_VALUE) {
    1356                            conversation = (Conversation)skype.factory(Conversation.moduleID(), oid, skype);
    1357                    }
    1358                    return conversation;
    1359            }
    1360
    1361            /**
    1362             *Returns a list of Conversation objects by Conversation.LIST_TYPE filter. <br>
    1363             * @param type Filter. <br>
    1364             * @return conversations List of conversations matching the filter. <br>
    1365             */
    1366            public Conversation [] GetConversationList( Conversation.LIST_TYPE type) {
    1367
    1368                    Request request = null;
    1369                    try {
    1370                            request = new XCallRequest(0,18);
    1371                    } catch (IOException e) {
    1372                            e.printStackTrace();
    1373                            if (errorListener != null)
    1374                                    errorListener.OnSkypeKitFatalError();
    1375                    }
    1376                    request.addParm('e',1,type.getId());
    1377
    1378                    Response r = XCall((XCallRequest)request);
    1379
    1380                    if (r.isErrCall())
    1381                            return null;
    1382
    1383                    Vector<Conversation> conversations = new Vector<Conversation>();
    1384                    while (r.HasMore(1))
    1385                    {
    1386                            int oid = 0;
    1387                            Conversation conversation = null;
    1388                            oid = r.GetOid(1);
    1389                            if (oid != AbstractDecoder.NULL_VALUE) {
    1390                                    conversation = (Conversation)skype.factory(Conversation.moduleID(), oid, skype);
    1391                            }
    1392                            conversations.add(conversation);
    1393                    }
    1394                    return conversations.toArray(new Conversation[conversations.size()]);
    1395
    1396            }
    1397
    1398            /**
    1399             *Retrieves a Message object by the P_GUID property (globally unique ID, same for all the participants of the conversation, in which this message occured). <br>
    1400             * @param guid Globally unique ID of the message. <br>
    1401             * @return message Returns a Message object if a match was found. <br>
    1402             */
    1403            public Message GetMessageByGuid( byte[] guid) {
    1404
    1405                    Request request = null;
    1406                    try {
    1407                            request = new XCallRequest(0,21);
    1408                    } catch (IOException e) {
    1409                            e.printStackTrace();
    1410                            if (errorListener != null)
    1411                                    errorListener.OnSkypeKitFatalError();
    1412                    }
    1413                    request.addParm('B',1,guid);
    1414
    1415                    Response r = XCall((XCallRequest)request);
    1416
    1417                    if (r.isErrCall())
    1418                            return null;
    1419
    1420                    int oid = 0;
    1421                    Message message = null;
    1422                    oid = r.GetOid(1);
    1423                    if (oid != AbstractDecoder.NULL_VALUE) {
    1424                            message = (Message)skype.factory(Message.moduleID(), oid, skype);
    1425                    }
    1426                    return message;
    1427            }
    1428
    1429            /**
    1430             *Returns all messages of the given type,                   the most recent POSTED_EMOTE or POSTED_TEXT of each conversation.
    1431             * @param type Type of messages requested
    1432             * @param latestPerConvOnly Whether to return only the most recent message per conversation
    1433             * @param fromTimestampInc Starting timestamp for reqested range, inclusive
    1434             * @param toTimestampExc Ending timestamp for requested range, exclusive
    1435             * @return messages
    1436             */
    1437            public Message [] GetMessageListByType( Message.TYPE type, boolean latestPerConvOnly, int fromTimestampInc, int toTimestampExc) {
    1438
    1439                    Request request = null;
    1440                    try {
    1441                            request = new XCallRequest(0,136);
    1442                    } catch (IOException e) {
    1443                            e.printStackTrace();
    1444                            if (errorListener != null)
    1445                                    errorListener.OnSkypeKitFatalError();
    1446                    }
    1447                    request.addParm('e',1,type.getId());
    1448                    request.addParm('b',2,latestPerConvOnly);
    1449                    request.addParm('u',3,fromTimestampInc);
    1450                    request.addParm('u',4,toTimestampExc);
    1451
    1452                    Response r = XCall((XCallRequest)request);
    1453
    1454                    if (r.isErrCall())
    1455                            return null;
    1456
    1457                    Vector<Message> messages = new Vector<Message>();
    1458                    while (r.HasMore(1))
    1459                    {
    1460                            int oid = 0;
    1461                            Message message = null;
    1462                            oid = r.GetOid(1);
    1463                            if (oid != AbstractDecoder.NULL_VALUE) {
    1464                                    message = (Message)skype.factory(Message.moduleID(), oid, skype);
    1465                            }
    1466                            messages.add(message);
    1467                    }
    1468                    return messages.toArray(new Message[messages.size()]);
    1469
    1470            }
    1471
    1472            /**
    1473             *This method returns a table in form of two string lists of equal length and an uint argument that returns the count of items i both lists. The first list contains video recording device handles and the second list descriptive names of those devices. NB! This method requires videortphost to be running, otherwise it will return empty lists. <br>
    1474             * @return GetAvailableVideoDevicesResult
    1475             */
    1476            public GetAvailableVideoDevicesResult GetAvailableVideoDevices() {
    1477
    1478                    Request request = null;
    1479                    try {
    1480                            request = new XCallRequest(0,80);
    1481                    } catch (IOException e) {
    1482                            e.printStackTrace();
    1483                            if (errorListener != null)
    1484                                    errorListener.OnSkypeKitFatalError();
    1485                    }
    1486
    1487                    Response r = XCall((XCallRequest)request);
    1488
    1489                    if (r.isErrCall())
    1490                            return null;
    1491
    1492                    GetAvailableVideoDevicesResult result = new GetAvailableVideoDevicesResult();
    1493
    1494                    Vector<String> deviceNames = new Vector<String>();
    1495                    while (r.HasMore(1))
    1496                    {
    1497                            String string = null;
    1498                            string  = r.GetAsString(1);
    1499                            deviceNames.add(string);
    1500                    }
    1501                    result.deviceNames = deviceNames.toArray(new String[deviceNames.size()]);
    1502
    1503                    Vector<String> devicePaths = new Vector<String>();
    1504                    while (r.HasMore(2))
    1505                    {
    1506                            String string = null;
    1507                            string  = r.GetAsString(2);
    1508                            devicePaths.add(string);
    1509                    }
    1510                    result.devicePaths = devicePaths.toArray(new String[devicePaths.size()]);
    1511
    1512                    int count = 0;
    1513                    count = r.GetAsInt(3);
    1514                    result.count = count;
    1515
    1516                    return result;
    1517            }
    1518
    1519            public class GetAvailableVideoDevicesResult {
    1520                    public String [] deviceNames;
    1521                    public String [] devicePaths;
    1522                    public int count;
    1523            }
    1524
    1525            /**
    1526             *Queries whether the given video device has a specific Video.VIDEO_DEVICE_CAPABILITY. Use Skype.GetAvailableVideoDevices method to retrieve sstring lists with available deviceName and devicePath values. <br>
    1527             * @param deviceName Human readable device name. <br>
    1528             * @param devicePath Device ID. <br>
    1529             * @param cap Any of the Video.VIDEO_DEVICE_CAPABILITY values. <br>
    1530             */
    1531            public void HasVideoDeviceCapability( String deviceName, String devicePath, Video.VIDEO_DEVICE_CAPABILITY cap) {
    1532
    1533                    Request request = null;
    1534                    try {
    1535                            request = new XCallRequest(0,33);
    1536                    } catch (IOException e) {
    1537                            e.printStackTrace();
    1538                            if (errorListener != null)
    1539                                    errorListener.OnSkypeKitFatalError();
    1540                    }
    1541                    request.addParm('S',1,deviceName);
    1542                    request.addParm('S',2,devicePath);
    1543                    request.addParm('e',3,cap.getId());
    1544
    1545                    XCall((XCallRequest)request);
    1546            }
    1547
    1548            /**
    1549             * @param deviceName
    1550             * @param devicePath
    1551             */
    1552            public void DisplayVideoDeviceTuningDialog( String deviceName, String devicePath) {
    1553
    1554                    Request request = null;
    1555                    try {
    1556                            request = new XCallRequest(0,34);
    1557                    } catch (IOException e) {
    1558                            e.printStackTrace();
    1559                            if (errorListener != null)
    1560                                    errorListener.OnSkypeKitFatalError();
    1561                    }
    1562                    request.addParm('S',1,deviceName);
    1563                    request.addParm('S',2,devicePath);
    1564
    1565                    XCall((XCallRequest)request);
    1566            }
    1567
    1568            /**
    1569             * @param type
    1570             * @param deviceName name and path to be used only with media type VIDEO
    1571             * @param devicePath
    1572             * @return video
    1573             */
    1574            public Video GetPreviewVideo( Video.MEDIATYPE type, String deviceName, String devicePath) {
    1575
    1576                    Request request = null;
    1577                    try {
    1578                            request = new XCallRequest(0,35);
    1579                    } catch (IOException e) {
    1580                            e.printStackTrace();
    1581                            if (errorListener != null)
    1582                                    errorListener.OnSkypeKitFatalError();
    1583                    }
    1584                    request.addParm('e',1,type.getId());
    1585                    request.addParm('S',2,deviceName);
    1586                    request.addParm('S',3,devicePath);
    1587
    1588                    Response r = XCall((XCallRequest)request);
    1589
    1590                    if (r.isErrCall())
    1591                            return null;
    1592
    1593                    int oid = 0;
    1594                    Video video = null;
    1595                    oid = r.GetOid(1);
    1596                    if (oid != AbstractDecoder.NULL_VALUE) {
    1597                            video = (Video)skype.factory(Video.moduleID(), oid, skype);
    1598                    }
    1599                    return video;
    1600            }
    1601
    1602            /**
    1603             *Avaible to Video Engines using the Video RTP API
    1604             * @param command
    1605             * @return response
    1606             */
    1607            public String VideoCommand( String command) {
    1608
    1609                    Request request = null;
    1610                    try {
    1611                            request = new XCallRequest(0,59);
    1612                    } catch (IOException e) {
    1613                            e.printStackTrace();
    1614                            if (errorListener != null)
    1615                                    errorListener.OnSkypeKitFatalError();
    1616                    }
    1617                    request.addParm('S',1,command);
    1618
    1619                    Response r = XCall((XCallRequest)request);
    1620
    1621                    if (r.isErrCall())
    1622                            return null;
    1623
    1624                    String response = null;
    1625                    response = r.GetAsString(1);
    1626                    return response;
    1627            }
    1628
    1629            /**
    1630             * @param skypeName
    1631             * @return greeting
    1632             */
    1633            public Voicemail GetGreeting( String skypeName) {
    1634
    1635                    Request request = null;
    1636                    try {
    1637                            request = new XCallRequest(0,45);
    1638                    } catch (IOException e) {
    1639                            e.printStackTrace();
    1640                            if (errorListener != null)
    1641                                    errorListener.OnSkypeKitFatalError();
    1642                    }
    1643                    request.addParm('S',1,skypeName);
    1644
    1645                    Response r = XCall((XCallRequest)request);
    1646
    1647                    if (r.isErrCall())
    1648                            return null;
    1649
    1650                    int oid = 0;
    1651                    Voicemail greeting = null;
    1652                    oid = r.GetOid(1);
    1653                    if (oid != AbstractDecoder.NULL_VALUE) {
    1654                            greeting = (Voicemail)skype.factory(Voicemail.moduleID(), oid, skype);
    1655                    }
    1656                    return greeting;
    1657            }
    1658
    1659            /** Setupkey SETUPKEY_DISABLED_CODECS type:string  <br>Space-separated array of disabled codecs <br>This setup key is machine-specific and affects all local accounts. <br> */
    1660            public static final String DISABLED_CODECS = "*Lib/Audio/DisableCodecs";
    1661
    1662            /** Setupkey SETUPKEY_DISABLE_AEC type:boolean  <br>Disables Skype echo canceller <br>This setup key is machine-specific and affects all local accounts. <br> */
    1663            public static final String DISABLE_AEC = "*Lib/Audio/DisableAEC";
    1664
    1665            /** Setupkey SETUPKEY_DISABLE_NOISE_SUPPRESSOR type:boolean  <br>Disables Skype noise suppressor <br>This setup key is machine-specific and affects all local accounts. <br> */
    1666            public static final String DISABLE_NOISE_SUPPRESSOR = "*Lib/Audio/DisableNS";
    1667
    1668            /** Setupkey SETUPKEY_DISABLE_AGC type:boolean  Disables Skype automatic gain controller <br>This setup key is machine-specific and affects all local accounts. <br> */
    1669            public static final String DISABLE_AGC = "*Lib/Audio/DisableAGC";
    1670
    1671            /** Setupkey SETUPKEY_DISABLE_DIGITAL_NEAR_END_AGC type:boolean  <br>Disables Skype digital near-end gain controller <br>This setup key is machine-specific and affects all local accounts. <br> */
    1672            public static final String DISABLE_DIGITAL_NEAR_END_AGC = "*Lib/Audio/DisableDigitalNearEndAGC";
    1673
    1674            /** Setupkey SETUPKEY_DISABLE_DIGITAL_FAR_END_AGC type:boolean  <br>Disables Skype digital far-end gain controller <br>This setup key is machine-specific and affects all local accounts. <br> */
    1675            public static final String DISABLE_DIGITAL_FAR_END_AGC = "*Lib/Audio/DisableDigitalFarEndAGC";
    1676
    1677            /** Setupkey SETUPKEY_BEAMFORMER_MIC_SPACING type:string  <br>Space-separated array of 1 (in case of 2 microphones) or 2 (in case of 4 microphones) integers. SAL beamforming currently only supports 2 and 4-microphone configurations. The values represent the spacing between microphones (in millimeters). <br>In case of 2-microphone setup, Only the first value is used. <br><br>In case of 4-microphone setup, The first value is the distance between inner pair of microphones. The second value is the distance between inner pair of microphones and the outer pair. Like this: <br><br>Let the microphones be on straight line, A B C D. <br>Microphones B and C form the inner pair, while A and D form the outer pair. <br>The first value in the setup string would be distance between B and C. <br>The second value would be distance between A and B (which is the same as distance between C and D). <br><br>With 4-mic setup, you will need to use two channels. The inner pair should go to one channel (left) and the outer pair should go to another (right). <br><br>This setup key is machine-specific and affects all local accounts. <br> */
    1678            public static final String BEAMFORMER_MIC_SPACING = "*Lib/Audio/BeamformerMicSpacing";
    1679
    1680            /** Setupkey SETUPKEY_DISABLE_AUDIO_DEVICE_PROBING type:boolean  <br>Disables audio devices probing <br>This setup key is machine-specific and affects all local accounts. <br> */
    1681            public static final String DISABLE_AUDIO_DEVICE_PROBING = "*Lib/QualityMonitor/DisableAudioDeviceProbing";
    1682
    1683            /**
    1684             */
    1685            public enum PREPARESOUNDRESULT {
    1686
    1687                    /** */
    1688                    PREPARESOUND_SUCCESS(0),
    1689
    1690                    /** */
    1691                    PREPARESOUND_MISC_ERROR(1),
    1692
    1693                    /** */
    1694                    PREPARESOUND_FILE_NOT_FOUND(2),
    1695
    1696                    /** */
    1697                    PREPARESOUND_FILE_TOO_BIG(3),
    1698
    1699                    /** */
    1700                    PREPARESOUND_FILE_READ_ERROR(4),
    1701
    1702                    /** */
    1703                    PREPARESOUND_UNSUPPORTED_FILE_FORMAT(5),
    1704
    1705                    /** */
    1706                    PREPARESOUND_PLAYBACK_NOT_SUPPORTED(6);
    1707
    1708                    private static final Map<Integer,PREPARESOUNDRESULT> lookup = new HashMap<Integer,PREPARESOUNDRESULT>();
    1709
    1710                    static {
    1711                            for(PREPARESOUNDRESULT s : EnumSet.allOf(PREPARESOUNDRESULT.class))
    1712                                    lookup.put(s.getId(), s);
    1713                    }
    1714
    1715                    private final int id;
    1716
    1717                    private PREPARESOUNDRESULT(int value) {
    1718                            this.id = value;
    1719                    }
    1720
    1721                    public int getId() { return id; }
    1722
    1723                    public static PREPARESOUNDRESULT get(int code) {
    1724                            return lookup.get(code);
    1725                    }
    1726
    1727                    public static PREPARESOUNDRESULT fromString(String s) {
    1728                            for (PREPARESOUNDRESULT p : lookup.values()) {
    1729                                    if (p.toString() == s) {
    1730                                            return p;
    1731                                    }
    1732                            }
    1733                            return null;
    1734                    }
    1735            }
    1736
    1737            /**
    1738             */
    1739            public enum AUDIODEVICE_CAPABILITIES {
    1740
    1741                    /** */
    1742                    HAS_VIDEO_CAPTURE(1),
    1743
    1744                    /** */
    1745                    HAS_USB_INTERFACE(2),
    1746
    1747                    /** */
    1748                    POSSIBLY_HEADSET(4),
    1749
    1750                    /** */
    1751                    HAS_AUDIO_CAPTURE(8),
    1752
    1753                    /** */
    1754                    HAS_AUDIO_RENDERING(16),
    1755
    1756                    /** */
    1757                    HAS_LOWBANDWIDTH_CAPTURE(32),
    1758
    1759                    /** */
    1760                    IS_WEBCAM(64),
    1761
    1762                    /** */
    1763                    IS_HEADSET(128),
    1764
    1765                    /** */
    1766                    POSSIBLY_WEBCAM(256),
    1767
    1768                    /** */
    1769                    HAS_VIDEO_RENDERING(2048),
    1770
    1771                    /** */
    1772                    HAS_BLUETOOTH_INTERFACE(4096);
    1773
    1774                    private static final Map<Integer,AUDIODEVICE_CAPABILITIES> lookup = new HashMap<Integer,AUDIODEVICE_CAPABILITIES>();
    1775
    1776                    static {
    1777                            for(AUDIODEVICE_CAPABILITIES s : EnumSet.allOf(AUDIODEVICE_CAPABILITIES.class))
    1778                                    lookup.put(s.getId(), s);
    1779                    }
    1780
    1781                    private final int id;
    1782
    1783                    private AUDIODEVICE_CAPABILITIES(int value) {
    1784                            this.id = value;
    1785                    }
    1786
    1787                    public int getId() { return id; }
    1788
    1789                    public static AUDIODEVICE_CAPABILITIES get(int code) {
    1790                            return lookup.get(code);
    1791                    }
    1792
    1793                    public static AUDIODEVICE_CAPABILITIES fromString(String s) {
    1794                            for (AUDIODEVICE_CAPABILITIES p : lookup.values()) {
    1795                                    if (p.toString() == s) {
    1796                                            return p;
    1797                                    }
    1798                            }
    1799                            return null;
    1800                    }
    1801            }
    1802
    1803            /**
    1804             *Takes audio data that comes from the sound argument and mixes it into playback or notification device, depending on the value passed in the useCallOutDevice argument. The sound argument contains the audio data in in follwing format: first 4 bytes of the binary contain the sample rate, followed by 16 bit (mono) samples. The soundid argument is an arbitrary ID that you can pass in and then later use as an argument for Skype class PlayStop method. To mix the audio into playback device stream, set useCallOutDevice to true, to mic it into notification stream, set useCallOutDevice to false. <br>
    1805             * @param soundid
    1806             * @param sound
    1807             * @param loop
    1808             * @param useCallOutDevice
    1809             */
    1810            public void PlayStart( int soundid, byte[] sound, boolean loop, boolean useCallOutDevice) {
    1811
    1812                    Request request = null;
    1813                    try {
    1814                            request = new XCallRequest(0,48);
    1815                    } catch (IOException e) {
    1816                            e.printStackTrace();
    1817                            if (errorListener != null)
    1818                                    errorListener.OnSkypeKitFatalError();
    1819                    }
    1820                    request.addParm('u',1,soundid);
    1821                    request.addParm('B',2,sound);
    1822                    request.addParm('b',3,loop);
    1823                    request.addParm('b',4,useCallOutDevice);
    1824
    1825                    XCall((XCallRequest)request);
    1826            }
    1827
    1828            /**
    1829             * @param soundid
    1830             * @param datafile
    1831             * @param loop
    1832             * @param useCallOutDevice
    1833             * @return result
    1834             */
    1835            public PREPARESOUNDRESULT PlayStartFromFile( int soundid, String datafile, boolean loop, boolean useCallOutDevice) {
    1836
    1837                    Request request = null;
    1838                    try {
    1839                            request = new XCallRequest(0,212);
    1840                    } catch (IOException e) {
    1841                            e.printStackTrace();
    1842                            if (errorListener != null)
    1843                                    errorListener.OnSkypeKitFatalError();
    1844                    }
    1845                    request.addParm('u',1,soundid);
    1846                    request.addParm('f',2,datafile);
    1847                    request.addParm('b',3,loop);
    1848                    request.addParm('b',4,useCallOutDevice);
    1849
    1850                    Response r = XCall((XCallRequest)request);
    1851
    1852                    if (r.isErrCall())
    1853                            return null;
    1854
    1855                    PREPARESOUNDRESULT preparesoundresult = null;
    1856                    preparesoundresult = PREPARESOUNDRESULT.get(r.GetAsInt(1));
    1857                    return preparesoundresult;
    1858            }
    1859
    1860            /**
    1861             *Stops playback of the soundfile. The argument is the same ID you passed in the Skype class StartPlayback method. <br>
    1862             * @param soundid
    1863             */
    1864            public void PlayStop( int soundid) {
    1865
    1866                    Request request = null;
    1867                    try {
    1868                            request = new XCallRequest(0,49);
    1869                    } catch (IOException e) {
    1870                            e.printStackTrace();
    1871                            if (errorListener != null)
    1872                                    errorListener.OnSkypeKitFatalError();
    1873                    }
    1874                    request.addParm('u',1,soundid);
    1875
    1876                    XCall((XCallRequest)request);
    1877            }
    1878
    1879            /**
    1880             * @param recordAndPlaybackData
    1881             */
    1882            public void StartRecordingTest( boolean recordAndPlaybackData) {
    1883
    1884                    Request request = null;
    1885                    try {
    1886                            request = new XCallRequest(0,50);
    1887                    } catch (IOException e) {
    1888                            e.printStackTrace();
    1889                            if (errorListener != null)
    1890                                    errorListener.OnSkypeKitFatalError();
    1891                    }
    1892                    request.addParm('b',1,recordAndPlaybackData);
    1893
    1894                    XCall((XCallRequest)request);
    1895            }
    1896
    1897            /**
    1898             */
    1899            public void StopRecordingTest() {
    1900
    1901                    Request request = null;
    1902                    try {
    1903                            request = new XCallRequest(0,51);
    1904                    } catch (IOException e) {
    1905                            e.printStackTrace();
    1906                            if (errorListener != null)
    1907                                    errorListener.OnSkypeKitFatalError();
    1908                    }
    1909
    1910                    XCall((XCallRequest)request);
    1911            }
    1912
    1913            /**
    1914             *This method returns a table in form of three string lists of equal lengths. The first list contains audio output device handles ('hw:0,0', 'hw:0,1', etc.) The second list contains descriptive names of those devices (Ensoniq AudioPCI etc.) The third list contains device product IDs. Note that the values in these lists depend on which audio engine you are running (SAL, PCM, RTP). <br>
    1915             * @return GetAvailableOutputDevicesResult
    1916             */
    1917            public GetAvailableOutputDevicesResult GetAvailableOutputDevices() {
    1918
    1919                    Request request = null;
    1920                    try {
    1921                            request = new XCallRequest(0,53);
    1922                    } catch (IOException e) {
    1923                            e.printStackTrace();
    1924                            if (errorListener != null)
    1925                                    errorListener.OnSkypeKitFatalError();
    1926                    }
    1927
    1928                    Response r = XCall((XCallRequest)request);
    1929
    1930                    if (r.isErrCall())
    1931                            return null;
    1932
    1933                    GetAvailableOutputDevicesResult result = new GetAvailableOutputDevicesResult();
    1934
    1935                    Vector<String> handleList = new Vector<String>();
    1936                    while (r.HasMore(1))
    1937                    {
    1938                            String string = null;
    1939                            string  = r.GetAsString(1);
    1940                            handleList.add(string);
    1941                    }
    1942                    result.handleList = handleList.toArray(new String[handleList.size()]);
    1943
    1944                    Vector<String> nameList = new Vector<String>();
    1945                    while (r.HasMore(2))
    1946                    {
    1947                            String string = null;
    1948                            string  = r.GetAsString(2);
    1949                            nameList.add(string);
    1950                    }
    1951                    result.nameList = nameList.toArray(new String[nameList.size()]);
    1952
    1953                    Vector<String> productIdList = new Vector<String>();
    1954                    while (r.HasMore(3))
    1955                    {
    1956                            String string = null;
    1957                            string  = r.GetAsString(3);
    1958                            productIdList.add(string);
    1959                    }
    1960                    result.productIdList = productIdList.toArray(new String[productIdList.size()]);
    1961
    1962                    return result;
    1963            }
    1964
    1965            public class GetAvailableOutputDevicesResult {
    1966                    public String [] handleList;
    1967                    public String [] nameList;
    1968                    public String [] productIdList;
    1969            }
    1970
    1971            /**
    1972             *This method returns a table in form of three string lists of equal length. The first list contains audio recording device handles ('hw:0,0', 'hw:0,1', etc.) The second list contains descriptive names of those devices (Ensoniq AudioPCI etc.) The third list contains device product IDs. Note that the values in these lists depend on which audio engine you are running (SAL, PCM, RTP). <br>
    1973             * @return GetAvailableRecordingDevicesResult
    1974             */
    1975            public GetAvailableRecordingDevicesResult GetAvailableRecordingDevices() {
    1976
    1977                    Request request = null;
    1978                    try {
    1979                            request = new XCallRequest(0,54);
    1980                    } catch (IOException e) {
    1981                            e.printStackTrace();
    1982                            if (errorListener != null)
    1983                                    errorListener.OnSkypeKitFatalError();
    1984                    }
    1985
    1986                    Response r = XCall((XCallRequest)request);
    1987
    1988                    if (r.isErrCall())
    1989                            return null;
    1990
    1991                    GetAvailableRecordingDevicesResult result = new GetAvailableRecordingDevicesResult();
    1992
    1993                    Vector<String> handleList = new Vector<String>();
    1994                    while (r.HasMore(1))
    1995                    {
    1996                            String string = null;
    1997                            string  = r.GetAsString(1);
    1998                            handleList.add(string);
    1999                    }
    2000                    result.handleList = handleList.toArray(new String[handleList.size()]);
    2001
    2002                    Vector<String> nameList = new Vector<String>();
    2003                    while (r.HasMore(2))
    2004                    {
    2005                            String string = null;
    2006                            string  = r.GetAsString(2);
    2007                            nameList.add(string);
    2008                    }
    2009                    result.nameList = nameList.toArray(new String[nameList.size()]);
    2010
    2011                    Vector<String> productIdList = new Vector<String>();
    2012                    while (r.HasMore(3))
    2013                    {
    2014                            String string = null;
    2015                            string  = r.GetAsString(3);
    2016                            productIdList.add(string);
    2017                    }
    2018                    result.productIdList = productIdList.toArray(new String[productIdList.size()]);
    2019
    2020                    return result;
    2021            }
    2022
    2023            public class GetAvailableRecordingDevicesResult {
    2024                    public String [] handleList;
    2025                    public String [] nameList;
    2026                    public String [] productIdList;
    2027            }
    2028
    2029            /**
    2030             *Sets audio devices given in arguments as active audio devices. This command selects all three devices - microphone, playback and the notification channel. Valid input values for this method come from the first string list you get back from Skype class GetAvailableOutputDevices (handleList). <br>
    2031             * @param callInDevice
    2032             * @param callOutDevice
    2033             * @param waveOutDevice
    2034             */
    2035            public void SelectSoundDevices( String callInDevice, String callOutDevice, String waveOutDevice) {
    2036
    2037                    Request request = null;
    2038                    try {
    2039                            request = new XCallRequest(0,55);
    2040                    } catch (IOException e) {
    2041                            e.printStackTrace();
    2042                            if (errorListener != null)
    2043                                    errorListener.OnSkypeKitFatalError();
    2044                    }
    2045                    request.addParm('S',1,callInDevice);
    2046                    request.addParm('S',2,callOutDevice);
    2047                    request.addParm('S',3,waveOutDevice);
    2048
    2049                    XCall((XCallRequest)request);
    2050            }
    2051
    2052            /**
    2053             *The uint argument returns AUDIODEVICE_CAPABILITIES (declared in Skype class) <br>
    2054             * @param deviceHandle
    2055             * @return GetAudioDeviceCapabilitiesResult
    2056             */
    2057            public GetAudioDeviceCapabilitiesResult GetAudioDeviceCapabilities( String deviceHandle) {
    2058
    2059                    Request request = null;
    2060                    try {
    2061                            request = new XCallRequest(0,56);
    2062                    } catch (IOException e) {
    2063                            e.printStackTrace();
    2064                            if (errorListener != null)
    2065                                    errorListener.OnSkypeKitFatalError();
    2066                    }
    2067                    request.addParm('S',1,deviceHandle);
    2068
    2069                    Response r = XCall((XCallRequest)request);
    2070
    2071                    if (r.isErrCall())
    2072                            return null;
    2073
    2074                    GetAudioDeviceCapabilitiesResult result = new GetAudioDeviceCapabilitiesResult();
    2075
    2076                    String interfaceString = null;
    2077                    interfaceString = r.GetAsString(1);
    2078                    result.interfaceString = interfaceString;
    2079
    2080                    int capabilities = 0;
    2081                    capabilities = r.GetAsInt(2);
    2082                    result.capabilities = capabilities;
    2083
    2084                    return result;
    2085            }
    2086
    2087            public class GetAudioDeviceCapabilitiesResult {
    2088                    public String interfaceString;
    2089                    public int capabilities; /** bit set of AUDIODEVICE_CAPABILITIES */
    2090            }
    2091
    2092            /**
    2093             *Returns current audio stream volume for both playback and microphone streams. Useful for displaying visual audio indicators in you UI. See also Skype class OnNrgLevelsChange callback that gets fired each time the these values are changed. <br>
    2094             * @return GetNrgLevelsResult
    2095             */
    2096            public GetNrgLevelsResult GetNrgLevels() {
    2097
    2098                    Request request = null;
    2099                    try {
    2100                            request = new XCallRequest(0,57);
    2101                    } catch (IOException e) {
    2102                            e.printStackTrace();
    2103                            if (errorListener != null)
    2104                                    errorListener.OnSkypeKitFatalError();
    2105                    }
    2106
    2107                    Response r = XCall((XCallRequest)request);
    2108
    2109                    if (r.isErrCall())
    2110                            return null;
    2111
    2112                    GetNrgLevelsResult result = new GetNrgLevelsResult();
    2113
    2114                    int micLevel = 0;
    2115                    micLevel = r.GetAsInt(1);
    2116                    result.micLevel = micLevel;
    2117
    2118                    int speakerLevel = 0;
    2119                    speakerLevel = r.GetAsInt(2);
    2120                    result.speakerLevel = speakerLevel;
    2121
    2122                    return result;
    2123            }
    2124
    2125            public class GetNrgLevelsResult {
    2126                    public int micLevel;
    2127                    public int speakerLevel;
    2128            }
    2129
    2130            /**
    2131             *NB! This command only works if its implemented in external audiohost (RTP or PCM host). The command can be is used for passing custom commands from client UI to the audio implementation. <br>
    2132             * @param command
    2133             * @return response
    2134             */
    2135            public String VoiceCommand( String command) {
    2136
    2137                    Request request = null;
    2138                    try {
    2139                            request = new XCallRequest(0,58);
    2140                    } catch (IOException e) {
    2141                            e.printStackTrace();
    2142                            if (errorListener != null)
    2143                                    errorListener.OnSkypeKitFatalError();
    2144                    }
    2145                    request.addParm('S',1,command);
    2146
    2147                    Response r = XCall((XCallRequest)request);
    2148
    2149                    if (r.isErrCall())
    2150                            return null;
    2151
    2152                    String response = null;
    2153                    response = r.GetAsString(1);
    2154                    return response;
    2155            }
    2156
    2157            /**
    2158             *Returns value of audio playback volume setting (0..100). <br>
    2159             * @return volume
    2160             */
    2161            public int GetSpeakerVolume() {
    2162
    2163                    Request request = null;
    2164                    try {
    2165                            request = new XCallRequest(0,60);
    2166                    } catch (IOException e) {
    2167                            e.printStackTrace();
    2168                            if (errorListener != null)
    2169                                    errorListener.OnSkypeKitFatalError();
    2170                    }
    2171
    2172                    Response r = XCall((XCallRequest)request);
    2173
    2174                    if (r.isErrCall())
    2175                            return 0;
    2176
    2177                    int volume = 0;
    2178                    volume = r.GetAsInt(1);
    2179                    return volume;
    2180            }
    2181
    2182            /**
    2183             *This method is for setting speaker volume. It will set the level for Skype digital gain control. Skype audio library will not control gain of audio device itself. <br>
    2184             * @param volume
    2185             */
    2186            public void SetSpeakerVolume( int volume) {
    2187
    2188                    Request request = null;
    2189                    try {
    2190                            request = new XCallRequest(0,61);
    2191                    } catch (IOException e) {
    2192                            e.printStackTrace();
    2193                            if (errorListener != null)
    2194                                    errorListener.OnSkypeKitFatalError();
    2195                    }
    2196                    request.addParm('u',1,volume);
    2197
    2198                    XCall((XCallRequest)request);
    2199            }
    2200
    2201            /**
    2202             *Returns value of microphone volume setting (0..100). It will return the analog gain of audio device set by Skype AGC. For real-time microphone volume, use GetNrgLevels method or OnNrgLevelsChange callback (both are methods of Skype class). <br>
    2203             * @return micVolume
    2204             */
    2205            public int GetMicVolume() {
    2206
    2207                    Request request = null;
    2208                    try {
    2209                            request = new XCallRequest(0,62);
    2210                    } catch (IOException e) {
    2211                            e.printStackTrace();
    2212                            if (errorListener != null)
    2213                                    errorListener.OnSkypeKitFatalError();
    2214                    }
    2215
    2216                    Response r = XCall((XCallRequest)request);
    2217
    2218                    if (r.isErrCall())
    2219                            return 0;
    2220
    2221                    int micVolume = 0;
    2222                    micVolume = r.GetAsInt(1);
    2223                    return micVolume;
    2224            }
    2225
    2226            /**
    2227             *This method is for setting the microphone volume level. This does not work when Skype AGC (Automatic Gain Control) is enabled, which it is by default. It is currently impossible to disable AGC, so for now this method is here for purpose of future compatibility. <br>
    2228             * @param volume
    2229             */
    2230            public void SetMicVolume( int volume) {
    2231
    2232                    Request request = null;
    2233                    try {
    2234                            request = new XCallRequest(0,63);
    2235                    } catch (IOException e) {
    2236                            e.printStackTrace();
    2237                            if (errorListener != null)
    2238                                    errorListener.OnSkypeKitFatalError();
    2239                    }
    2240                    request.addParm('u',1,volume);
    2241
    2242                    XCall((XCallRequest)request);
    2243            }
    2244
    2245            /**
    2246             *Returns true in &muted argument if the currently selected playback device is muted. <br>
    2247             * @return muted
    2248             */
    2249            public boolean IsSpeakerMuted() {
    2250
    2251                    Request request = null;
    2252                    try {
    2253                            request = new XCallRequest(0,64);
    2254                    } catch (IOException e) {
    2255                            e.printStackTrace();
    2256                            if (errorListener != null)
    2257                                    errorListener.OnSkypeKitFatalError();
    2258                    }
    2259
    2260                    Response r = XCall((XCallRequest)request);
    2261
    2262                    if (r.isErrCall())
    2263                            return false;
    2264
    2265                    boolean muted = false;
    2266                    muted = r.GetAsBoolean(1);
    2267                    return muted;
    2268            }
    2269
    2270            /**
    2271             *Returns true in &muted argument if the currently selected microphone is muted. <br>
    2272             * @return muted
    2273             */
    2274            public boolean IsMicrophoneMuted() {
    2275
    2276                    Request request = null;
    2277                    try {
    2278                            request = new XCallRequest(0,65);
    2279                    } catch (IOException e) {
    2280                            e.printStackTrace();
    2281                            if (errorListener != null)
    2282                                    errorListener.OnSkypeKitFatalError();
    2283                    }
    2284
    2285                    Response r = XCall((XCallRequest)request);
    2286
    2287                    if (r.isErrCall())
    2288                            return false;
    2289
    2290                    boolean muted = false;
    2291                    muted = r.GetAsBoolean(1);
    2292                    return muted;
    2293            }
    2294
    2295            /**
    2296             *Sets currently selected playback device mute status according to argument. <br>
    2297             * @param mute
    2298             */
    2299            public void MuteSpeakers( boolean mute) {
    2300
    2301                    Request request = null;
    2302                    try {
    2303                            request = new XCallRequest(0,66);
    2304                    } catch (IOException e) {
    2305                            e.printStackTrace();
    2306                            if (errorListener != null)
    2307                                    errorListener.OnSkypeKitFatalError();
    2308                    }
    2309                    request.addParm('b',1,mute);
    2310
    2311                    XCall((XCallRequest)request);
    2312            }
    2313
    2314            /**
    2315             *Sets currently selected microphone mute status according to argument. <br>
    2316             * @param mute
    2317             */
    2318            public void MuteMicrophone( boolean mute) {
    2319
    2320                    Request request = null;
    2321                    try {
    2322                            request = new XCallRequest(0,67);
    2323                    } catch (IOException e) {
    2324                            e.printStackTrace();
    2325                            if (errorListener != null)
    2326                                    errorListener.OnSkypeKitFatalError();
    2327                    }
    2328                    request.addParm('b',1,mute);
    2329
    2330                    XCall((XCallRequest)request);
    2331            }
    2332
    2333            /**
    2334             */
    2335            public enum OPERATING_MEDIA {
    2336
    2337                    /** */
    2338                    OM_UNKNOWN(0),
    2339
    2340                    /** */
    2341                    OM_FREE(1),
    2342
    2343                    /** */
    2344                    OM_FREE_WIRELESS(2),
    2345
    2346                    /** */
    2347                    OM_3G(3),
    2348
    2349                    /** */
    2350                    OM_4G(4);
    2351
    2352                    private static final Map<Integer,OPERATING_MEDIA> lookup = new HashMap<Integer,OPERATING_MEDIA>();
    2353
    2354                    static {
    2355                            for(OPERATING_MEDIA s : EnumSet.allOf(OPERATING_MEDIA.class))
    2356                                    lookup.put(s.getId(), s);
    2357                    }
    2358
    2359                    private final int id;
    2360
    2361                    private OPERATING_MEDIA(int value) {
    2362                            this.id = value;
    2363                    }
    2364
    2365                    public int getId() { return id; }
    2366
    2367                    public static OPERATING_MEDIA get(int code) {
    2368                            return lookup.get(code);
    2369                    }
    2370
    2371                    public static OPERATING_MEDIA fromString(String s) {
    2372                            for (OPERATING_MEDIA p : lookup.values()) {
    2373                                    if (p.toString() == s) {
    2374                                            return p;
    2375                                    }
    2376                            }
    2377                            return null;
    2378                    }
    2379            }
    2380
    2381            /**
    2382             * @param media
    2383             * @param maxUplinkBps
    2384             * @param maxDownlinkBps
    2385             */
    2386            public void SetOperatingMedia( OPERATING_MEDIA media, int maxUplinkBps, int maxDownlinkBps) {
    2387
    2388                    Request request = null;
    2389                    try {
    2390                            request = new XCallRequest(0,255);
    2391                    } catch (IOException e) {
    2392                            e.printStackTrace();
    2393                            if (errorListener != null)
    2394                                    errorListener.OnSkypeKitFatalError();
    2395                    }
    2396                    request.addParm('e',1,media.getId());
    2397                    request.addParm('u',2,maxUplinkBps);
    2398                    request.addParm('u',3,maxDownlinkBps);
    2399
    2400                    XCall((XCallRequest)request);
    2401            }
    2402
    2403            /**
    2404             *creates an CONFIRMATION_CODE_REQUEST SMS message
    2405             * @param type
    2406             * @param number
    2407             * @return sms
    2408             */
    2409            public Sms RequestConfirmationCode( Sms.CONFIRM_TYPE type, String number) {
    2410
    2411                    Request request = null;
    2412                    try {
    2413                            request = new XCallRequest(0,29);
    2414                    } catch (IOException e) {
    2415                            e.printStackTrace();
    2416                            if (errorListener != null)
    2417                                    errorListener.OnSkypeKitFatalError();
    2418                    }
    2419                    request.addParm('e',1,type.getId());
    2420                    request.addParm('S',2,number);
    2421
    2422                    Response r = XCall((XCallRequest)request);
    2423
    2424                    if (r.isErrCall())
    2425                            return null;
    2426
    2427                    int oid = 0;
    2428                    Sms sms = null;
    2429                    oid = r.GetOid(1);
    2430                    if (oid != AbstractDecoder.NULL_VALUE) {
    2431                            sms = (Sms)skype.factory(Sms.moduleID(), oid, skype);
    2432                    }
    2433                    return sms;
    2434            }
    2435
    2436            /**
    2437             *creates an CONFIRMATION_CODE_REQUEST SMS message
    2438             * @param number
    2439             * @param code
    2440             * @return sms
    2441             */
    2442            public Sms SubmitConfirmationCode( String number, String code) {
    2443
    2444                    Request request = null;
    2445                    try {
    2446                            request = new XCallRequest(0,30);
    2447                    } catch (IOException e) {
    2448                            e.printStackTrace();
    2449                            if (errorListener != null)
    2450                                    errorListener.OnSkypeKitFatalError();
    2451                    }
    2452                    request.addParm('S',1,number);
    2453                    request.addParm('S',2,code);
    2454
    2455                    Response r = XCall((XCallRequest)request);
    2456
    2457                    if (r.isErrCall())
    2458                            return null;
    2459
    2460                    int oid = 0;
    2461                    Sms sms = null;
    2462                    oid = r.GetOid(1);
    2463                    if (oid != AbstractDecoder.NULL_VALUE) {
    2464                            sms = (Sms)skype.factory(Sms.moduleID(), oid, skype);
    2465                    }
    2466                    return sms;
    2467            }
    2468
    2469            /**
    2470             *creates an OUTGOING/COMPOSING SMS message
    2471             * @return sms
    2472             */
    2473            public Sms CreateOutgoingSms() {
    2474
    2475                    Request request = null;
    2476                    try {
    2477                            request = new XCallRequest(0,70);
    2478                    } catch (IOException e) {
    2479                            e.printStackTrace();
    2480                            if (errorListener != null)
    2481                                    errorListener.OnSkypeKitFatalError();
    2482                    }
    2483
    2484                    Response r = XCall((XCallRequest)request);
    2485
    2486                    if (r.isErrCall())
    2487                            return null;
    2488
    2489                    int oid = 0;
    2490                    Sms sms = null;
    2491                    oid = r.GetOid(1);
    2492                    if (oid != AbstractDecoder.NULL_VALUE) {
    2493                            sms = (Sms)skype.factory(Sms.moduleID(), oid, skype);
    2494                    }
    2495                    return sms;
    2496            }
    2497
    2498            /** Setupkey SETUPKEY_FT_AUTOACCEPT type:int  <br>Controls file transfer auto-accept.  <br> - 0 - off <br> - 1 - on <br>This is account-specific setup key. It can only be used while an account is logged in. <br> */
    2499            public static final String FT_AUTOACCEPT = "Lib/FileTransfer/AutoAccept";
    2500
    2501            /** Setupkey SETUPKEY_FT_SAVEPATH type:string  <br>Full local path to save incoming file transfers (used for AutoAccept feature) <br>This is account-specific setup key. It can only be used while an account is logged in. <br> */
    2502            public static final String FT_SAVEPATH = "Lib/FileTransfer/SavePath";
    2503
    2504            /** Setupkey SETUPKEY_FT_INCOMING_LIMIT type:uint  <br>Number of simultaneous incoming file transfers (per user). Value 0 means no limitation.  <br>This is account-specific setup key. It can only be used while an account is logged in. <br> */
    2505            public static final String FT_INCOMING_LIMIT = "Lib/FileTransfer/IncomingLimit";
    2506
    2507            /** Setupkey SETUPKEY_IDLE_TIME_FOR_AWAY type:int  <br>Number of seconds since the last keyboard or mouse activity, after which the online status of currently logged in account should be set to AWAY. See Account.SetAvailability method for more information. <br>This is account-specific setup key. It can only be used while an account is logged in. <br> */
    2508            public static final String IDLE_TIME_FOR_AWAY = "Lib/Account/IdleTimeForAway";
    2509
    2510            /** Setupkey SETUPKEY_IDLE_TIME_FOR_NA type:int  <br>The Contact.AVAILABILITY.NOT_AVAILABLE online status has been deprecated. This setup key is no longer in use. <br> */
    2511            public static final String IDLE_TIME_FOR_NA = "Lib/Account/IdleTimeForNA";
    2512
    2513            /**
    2514             *Retrieves an Account object by Skype name (identity). This should normally be one of the first method calls after Skype object initialization. Nearly all the other methods require successful account login in order to work properly. The list of accounts that have been used on the local machine/database can be retrieved with Skype.GetExistingAccounts method. If a matching identity is not found, a new Account object is created. This object can then be used to populate requred fields and then use Account.Register method for new account creation. This method returns false on error. <br>
    2515             * @param identity Account skypename. <br>
    2516             * @return account Returns account object if successful. <br>
    2517             */
    2518            public Account GetAccount( String identity) {
    2519
    2520                    Request request = null;
    2521                    try {
    2522                            request = new XCallRequest(0,115);
    2523                    } catch (IOException e) {
    2524                            e.printStackTrace();
    2525                            if (errorListener != null)
    2526                                    errorListener.OnSkypeKitFatalError();
    2527                    }
    2528                    request.addParm('S',1,identity);
    2529
    2530                    Response r = XCall((XCallRequest)request);
    2531
    2532                    if (r.isErrCall())
    2533                            return null;
    2534
    2535                    int oid = 0;
    2536                    Account account = null;
    2537                    oid = r.GetOid(1);
    2538                    if (oid != AbstractDecoder.NULL_VALUE) {
    2539                            if (! object_list.containsKey(oid)) {
    2540                                    object_list.clear(); // #AABIP-7: Clear any other account's cached info from previous logins
    2541                            }
    2542                            account = (Account)skype.factory(Account.moduleID(), oid, skype);
    2543                    }
    2544                    return account;
    2545            }
    2546
    2547            /**
    2548             *Returns a list of possible profiles used before on this machine
    2549             * @return accountNameList
    2550             */
    2551            public String [] GetExistingAccounts() {
    2552
    2553                    Request request = null;
    2554                    try {
    2555                            request = new XCallRequest(0,113);
    2556                    } catch (IOException e) {
    2557                            e.printStackTrace();
    2558                            if (errorListener != null)
    2559                                    errorListener.OnSkypeKitFatalError();
    2560                    }
    2561
    2562                    Response r = XCall((XCallRequest)request);
    2563
    2564                    if (r.isErrCall())
    2565                            return null;
    2566
    2567                    Vector<String> accountNameList = new Vector<String>();
    2568                    while (r.HasMore(1))
    2569                    {
    2570                            String string = null;
    2571                            string  = r.GetAsString(1);
    2572                            accountNameList.add(string);
    2573                    }
    2574                    return accountNameList.toArray(new String[accountNameList.size()]);
    2575
    2576            }
    2577
    2578            /**
    2579             *return most recently used account that has pwd saved. empty string if none
    2580             * @return account
    2581             */
    2582            public String GetDefaultAccountName() {
    2583
    2584                    Request request = null;
    2585                    try {
    2586                            request = new XCallRequest(0,114);
    2587                    } catch (IOException e) {
    2588                            e.printStackTrace();
    2589                            if (errorListener != null)
    2590                                    errorListener.OnSkypeKitFatalError();
    2591                    }
    2592
    2593                    Response r = XCall((XCallRequest)request);
    2594
    2595                    if (r.isErrCall())
    2596                            return null;
    2597
    2598                    String account = null;
    2599                    account = r.GetAsString(1);
    2600                    return account;
    2601            }
    2602
    2603            /**
    2604             *suggest a nice skypename to go with given fullname
    2605             * @param fullname
    2606             * @return suggestedName
    2607             */
    2608            public String GetSuggestedSkypename( String fullname) {
    2609
    2610                    Request request = null;
    2611                    try {
    2612                            request = new XCallRequest(0,116);
    2613                    } catch (IOException e) {
    2614                            e.printStackTrace();
    2615                            if (errorListener != null)
    2616                                    errorListener.OnSkypeKitFatalError();
    2617                    }
    2618                    request.addParm('S',1,fullname);
    2619
    2620                    Response r = XCall((XCallRequest)request);
    2621
    2622                    if (r.isErrCall())
    2623                            return null;
    2624
    2625                    String suggestedName = null;
    2626                    suggestedName = r.GetAsString(1);
    2627                    return suggestedName;
    2628            }
    2629
    2630            /**
    2631            A value of this type can be returned by one of the following methods (of Skype class): ValidateAvatar, ValidateProfileString, ValidatePassword.  <br> */
    2632            public enum VALIDATERESULT {
    2633
    2634                    /** Given property could not be validated. The length of the field was within limits and the value is assumed to be Ok. Your client should treat this value as equivalent to VALIDATED_OK. <br>*/
    2635                    NOT_VALIDATED(0),
    2636
    2637                    /** Avatar or profile string validation succeeded. <br>*/
    2638                    VALIDATED_OK(1),
    2639
    2640                    /** Password is too short. <br>*/
    2641                    TOO_SHORT(2),
    2642
    2643                    /** The value exceeds max size limit for the given property. <br>*/
    2644                    TOO_LONG(3),
    2645
    2646                    /** Value contains illegal characters. <br>*/
    2647                    CONTAINS_INVALID_CHAR(4),
    2648
    2649                    /** Value contains whitespace. <br>*/
    2650                    CONTAINS_SPACE(5),
    2651
    2652                    /** Password cannot be the same as skypename. <br>*/
    2653                    SAME_AS_USERNAME(6),
    2654
    2655                    /** Value has invalid format. <br>*/
    2656                    INVALID_FORMAT(7),
    2657
    2658                    /** Value contains invalid word. <br>*/
    2659                    CONTAINS_INVALID_WORD(8),
    2660
    2661                    /** Password is too simple. <br>*/
    2662                    TOO_SIMPLE(9),
    2663
    2664                    /** Value starts with an invalid character. <br>*/
    2665                    STARTS_WITH_INVALID_CHAR(10);
    2666
    2667                    private static final Map<Integer,VALIDATERESULT> lookup = new HashMap<Integer,VALIDATERESULT>();
    2668
    2669                    static {
    2670                            for(VALIDATERESULT s : EnumSet.allOf(VALIDATERESULT.class))
    2671                                    lookup.put(s.getId(), s);
    2672                    }
    2673
    2674                    private final int id;
    2675
    2676                    private VALIDATERESULT(int value) {
    2677                            this.id = value;
    2678                    }
    2679
    2680                    public int getId() { return id; }
    2681
    2682                    public static VALIDATERESULT get(int code) {
    2683                            return lookup.get(code);
    2684                    }
    2685
    2686                    public static VALIDATERESULT fromString(String s) {
    2687                            for (VALIDATERESULT p : lookup.values()) {
    2688                                    if (p.toString() == s) {
    2689                                            return p;
    2690                                    }
    2691                            }
    2692                            return null;
    2693                    }
    2694            }
    2695
    2696            /**
    2697             * @param value
    2698             * @return ValidateAvatarResult
    2699             */
    2700            public ValidateAvatarResult ValidateAvatar( byte[] value) {
    2701
    2702                    Request request = null;
    2703                    try {
    2704                            request = new XCallRequest(0,119);
    2705                    } catch (IOException e) {
    2706                            e.printStackTrace();
    2707                            if (errorListener != null)
    2708                                    errorListener.OnSkypeKitFatalError();
    2709                    }
    2710                    request.addParm('B',1,value);
    2711
    2712                    Response r = XCall((XCallRequest)request);
    2713
    2714                    if (r.isErrCall())
    2715                            return null;
    2716
    2717                    ValidateAvatarResult result = new ValidateAvatarResult();
    2718
    2719                    VALIDATERESULT validateresult = null;
    2720                    validateresult = VALIDATERESULT.get(r.GetAsInt(1));
    2721                    result.result = validateresult;
    2722
    2723                    int freeBytesLeft = 0;
    2724                    freeBytesLeft = r.GetAsInt(2);
    2725                    result.freeBytesLeft = freeBytesLeft;
    2726
    2727                    return result;
    2728            }
    2729
    2730            public class ValidateAvatarResult {
    2731                    public VALIDATERESULT result;
    2732                    public int freeBytesLeft;
    2733            }
    2734
    2735            /**
    2736             *This method should be used for validating skypenames before registering new accounts, if the propKey is set to SKYPENAME (Contact class) and forRegistration argument is set to true. If the forRegistration argument is false, only string length check is applied. It is also useful to probe, what the size limits are, for each string property (e.g. 300 characters for moodmessage) <br>
    2737             * @param propKey
    2738             * @param strValue
    2739             * @param forRegistration
    2740             * @return ValidateProfileStringResult
    2741             */
    2742            public ValidateProfileStringResult ValidateProfileString( int propKey, String strValue, boolean forRegistration) {
    2743
    2744                    Request request = null;
    2745                    try {
    2746                            request = new XCallRequest(0,102);
    2747                    } catch (IOException e) {
    2748                            e.printStackTrace();
    2749                            if (errorListener != null)
    2750                                    errorListener.OnSkypeKitFatalError();
    2751                    }
    2752                    request.addParm('e',1,propKey);
    2753                    request.addParm('S',2,strValue);
    2754                    request.addParm('b',3,forRegistration);
    2755
    2756                    Response r = XCall((XCallRequest)request);
    2757
    2758                    if (r.isErrCall())
    2759                            return null;
    2760
    2761                    ValidateProfileStringResult result = new ValidateProfileStringResult();
    2762
    2763                    VALIDATERESULT validateresult = null;
    2764                    validateresult = VALIDATERESULT.get(r.GetAsInt(1));
    2765                    result.result = validateresult;
    2766
    2767                    int freeBytesLeft = 0;
    2768                    freeBytesLeft = r.GetAsInt(2);
    2769                    result.freeBytesLeft = freeBytesLeft;
    2770
    2771                    return result;
    2772            }
    2773
    2774            public class ValidateProfileStringResult {
    2775                    public VALIDATERESULT result;
    2776                    public int freeBytesLeft;
    2777            }
    2778
    2779            /**
    2780             *This method is for pre-validating account passwords before account creation or password change. The result will return either VALIDATED_OK or one of many possible reasons the password is unacceptable (too short, too simple, etc.) <br>
    2781             * @param username
    2782             * @param password
    2783             * @return result
    2784             */
    2785            public VALIDATERESULT ValidatePassword( String username, String password) {
    2786
    2787                    Request request = null;
    2788                    try {
    2789                            request = new XCallRequest(0,71);
    2790                    } catch (IOException e) {
    2791                            e.printStackTrace();
    2792                            if (errorListener != null)
    2793                                    errorListener.OnSkypeKitFatalError();
    2794                    }
    2795                    request.addParm('S',1,username);
    2796                    request.addParm('S',2,password);
    2797
    2798                    Response r = XCall((XCallRequest)request);
    2799
    2800                    if (r.isErrCall())
    2801                            return null;
    2802
    2803                    VALIDATERESULT validateresult = null;
    2804                    validateresult = VALIDATERESULT.get(r.GetAsInt(1));
    2805                    return validateresult;
    2806            }
    2807
    2808            /** Setupkey SETUPKEY_PORT type:int  <br>Suggested port number (lib will *try* to use that) <br>This setup key is machine-specific and affects all local accounts. <br> */
    2809            public static final String PORT = "*Lib/Connection/Port";
    2810
    2811            /** Setupkey SETUPKEY_HTTPS_PROXY_ENABLE type:int  <br>Set to 0 for automatic proxy detect, 1 to use proxy config below <br>This setup key is machine-specific and affects all local accounts. <br> */
    2812            public static final String HTTPS_PROXY_ENABLE = "*Lib/Connection/HttpsProxy/Enable";
    2813
    2814            /** Setupkey SETUPKEY_HTTPS_PROXY_ADDR type:string  <br>name:port of HTTP proxy server <br>This setup key is machine-specific and affects all local accounts. <br> */
    2815            public static final String HTTPS_PROXY_ADDR = "*Lib/Connection/HttpsProxy/Addr";
    2816
    2817            /** Setupkey SETUPKEY_HTTPS_PROXY_USER type:string  <br>HTTPS proxy server username <br>This setup key is machine-specific and affects all local accounts. <br> */
    2818            public static final String HTTPS_PROXY_USER = "*Lib/Connection/HttpsProxy/User";
    2819
    2820            /** Setupkey SETUPKEY_HTTPS_PROXY_PWD type:string  <br>HTTPS proxy server password (base64 encoded) <br>This setup key is machine-specific and affects all local accounts. <br> */
    2821            public static final String HTTPS_PROXY_PWD = "*Lib/Connection/HttpsProxy/Pwd";
    2822
    2823            /** Setupkey SETUPKEY_SOCKS_PROXY_ENABLE type:int  <br>Set to non-zero to enable socks proxy support <br>This setup key is machine-specific and affects all local accounts. <br> */
    2824            public static final String SOCKS_PROXY_ENABLE = "*Lib/Connection/SocksProxy/Enable";
    2825
    2826            /** Setupkey SETUPKEY_SOCKS_PROXY_ADDR type:string  <br>name:port of SOCKS proxy server <br>This setup key is machine-specific and affects all local accounts. <br> */
    2827            public static final String SOCKS_PROXY_ADDR = "*Lib/Connection/SocksProxy/Addr";
    2828
    2829            /** Setupkey SETUPKEY_SOCKS_PROXY_USER type:string  <br>SOCKS proxy server username <br>This setup key is machine-specific and affects all local accounts. <br> */
    2830            public static final String SOCKS_PROXY_USER = "*Lib/Connection/SocksProxy/User";
    2831
    2832            /** Setupkey SETUPKEY_SOCKS_PROXY_PWD type:string  <br>SOCKS proxy server password (base64 encoded) <br>This setup key is machine-specific and affects all local accounts. <br> */
    2833            public static final String SOCKS_PROXY_PWD = "*Lib/Connection/SocksProxy/Pwd";
    2834
    2835            /** Setupkey SETUPKEY_LOCALADDRESS type:string  <br>local interface to listen to <br>This setup key is machine-specific and affects all local accounts. <br> */
    2836            public static final String LOCALADDRESS = "*Lib/Connection/LocalAddress";
    2837
    2838            /** Setupkey SETUPKEY_DISABLE_PORT80 type:int  <br>1 disables listening of alternative ports (80, 443) <br>This setup key is machine-specific and affects all local accounts. <br> */
    2839            public static final String DISABLE_PORT80 = "*Lib/Connection/DisablePort80";
    2840
    2841            /** Setupkey SETUPKEY_DISABLE_UDP type:int  <br>1 disables UDP port binding. should be set before connect <br>This setup key is machine-specific and affects all local accounts. <br> */
    2842            public static final String DISABLE_UDP = "*Lib/Connection/DisableUDP";
    2843
    2844            /**
    2845             */
    2846            public enum PROXYTYPE {
    2847
    2848                    /** */
    2849                    HTTPS_PROXY(0),
    2850
    2851                    /** */
    2852                    SOCKS_PROXY(1);
    2853
    2854                    private static final Map<Integer,PROXYTYPE> lookup = new HashMap<Integer,PROXYTYPE>();
    2855
    2856                    static {
    2857                            for(PROXYTYPE s : EnumSet.allOf(PROXYTYPE.class))
    2858                                    lookup.put(s.getId(), s);
    2859                    }
    2860
    2861                    private final int id;
    2862
    2863                    private PROXYTYPE(int value) {
    2864                            this.id = value;
    2865                    }
    2866
    2867                    public int getId() { return id; }
    2868
    2869                    public static PROXYTYPE get(int code) {
    2870                            return lookup.get(code);
    2871                    }
    2872
    2873                    public static PROXYTYPE fromString(String s) {
    2874                            for (PROXYTYPE p : lookup.values()) {
    2875                                    if (p.toString() == s) {
    2876                                            return p;
    2877                                    }
    2878                            }
    2879                            return null;
    2880                    }
    2881            }
    2882
    2883            /**
    2884             *This is used for retrieving local setup keys of type string. For more information, see Defines section in the skype-embedded_2.h  <br>
    2885             * @param key
    2886             * @return value
    2887             */
    2888            public String GetStr( String key) {
    2889
    2890                    Request request = null;
    2891                    try {
    2892                            request = new XCallRequest(0,120);
    2893                    } catch (IOException e) {
    2894                            e.printStackTrace();
    2895                            if (errorListener != null)
    2896                                    errorListener.OnSkypeKitFatalError();
    2897                    }
    2898                    request.addParm('S',1,key);
    2899
    2900                    Response r = XCall((XCallRequest)request);
    2901
    2902                    if (r.isErrCall())
    2903                            return null;
    2904
    2905                    String value = null;
    2906                    value = r.GetAsString(1);
    2907                    return value;
    2908            }
    2909
    2910            /**
    2911             *This is used for retrieving local setup keys of type int. For more information, see Defines section in the skype-embedded_2.h  <br>
    2912             * @param key
    2913             * @return value
    2914             */
    2915            public int GetInt( String key) {
    2916
    2917                    Request request = null;
    2918                    try {
    2919                            request = new XCallRequest(0,121);
    2920                    } catch (IOException e) {
    2921                            e.printStackTrace();
    2922                            if (errorListener != null)
    2923                                    errorListener.OnSkypeKitFatalError();
    2924                    }
    2925                    request.addParm('S',1,key);
    2926
    2927                    Response r = XCall((XCallRequest)request);
    2928
    2929                    if (r.isErrCall())
    2930                            return 0;
    2931
    2932                    int value = 0;
    2933                    value = r.GetAsInt(1);
    2934                    return value;
    2935            }
    2936
    2937            /**
    2938             *This is used for retrieving local setup keys of type binary. For more information, see Defines section in the skype-embedded_2.h  <br>
    2939             * @param key
    2940             * @return value
    2941             */
    2942            public byte[] GetBin( String key) {
    2943
    2944                    Request request = null;
    2945                    try {
    2946                            request = new XCallRequest(0,122);
    2947                    } catch (IOException e) {
    2948                            e.printStackTrace();
    2949                            if (errorListener != null)
    2950                                    errorListener.OnSkypeKitFatalError();
    2951                    }
    2952                    request.addParm('S',1,key);
    2953
    2954                    Response r = XCall((XCallRequest)request);
    2955
    2956                    if (r.isErrCall())
    2957                            return null;
    2958
    2959                    byte[] value = null;
    2960                    value = r.GetAsBinary(1);
    2961                    return value;
    2962            }
    2963
    2964            /**
    2965             *This is used for setting local setup keys of type string. For more information, see Defines section in the skype-embedded_2.h  <br>
    2966             * @param key
    2967             * @param value
    2968             */
    2969            public void SetStr( String key, String value) {
    2970
    2971                    Request request = null;
    2972                    try {
    2973                            request = new XCallRequest(0,123);
    2974                    } catch (IOException e) {
    2975                            e.printStackTrace();
    2976                            if (errorListener != null)
    2977                                    errorListener.OnSkypeKitFatalError();
    2978                    }
    2979                    request.addParm('S',1,key);
    2980                    request.addParm('S',2,value);
    2981
    2982                    XCall((XCallRequest)request);
    2983            }
    2984
    2985            /**
    2986             *This is used for setting local setup keys of type int. For more information, see Defines section in the skype-embedded_2.h  <br>
    2987             * @param key
    2988             * @param value
    2989             */
    2990            public void SetInt( String key, int value) {
    2991
    2992                    Request request = null;
    2993                    try {
    2994                            request = new XCallRequest(0,124);
    2995                    } catch (IOException e) {
    2996                            e.printStackTrace();
    2997                            if (errorListener != null)
    2998                                    errorListener.OnSkypeKitFatalError();
    2999                    }
    3000                    request.addParm('S',1,key);
    3001                    request.addParm('i',2,value);
    3002
    3003                    XCall((XCallRequest)request);
    3004            }
    3005
    3006            /**
    3007             *This is used for setting local setup keys of type binary. For more information, see Defines section in the skype-embedded_2.h  <br>
    3008             * @param key
    3009             * @param value
    3010             */
    3011            public void SetBin( String key, byte[] value) {
    3012
    3013                    Request request = null;
    3014                    try {
    3015                            request = new XCallRequest(0,125);
    3016                    } catch (IOException e) {
    3017                            e.printStackTrace();
    3018                            if (errorListener != null)
    3019                                    errorListener.OnSkypeKitFatalError();
    3020                    }
    3021                    request.addParm('S',1,key);
    3022                    request.addParm('B',2,value);
    3023
    3024                    XCall((XCallRequest)request);
    3025            }
    3026
    3027            /**
    3028             *Returns true if the given setup key is defined in local setup. For more information, see Defines section in the skype-embedded_2.h  <br>
    3029             * @param key
    3030             * @return value
    3031             */
    3032            public boolean IsDefined( String key) {
    3033
    3034                    Request request = null;
    3035                    try {
    3036                            request = new XCallRequest(0,126);
    3037                    } catch (IOException e) {
    3038                            e.printStackTrace();
    3039                            if (errorListener != null)
    3040                                    errorListener.OnSkypeKitFatalError();
    3041                    }
    3042                    request.addParm('S',1,key);
    3043
    3044                    Response r = XCall((XCallRequest)request);
    3045
    3046                    if (r.isErrCall())
    3047                            return false;
    3048
    3049                    boolean value = false;
    3050                    value = r.GetAsBoolean(1);
    3051                    return value;
    3052            }
    3053
    3054            /**
    3055             * @param key
    3056             */
    3057            public void Delete( String key) {
    3058
    3059                    Request request = null;
    3060                    try {
    3061                            request = new XCallRequest(0,127);
    3062                    } catch (IOException e) {
    3063                            e.printStackTrace();
    3064                            if (errorListener != null)
    3065                                    errorListener.OnSkypeKitFatalError();
    3066                    }
    3067                    request.addParm('S',1,key);
    3068
    3069                    XCall((XCallRequest)request);
    3070            }
    3071
    3072            /**
    3073             * @param key
    3074             * @return value
    3075             */
    3076            public String [] GetSubKeys( String key) {
    3077
    3078                    Request request = null;
    3079                    try {
    3080                            request = new XCallRequest(0,128);
    3081                    } catch (IOException e) {
    3082                            e.printStackTrace();
    3083                            if (errorListener != null)
    3084                                    errorListener.OnSkypeKitFatalError();
    3085                    }
    3086                    request.addParm('S',1,key);
    3087
    3088                    Response r = XCall((XCallRequest)request);
    3089
    3090                    if (r.isErrCall())
    3091                            return null;
    3092
    3093                    Vector<String> value = new Vector<String>();
    3094                    while (r.HasMore(1))
    3095                    {
    3096                            String string = null;
    3097                            string  = r.GetAsString(1);
    3098                            value.add(string);
    3099                    }
    3100                    return value.toArray(new String[value.size()]);
    3101
    3102            }
    3103
    3104            /**
    3105             *Returns two string lists. First of them will contain list of two-letter language codes (ISO 639-1) The second list contains names of corresponding languages. <br>
    3106             * @return GetISOLanguageInfoResult
    3107             */
    3108            public GetISOLanguageInfoResult GetISOLanguageInfo() {
    3109
    3110                    Request request = null;
    3111                    try {
    3112                            request = new XCallRequest(0,207);
    3113                    } catch (IOException e) {
    3114                            e.printStackTrace();
    3115                            if (errorListener != null)
    3116                                    errorListener.OnSkypeKitFatalError();
    3117                    }
    3118
    3119                    Response r = XCall((XCallRequest)request);
    3120
    3121                    if (r.isErrCall())
    3122                            return null;
    3123
    3124                    GetISOLanguageInfoResult result = new GetISOLanguageInfoResult();
    3125
    3126                    Vector<String> languageCodeList = new Vector<String>();
    3127                    while (r.HasMore(1))
    3128                    {
    3129                            String string = null;
    3130                            string  = r.GetAsString(1);
    3131                            languageCodeList.add(string);
    3132                    }
    3133                    result.languageCodeList = languageCodeList.toArray(new String[languageCodeList.size()]);
    3134
    3135                    Vector<String> languageNameList = new Vector<String>();
    3136                    while (r.HasMore(2))
    3137                    {
    3138                            String string = null;
    3139                            string  = r.GetAsString(2);
    3140                            languageNameList.add(string);
    3141                    }
    3142                    result.languageNameList = languageNameList.toArray(new String[languageNameList.size()]);
    3143
    3144                    return result;
    3145            }
    3146
    3147            public class GetISOLanguageInfoResult {
    3148                    public String [] languageCodeList;
    3149                    public String [] languageNameList; /** assumes UI has set correct language */
    3150            }
    3151
    3152            /**
    3153             *Returns three string lists and one int array, containing 2-letter country code, country name, dialing prefix and example dial string (not available for all items). This method does currently return 0 for South Georgia and the South Sandwich Islands. <br>
    3154             * @return GetISOCountryInfoResult
    3155             */
    3156            public GetISOCountryInfoResult GetISOCountryInfo() {
    3157
    3158                    Request request = null;
    3159                    try {
    3160                            request = new XCallRequest(0,208);
    3161                    } catch (IOException e) {
    3162                            e.printStackTrace();
    3163                            if (errorListener != null)
    3164                                    errorListener.OnSkypeKitFatalError();
    3165                    }
    3166
    3167                    Response r = XCall((XCallRequest)request);
    3168
    3169                    if (r.isErrCall())
    3170                            return null;
    3171
    3172                    GetISOCountryInfoResult result = new GetISOCountryInfoResult();
    3173
    3174                    Vector<String> countryCodeList = new Vector<String>();
    3175                    while (r.HasMore(1))
    3176                    {
    3177                            String string = null;
    3178                            string  = r.GetAsString(1);
    3179                            countryCodeList.add(string);
    3180                    }
    3181                    result.countryCodeList = countryCodeList.toArray(new String[countryCodeList.size()]);
    3182
    3183                    Vector<String> countryNameList = new Vector<String>();
    3184                    while (r.HasMore(2))
    3185                    {
    3186                            String string = null;
    3187                            string  = r.GetAsString(2);
    3188                            countryNameList.add(string);
    3189                    }
    3190                    result.countryNameList = countryNameList.toArray(new String[countryNameList.size()]);
    3191
    3192                    Vector<Integer> countryPrefixList = new Vector<Integer>();
    3193                    while (r.HasMore(3))
    3194                    {
    3195                            Integer integer = null;
    3196                            integer = new Integer(r.GetAsInt(3));
    3197                            countryPrefixList.add(integer);
    3198                    }
    3199
    3200                    int[] intArray = new int[countryPrefixList.size()];
    3201                    for (int i = 0; i < countryPrefixList.size(); i++) {
    3202                            intArray[i] = countryPrefixList.get(i);
    3203                    }
    3204                    result.countryPrefixList = intArray;
    3205                    Vector<String> countryDialExampleList = new Vector<String>();
    3206                    while (r.HasMore(4))
    3207                    {
    3208                            String string = null;
    3209                            string  = r.GetAsString(4);
    3210                            countryDialExampleList.add(string);
    3211                    }
    3212                    result.countryDialExampleList = countryDialExampleList.toArray(new String[countryDialExampleList.size()]);
    3213
    3214                    return result;
    3215            }
    3216
    3217            public class GetISOCountryInfoResult {
    3218                    public String [] countryCodeList;
    3219                    public String [] countryNameList; /** assumes UI has set correct language */
    3220                    public int [] countryPrefixList;
    3221                    public String [] countryDialExampleList;
    3222            }
    3223
    3224            /**
    3225             *Returns 2-letter country code based on PSTN number. The input argument has to be without + in from of it - '37212345678' will return 'ee' while '+37212345678' will return an empty string. <br>
    3226             * @param number
    3227             * @return countryCode
    3228             */
    3229            public String GetISOCountryCodebyPhoneNo( String number) {
    3230
    3231                    Request request = null;
    3232                    try {
    3233                            request = new XCallRequest(0,211);
    3234                    } catch (IOException e) {
    3235                            e.printStackTrace();
    3236                            if (errorListener != null)
    3237                                    errorListener.OnSkypeKitFatalError();
    3238                    }
    3239                    request.addParm('S',1,number);
    3240
    3241                    Response r = XCall((XCallRequest)request);
    3242
    3243                    if (r.isErrCall())
    3244                            return null;
    3245
    3246                    String countryCode = null;
    3247                    countryCode = r.GetAsString(1);
    3248                    return countryCode;
    3249            }
    3250
    3251
    3252    }