C# SkypeKit.SktConversation类代码示例

 public OnConversationUnconsumedSuppressedMessagesArgs(SktConversation sender, uint newValue)
 {
     this.sender = sender;  value = newValue;
 }

 internal void FireOnConversationPasswordhint(SktConversation sender, String value)
 {
     if (OnConversationPasswordhint == null) return; // Event not assigned
     OnConversationPasswordhintArgs args = new OnConversationPasswordhintArgs(sender, value);
     if (gui == null) { FireCallbackInSeparateThread(args, OnConversationPasswordhintInNewThread); return; } // No gui firing in separate thread
     gui.BeginInvoke(OnConversationPasswordhint, new object[] { sender, args }); // Syncing to GUI thread
 }

 internal void FireOnConversationUnconsumedSuppressedMessages(SktConversation sender, uint value)
 {
     if (OnConversationUnconsumedSuppressedMessages == null) return; // Event not assigned
     OnConversationUnconsumedSuppressedMessagesArgs args = new OnConversationUnconsumedSuppressedMessagesArgs(sender, value);
     if (gui == null) { FireCallbackInSeparateThread(args, OnConversationUnconsumedSuppressedMessagesInNewThread); return; } // No gui firing in separate thread
     gui.BeginInvoke(OnConversationUnconsumedSuppressedMessages, new object[] { sender, args }); // Syncing to GUI thread
 }

 internal void FireOnConversationMetaPicture(SktConversation sender, byte[] value)
 {
     if (OnConversationMetaPicture == null) return; // Event not assigned
     OnConversationMetaPictureArgs args = new OnConversationMetaPictureArgs(sender, value);
     if (gui == null) { FireCallbackInSeparateThread(args, OnConversationMetaPictureInNewThread); return; } // No gui firing in separate thread
     gui.BeginInvoke(OnConversationMetaPicture, new object[] { sender, args }); // Syncing to GUI thread
 }

 internal void FireOnConversationOptAdminOnlyActivities(SktConversation sender, SktConversation.ALLOWED_ACTIVITY value)
 {
     if (OnConversationOptAdminOnlyActivities == null) return; // Event not assigned
     OnConversationOptAdminOnlyActivitiesArgs args = new OnConversationOptAdminOnlyActivitiesArgs(sender, value);
     if (gui == null) { FireCallbackInSeparateThread(args, OnConversationOptAdminOnlyActivitiesInNewThread); return; } // No gui firing in separate thread
     gui.BeginInvoke(OnConversationOptAdminOnlyActivities, new object[] { sender, args }); // Syncing to GUI thread
 }

        /** When the socket reader receives a property update from runtime, it decodes object ID
         * property ID and the new value of the property. It then calls this method of
         * the target object, to update the new value in property cache. After updating the cache,
         * this method then fires appropriate event in skype.events to notify the UI of what has happened.
         * DispatchPropertyUpdate is executed in the socket reader thread.
         */
        internal override void DispatchPropertyUpdate(uint propId, object value, bool hasValue)
        {
            switch (propId)
            {
            case 972: /* Conversation.P_IDENTITY */
                cache[0] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_identity = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_IDENTITY = " + cache_identity.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_IDENTITY - update without value");
                skypeRef.events.FireOnConversationIdentity(this, cache_identity);
                break;

            case 902: /* Conversation.P_TYPE */
                cache[1] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_type = (SktConversation.TYPE)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_TYPE = " + cache_type.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_TYPE - update without value");
                skypeRef.events.FireOnConversationType(this, cache_type);
                break;

            case 918: /* Conversation.P_LIVE_HOST */
                cache[2] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_host = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_HOST = " + cache_live_host.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_HOST - update without value");
                skypeRef.events.FireOnConversationLiveHost(this, cache_live_host);
                break;

            case 974: /* Conversation.P_LIVE_START_TIMESTAMP */
                cache[3] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_start_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_START_TIMESTAMP = " + cache_live_start_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_START_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationLiveStartTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_live_start_timestamp));
                break;

            case 996: /* Conversation.P_LIVE_IS_MUTED */
                cache[4] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_is_muted = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_IS_MUTED = " + cache_live_is_muted.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_IS_MUTED - update without value");
                skypeRef.events.FireOnConversationLiveIsMuted(this, cache_live_is_muted);
                break;

            case 920: /* Conversation.P_ALERT_STRING */
                cache[5] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_alert_string = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_ALERT_STRING = " + cache_alert_string.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_ALERT_STRING - update without value");
                skypeRef.events.FireOnConversationAlertString(this, cache_alert_string);
                break;

            case 921: /* Conversation.P_IS_BOOKMARKED */
                cache[6] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_is_bookmarked = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_IS_BOOKMARKED = " + cache_is_bookmarked.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_IS_BOOKMARKED - update without value");
                skypeRef.events.FireOnConversationIsBookmarked(this, cache_is_bookmarked);
                break;

            case 925: /* Conversation.P_GIVEN_DISPLAYNAME */
                cache[7] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_given_displayname = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_GIVEN_DISPLAYNAME = " + cache_given_displayname.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_GIVEN_DISPLAYNAME - update without value");
                skypeRef.events.FireOnConversationGivenDisplayname(this, cache_given_displayname);
                break;

            case 924: /* Conversation.P_DISPLAYNAME */
                cache[8] = hasValue; // if no value - invalidate cache
