Ejemplo n.º 1
0
        /// <summary>
        /// Cslled to send refresh events to client.
        /// </summary>
        private void DoRefresh(object state)
        {
            try
            {
                // check if disposed.
                if (m_disposed)
                {
                    return;
                }

                // send a dummy callback after a cancel.
                if (state == null)
                {
                    IComAeEventCallback callback = m_callback;

                    if (callback != null)
                    {
                        callback.OnEvent(
                            ClientHandle,
                            true,
                            true,
                            null);
                    }

                    return;
                }

                Queue <AeEvent> eventsToSend = null;

                lock (m_lock)
                {
                    // check if refresh has been cancelled.
                    if (!Object.ReferenceEquals(state, m_refreshQueue))
                    {
                        return;
                    }

                    // clear the queue to indicate operation is complete.
                    eventsToSend   = m_refreshQueue;
                    m_refreshQueue = null;
                }

                // send the events to client.
                SendInBlocks(m_callback, eventsToSend, MaxSize, true);
            }
            catch (Exception exception)
            {
                Utils.Trace(exception, "Error processing refresh callback.");
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Sets the callback.
        /// </summary>
        /// <param name="callback">The callback.</param>
        public void SetCallback(IComAeEventCallback callback)
        {
            ThrowIfDisposed();

            lock (m_lock)
            {
                if (m_callback != null)
                {
                    m_callback.Dispose();
                    m_callback = null;
                }

                m_callback = callback;
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Sends the queued events in blocks.
        /// </summary>
        private void SendInBlocks(IComAeEventCallback callback, Queue <AeEvent> events, uint blockSize, bool refreshFlag)
        {
            if (callback == null)
            {
                return;
            }

            if (blockSize == 0)
            {
                blockSize = (uint)events.Count;
            }

            while (events.Count > 0)
            {
                List <ONEVENTSTRUCT> eventsInBlock = new List <ONEVENTSTRUCT>();

                try
                {
                    for (int ii = 0; ii < blockSize && events.Count > 0; ii++)
                    {
                        // warning - Translate() allocates unmanaged memory that is deleted in the finally block.
                        eventsInBlock.Add(Translate(events.Dequeue()));
                    }

                    // invoke callback.
                    callback.OnEvent(
                        ClientHandle,
                        refreshFlag,
                        (refreshFlag)?events.Count == 0:false,
                        eventsInBlock.ToArray());
                }
                finally
                {
                    // must deallocate attributes on exit.
                    for (int ii = 0; ii < eventsInBlock.Count; ii++)
                    {
                        IntPtr pAttributes = eventsInBlock[ii].pEventAttributes;
                        ComUtils.GetVARIANTs(ref pAttributes, eventsInBlock[ii].dwNumEventAttrs, true);
                    }
                }
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Sends the queued events in blocks.
        /// </summary>
        private void SendInBlocks(IComAeEventCallback callback, Queue<AeEvent> events, uint blockSize, bool refreshFlag)
        {
            if (callback == null)
            {
                return;
            }

            if (blockSize == 0)
            {
                blockSize = (uint)events.Count;
            }

            while (events.Count > 0)
            {
                List<ONEVENTSTRUCT> eventsInBlock = new List<ONEVENTSTRUCT>();

                try
                {
                    for (int ii = 0; ii < blockSize && events.Count > 0; ii++)
                    {
                        // warning - Translate() allocates unmanaged memory that is deleted in the finally block.
                        eventsInBlock.Add(Translate(events.Dequeue()));
                    }

                    // invoke callback.
                    callback.OnEvent(
                        ClientHandle,
                        refreshFlag,
                        (refreshFlag)?events.Count == 0:false,
                        eventsInBlock.ToArray());
                }
                finally
                {
                    // must deallocate attributes on exit.
                    for (int ii = 0; ii < eventsInBlock.Count; ii++)
                    {
                        IntPtr pAttributes = eventsInBlock[ii].pEventAttributes;
                        ComUtils.GetVARIANTs(ref pAttributes, eventsInBlock[ii].dwNumEventAttrs, true);
                    }
                }
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Sets the callback.
        /// </summary>
        /// <param name="callback">The callback.</param>
        public void SetCallback(IComAeEventCallback callback)
        {
            ThrowIfDisposed();

            lock (m_lock)
            {
                if (m_callback != null)
                {
                    m_callback.Dispose();
                    m_callback = null;
                }

                m_callback = callback;
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Called send events to client.
        /// </summary>
        private void DoProcessQueue(object state)
        {
            Queue <AeEvent> events = new Queue <AeEvent>();

            try
            {
                // check if disposed.
                if (m_disposed)
                {
                    return;
                }

                // process the queue.
                lock (m_queue)
                {
                    while (m_queue.Count > 0)
                    {
                        events.Enqueue(m_queue.Dequeue());
                    }
                }

                // check if time for a keep alive.
                lock (m_lock)
                {
                    // check if time for keep alive.
                    if (events.Count == 0)
                    {
                        if (KeepAlive == 0 || m_lastUpdateTime.AddMilliseconds(KeepAlive * m_keepAliveCount) > DateTime.UtcNow)
                        {
                            return;
                        }
                    }

                    // no keep alives if not active.
                    if (!Active)
                    {
                        return;
                    }

                    // update counters.
                    if (events.Count > 0)
                    {
                        m_lastUpdateTime = DateTime.UtcNow;
                        m_keepAliveCount = 1;
                    }
                    else
                    {
                        m_keepAliveCount++;
                    }
                }

                // send a keep alive callback.
                if (events.Count == 0)
                {
                    IComAeEventCallback callback = m_callback;

                    if (callback != null)
                    {
                        callback.OnEvent(
                            ClientHandle,
                            false,
                            false,
                            null);
                    }

                    return;
                }

                // send the events to client.
                SendInBlocks(m_callback, events, MaxSize, false);
            }
            catch (Exception exception)
            {
                Utils.Trace(exception, "Error processing event callback.");
            }
        }