/** 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
                if (hasValue)
                {
                    cache_displayname = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_DISPLAYNAME = " + cache_displayname.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_DISPLAYNAME - update without value");
                skypeRef.events.FireOnConversationDisplayname(this, cache_displayname);
                break;

            case 927: /* Conversation.P_LOCAL_LIVESTATUS */
                cache[9] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_local_livestatus = (SktConversation.LOCAL_LIVESTATUS)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LOCAL_LIVESTATUS = " + cache_local_livestatus.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LOCAL_LIVESTATUS - update without value");
                skypeRef.events.FireOnConversationLocalLivestatus(this, cache_local_livestatus);
                break;

            case 928: /* Conversation.P_INBOX_TIMESTAMP */
                cache[10] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_inbox_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_TIMESTAMP = " + cache_inbox_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationInboxTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_inbox_timestamp));
                break;

            case 973: /* Conversation.P_INBOX_MESSAGE_ID */
                cache[11] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_inbox_message_id = (SktMessage)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_MESSAGE_ID = " + cache_inbox_message_id.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_MESSAGE_ID - update without value");
                skypeRef.events.FireOnConversationInboxMessageId(this, cache_inbox_message_id);
                break;

            case 975: /* Conversation.P_UNCONSUMED_SUPPRESSED_MESSAGES */
                cache[12] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_suppressed_messages = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_SUPPRESSED_MESSAGES = " + cache_unconsumed_suppressed_messages.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_SUPPRESSED_MESSAGES - update without value");
                skypeRef.events.FireOnConversationUnconsumedSuppressedMessages(this, cache_unconsumed_suppressed_messages);
                break;

            case 976: /* Conversation.P_UNCONSUMED_NORMAL_MESSAGES */
                cache[13] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_normal_messages = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_NORMAL_MESSAGES = " + cache_unconsumed_normal_messages.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_NORMAL_MESSAGES - update without value");
                skypeRef.events.FireOnConversationUnconsumedNormalMessages(this, cache_unconsumed_normal_messages);
                break;

            case 977: /* Conversation.P_UNCONSUMED_ELEVATED_MESSAGES */
                cache[14] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_elevated_messages = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_ELEVATED_MESSAGES = " + cache_unconsumed_elevated_messages.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_ELEVATED_MESSAGES - update without value");
                skypeRef.events.FireOnConversationUnconsumedElevatedMessages(this, cache_unconsumed_elevated_messages);
                break;

            case 970: /* Conversation.P_UNCONSUMED_MESSAGES_VOICE */
                cache[15] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_messages_voice = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_MESSAGES_VOICE = " + cache_unconsumed_messages_voice.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_MESSAGES_VOICE - update without value");
                skypeRef.events.FireOnConversationUnconsumedMessagesVoice(this, cache_unconsumed_messages_voice);
                break;

            case 971: /* Conversation.P_ACTIVE_VM_ID */
                cache[16] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_active_vm_id = (SktVoicemail)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_ACTIVE_VM_ID = " + cache_active_vm_id.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_ACTIVE_VM_ID - update without value");
                skypeRef.events.FireOnConversationActiveVmId(this, cache_active_vm_id);
                break;

            case 979: /* Conversation.P_CONSUMPTION_HORIZON */
                cache[17] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_consumption_horizon = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_CONSUMPTION_HORIZON = " + cache_consumption_horizon.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_CONSUMPTION_HORIZON - update without value");
                skypeRef.events.FireOnConversationConsumptionHorizon(this, skypeRef.UnixTimestampToDateTime(cache_consumption_horizon));
                break;

            case 981: /* Conversation.P_LAST_ACTIVITY_TIMESTAMP */
                cache[18] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_last_activity_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LAST_ACTIVITY_TIMESTAMP = " + cache_last_activity_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LAST_ACTIVITY_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationLastActivityTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_last_activity_timestamp));
                break;

            case 915: /* Conversation.P_SPAWNED_FROM_CONVO_ID */
                cache[19] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_spawned_from_convo_id = (SktConversation)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_SPAWNED_FROM_CONVO_ID = " + cache_spawned_from_convo_id.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_SPAWNED_FROM_CONVO_ID - update without value");
                skypeRef.events.FireOnConversationSpawnedFromConvoId(this, cache_spawned_from_convo_id);
                break;

            case 903: /* Conversation.P_CREATOR */
                cache[20] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_creator = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATOR = " + cache_creator.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATOR - update without value");
                skypeRef.events.FireOnConversationCreator(this, cache_creator);
                break;

            case 904: /* Conversation.P_CREATION_TIMESTAMP */
                cache[21] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_creation_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATION_TIMESTAMP = " + cache_creation_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATION_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationCreationTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_creation_timestamp));
                break;

            case 919: /* Conversation.P_MY_STATUS */
                cache[22] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_my_status = (SktConversation.MY_STATUS)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_MY_STATUS = " + cache_my_status.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_MY_STATUS - update without value");
                skypeRef.events.FireOnConversationMyStatus(this, cache_my_status);
                break;

            case 922: /* Conversation.P_OPT_JOINING_ENABLED */
                cache[23] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_joining_enabled = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_JOINING_ENABLED = " + cache_opt_joining_enabled.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_JOINING_ENABLED - update without value");
                skypeRef.events.FireOnConversationOptJoiningEnabled(this, cache_opt_joining_enabled);
                break;

            case 906: /* Conversation.P_OPT_ENTRY_LEVEL_RANK */
                cache[24] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_entry_level_rank = (SktParticipant.RANK)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ENTRY_LEVEL_RANK = " + cache_opt_entry_level_rank.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ENTRY_LEVEL_RANK - update without value");
                skypeRef.events.FireOnConversationOptEntryLevelRank(this, cache_opt_entry_level_rank);
                break;

            case 907: /* Conversation.P_OPT_DISCLOSE_HISTORY */
                cache[25] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_disclose_history = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_DISCLOSE_HISTORY = " + cache_opt_disclose_history.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_DISCLOSE_HISTORY - update without value");
                skypeRef.events.FireOnConversationOptDiscloseHistory(this, cache_opt_disclose_history);
                break;

            case 909: /* Conversation.P_OPT_ADMIN_ONLY_ACTIVITIES */
                cache[26] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_admin_only_activities = (SktConversation.ALLOWED_ACTIVITY)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ADMIN_ONLY_ACTIVITIES = " + cache_opt_admin_only_activities.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ADMIN_ONLY_ACTIVITIES - update without value");
                skypeRef.events.FireOnConversationOptAdminOnlyActivities(this, cache_opt_admin_only_activities);
                break;

            case 980: /* Conversation.P_PASSWORDHINT */
                cache[27] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_passwordhint = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_PASSWORDHINT = " + cache_passwordhint.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_PASSWORDHINT - update without value");
                skypeRef.events.FireOnConversationPasswordhint(this, cache_passwordhint);
                break;

            case 910: /* Conversation.P_META_NAME */
                cache[28] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_name = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_NAME = " + cache_meta_name.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_NAME - update without value");
                skypeRef.events.FireOnConversationMetaName(this, cache_meta_name);
                break;

            case 911: /* Conversation.P_META_TOPIC */
                cache[29] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_topic = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_TOPIC = " + cache_meta_topic.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_TOPIC - update without value");
                skypeRef.events.FireOnConversationMetaTopic(this, cache_meta_topic);
                break;

            case 913: /* Conversation.P_META_GUIDELINES */
                cache[30] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_guidelines = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_GUIDELINES = " + cache_meta_guidelines.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_GUIDELINES - update without value");
                skypeRef.events.FireOnConversationMetaGuidelines(this, cache_meta_guidelines);
                break;

            case 914: /* Conversation.P_META_PICTURE */
                cache[31] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_picture = (byte[])value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_PICTURE = binary size " + cache_meta_picture.Length.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_PICTURE - update without value");
                skypeRef.events.FireOnConversationMetaPicture(this, cache_meta_picture);
                break;

            default:
                skypeRef.Error(String.Format("Invalid Conversation class property ID ({0})received from socket.", propId)); break;
            }
        }
 internal void FetchLocalLivestatusFromRuntime()
 {
     if (skypeRef.logging) skypeRef.Log("Fetching P_LOCAL_LIVESTATUS from runtime");
     skypeRef.transport.SubmitPropertyRequest(18, 927, this.OID);
     if (skypeRef.transport.PropResponseWasOk(927))
     {
     cache_local_livestatus = (SktConversation.LOCAL_LIVESTATUS)skypeRef.decoder.DecodeUint();
     cache[9] = true;
     }
     skypeRef.transport.ResumeSocketReaderFromPropRequest();
 }
 public OnConversationLocalLivestatusArgs(SktConversation sender, SktConversation.LOCAL_LIVESTATUS newValue)
 {
     this.sender = sender;  value = newValue;
 }