//.........这里部分代码省略.........

 public void Add(SktConversation item)
 {
     base.Add((SktConversation)item);
 }

 public OnVideoConvoIdArgs(SktVideo sender, SktConversation newValue)
 {
     this.sender = sender;  value = newValue;
 }

 public OnVoicemailConvoIdArgs(SktVoicemail sender, SktConversation newValue)
 {
     this.sender = sender;  value = newValue;
 }

 public OnTransferConvoIdArgs(SktTransfer sender, SktConversation newValue)
 {
     this.sender = sender;  value = newValue;
 }

 public OnParticipantConvoIdArgs(SktParticipant sender, SktConversation newValue)
 {
     this.sender = sender;  value = newValue;
 }

 public OnMessageConvoIdArgs(SktMessage sender, SktConversation newValue)
 {
     this.sender = sender;  value = newValue;
 }

 /**  Merges two live conversations. For example, if the user already has a live conversation up - let's call
   it conversation A. Then a new incoming call occurs - another conversation obtains LOCAL_LIVESTATUS ==
   SktConversation.RINGING_FOR_ME, let's call it conversation B. The user wishes to pick up the new incoming
   call and add it to the existing one. For this you can first call B->JoinLiveSession and then merge two
   calls with A->Assimilate(B, A). The second argument will return the merged conversation. Note that there
   are actually three conversation objects involved: A (before merge), B and C (after the merge). Normally
   it would make sense to have the first conversation (A) as the second argument, so that it gets overwritten
   with the assimilation result.
 @returns conversation Returns a 3rd live conversation, result of merging two existing ones.
 @param [in] otherConversation - The new conversation to be merged with the one already in live state.
  */
 public SktConversation Assimilate(SktConversation otherConversation)
 {
     if (skypeRef.logging) skypeRef.Log("Executing Conversation.Assimilate");
     uint RequestId = skypeRef.encoder.AddMethodHeader(ClassId, 9, OID);
     skypeRef.encoder.AddObjectParam(1, otherConversation);
     skypeRef.transport.SubmitMethodRequest (RequestId);
     Dictionary<uint, uint> tagMap = new Dictionary<uint, uint> { {1, 1} };
     object[] args = new object[1];
     args[0] = null;
     skypeRef.decoder.DecodeMethodResponseArguments(1, ref args, new uint[1]{18}, ref tagMap, "SktConversation.Assimilate");
     return (SktConversation)args[0];
 }

 /**  Returns a list of Conversation objects by SktConversation.LIST_TYPE filter.
 @returns conversations List of conversations matching the filter.
 @param [in] type - Filter. Default value is SktConversation.LIST_TYPE.ALL_CONVERSATIONS
  */
 public SktConversation.List GetConversationList(SktConversation.LIST_TYPE type=SktConversation.LIST_TYPE.ALL_CONVERSATIONS)
 {
     if (skypeRef.logging) skypeRef.Log("Executing Skype.GetConversationList");
     uint RequestId = skypeRef.encoder.AddMethodHeader(ClassId, 18, OID);
     skypeRef.encoder.AddEnumParam(1, (uint)type);
     SktConversation.List conversations = new SktConversation.List(); // We always guarantee non-null list is returned
     skypeRef.transport.SubmitMethodRequest (RequestId);
     int argNr, marker;
     do
     {
     marker = (char)skypeRef.transport.ReadByte();
     if (marker != 'z')
     {
         if (marker == 'N') skypeRef.Error("SktSkype.GetConversationList failed.");
         argNr = (char)skypeRef.transport.ReadByte();
         switch (argNr)
         {
             case 1:
                 conversations = (SktConversation.List)skypeRef.decoder.DecodeObjectList(18);
                 break;
             case 'z': marker = argNr; break; // exiting the arg loop if the method failed
             default:
                 skypeRef.Error(String.Format("Got unexpected response argument {0} from runtime in SktSkype.GetConversationList", argNr));
                 break;
         }
     }
     } while (marker != 'z');
     skypeRef.transport.ResumeSocketReaderFromMethod();
     return conversations;
 }

 /**  Retrieves the list of this conversation's current participants, which you can optionally request to be
   filtered. If no Participants pass the filter, an empty list will be returned (the method itself still
   returns true).
 @returns participants List of conversation Participant objects that passed the filter.
 @param [in] filter - SktConversation.PARTICIPANTFILTER - defaults to SktConversation.ALL Default value is SktConversation.PARTICIPANTFILTER.ALL
  */
 public SktParticipant.List GetParticipants(SktConversation.PARTICIPANTFILTER filter=SktConversation.PARTICIPANTFILTER.ALL)
 {
     if (skypeRef.logging) skypeRef.Log("Executing Conversation.GetParticipants");
     uint RequestId = skypeRef.encoder.AddMethodHeader(ClassId, 38, OID);
     skypeRef.encoder.AddEnumParam(1, (uint)filter);
     SktParticipant.List participants = new SktParticipant.List(); // We always guarantee non-null list is returned
     skypeRef.transport.SubmitMethodRequest (RequestId);
     int argNr, marker;
     do
     {
     marker = (char)skypeRef.transport.ReadByte();
     if (marker != 'z')
     {
         if (marker == 'N') skypeRef.Error("SktConversation.GetParticipants failed.");
         argNr = (char)skypeRef.transport.ReadByte();
         switch (argNr)
         {
             case 1:
                 participants = (SktParticipant.List)skypeRef.decoder.DecodeObjectList(19);
                 break;
             case 'z': marker = argNr; break; // exiting the arg loop if the method failed
             default:
                 skypeRef.Error(String.Format("Got unexpected response argument {0} from runtime in SktConversation.GetParticipants", argNr));
                 break;
         }
     }
     } while (marker != 'z');
     skypeRef.transport.ResumeSocketReaderFromMethod();
     return participants;
 }