rvh323timer.c

基于h323协议的软phone

        SetWindowLong(hWnd, GWL_USERDATA, (LONG)nextTimeout);
#endif
        return RV_OK;
    }

    RvMemoryFree(nextTimeout);
    return RV_ERROR_UNKNOWN;
}


/************************************************************************
 * h323TimerCreateWindow
 * purpose : Create the timers window that we're going to use
 * input   : none
 * output  : none
 * return  : none
 ************************************************************************/
static void h323TimerCreateWindow(void)
{
    ThreadInstanceInitObject(RV_THREAD_INSTANCE_TIMERS_HWND, CreateTimersHWND, NULL, 0,
        NULL, NULL, &RvH323TimersHWNDIndex);
}


/************************************************************************
 * h323TimerCloseWindow
 * purpose : Close the timers window before exiting
 * input   : none
 * output  : none
 * return  : none
 ************************************************************************/
static void h323TimerCloseWindow(void)
{
    ThreadInstanceEndObject(RvH323TimersHWNDIndex, 0, NULL);
}



#else

/* Non WIN32: We just define these functions as empty */
#define h323TimerCreateWindow()
#define h323TimerCloseWindow()
#define h323TimerResetTimeout(_timers)

#endif  /* (RV_OS_TYPE == RV_OS_TYPE_WIN32) */








/************************************************************************
 * RvH323TimerConstruct
 * purpose: Create a timers array.
 * input  : maxTimers   - Maximum number of timers needed
 * output : timersQueue - Queue of timers these timers are in
 * return : pointer to timers handle on success, NULL o.w.
 ************************************************************************/
RVAPI RvH323TimerPoolHandle RVCALLCONV RvH323TimerConstruct(
    IN    int               maxTimers,
    OUT   RvTimerQueue**    timersQueue)
{
    RvStatus status;
    RvH323Timers * timers = NULL;
    RvTimerQueue* timerQ;

    status = ThreadInstanceInitObject(RV_THREAD_INSTANCE_TIMERS, ThreadCreateTimersQueue, NULL, maxTimers,
        (void**)&timerQ, NULL, &RvH323TimersIndex);
    if (status != RV_OK)
        return NULL;

    if (RvH323TimersInitialized == 0)
    {
        /* First time this function is called - allocate some more objects */
        RvLogSourceConstruct(RvLogGet(), &RvH323TimersLog, RV_LOG_LIBCODE_H323, "TIMEPOOL", "Timers pool");
    }

    /* Create a window for this thread */
    h323TimerCreateWindow();

    /* Allocate the RA that will holds these timers */
    if (RvMemoryAlloc(NULL, (void**)&timers, sizeof(RvH323Timers)) != RV_OK)
    {
        ThreadInstanceEndObject(RvH323TimersIndex, maxTimers, NULL);
        return NULL;
    }

    timers->timerQ = timerQ;
    timers->array = raConstruct(sizeof(RvTimer), maxTimers, RV_TRUE, "Timer Array");
    timers->threadInfo = RvThreadCurrent();
#if (RV_OS_TYPE == RV_OS_TYPE_WIN32)
    ThreadInstanceGetObject(RvH323TimersHWNDIndex, (void**)&timers->hWnd);
#endif
    if (timers->array == NULL)
    {
        ThreadInstanceEndObject(RvH323TimersIndex, maxTimers, NULL);
        RvMemoryFree(timers);
        return NULL;
    }

    RvH323TimersInitialized++;

    if (timersQueue != NULL)
        *timersQueue = timerQ;

    return (RvH323TimerPoolHandle)timers;
}


/************************************************************************
 * RvH323TimerDestruct
 * purpose: Create a timers array.
 * input  : timers          - pointer to timers array
 * output : none
 * return : none
 ************************************************************************/
RVAPI void RVCALLCONV RvH323TimerDestruct(
    IN RvH323TimerPoolHandle    timersH)
{
    RvH323Timers * timers = (RvH323Timers *) timersH;
    RvSize_t numTimers = 0;
    if (timers == NULL)
        return;


    if(timers->array != NULL)
    {
        numTimers = (RvSize_t)raMaxSize(timers->array);
        raDestruct(timers->array);
    }
    RvMemoryFree(timers);

    ThreadInstanceEndObject(RvH323TimersIndex, numTimers, NULL);
    h323TimerCloseWindow();

    RvH323TimersInitialized--;
    if (RvH323TimersInitialized == 0)
    {
        RvLogSourceDestruct(RvLogGet(), &RvH323TimersLog);
    }
}


/************************************************************************
 * RvH323TimerStartWithType
 * purpose: Set a timer of the stack.
 * input  : timers          - pointer to timers array
 *          eventHandler    - Callback to call when timer expires
 *          context         - Context to use as parameter for callback function
 *          timeOut         - Timeout of timer in nanoseconds (0 is not ignored)
 *          timerType       - Type of timer: RV_TIMER_TYPE_ONESHOT, RV_TIMER_TYPE_PERIODIC
 * output : None
 * return : Pointer to timer on success, NULL o.w.
 ************************************************************************/
RVAPI RvTimer* RVCALLCONV RvH323TimerStartWithType(
    IN    RvH323TimerPoolHandle timersH,
    IN    RvTimerFunc           eventHandler,
    IN    void*                 context,
    IN    RvInt64               timeOut,
    IN    RvInt                 timerType)
{
    RvH323Timers* timers = (RvH323Timers *) timersH;
    RvTimer* timer = NULL;
    int loc;
    static void* myContext1 = NULL;

#if defined(RV_NULLCHECK)
    if (timers == NULL)
        return NULL;
#endif

/* Convert a signed 64 bit number to string. The buf parameter */
/* should be at least 22 bytes or an overrun can occur. */
#if (RV_LOGMASK_COMPILEMASK & RV_LOGLEVEL_ENTER)
    if (RvLogIsSelected(&RvH323TimersLog, RV_LOGLEVEL_ENTER))
    {
        RvChar timeoutBuf[22];
        Rv64toA(timeoutBuf, timeOut);
        RvLogTextEnter(&RvH323TimersLog,
            "RvH323TimerStartWithType(tH=0x%p,eventHander=0x%p,context=0x%p,timeOut=%s,type=%d)",
            timersH, eventHandler, context, timeoutBuf, timerType);
    }
#endif

    /* Allocate a timer object */
    loc = raAdd(timers->array, (RAElement*)&timer);

    if (loc < 0)
        timer = NULL;
    else
    {
        RvStatus res;

        /* Start the timer */
        res = RvTimerStart(timer, timers->timerQ, timerType, timeOut, eventHandler, (void *)context);
        if (res == RV_OK)
        {
            h323TimerResetTimeout(timers);
        }
        else
        {
            RvLogError(&RvH323TimersLog, (&RvH323TimersLog,
                "Cannot start a timer (timer=0x%p, result=%d)", timer, res));
            raDelete(timers->array, (RAElement)timer);
            timer = NULL;
        }
    }

    RvLogLeave(&RvH323TimersLog, (&RvH323TimersLog,
        "RvH323TimerStartWithType(tH=0x%p,eventHander=0x%p,context=0x%p)=0x%p",
        timersH, eventHandler, context, timer));

    return timer;
}


/************************************************************************
 * RvH323TimerCancel
 * purpose: Reset a timer if it's set
 *          Used mainly for call timers.
 * input  : timer   - Timer to reset
 * output : timer   - Timer's value after it's reset
 * return : RV_OK on success, other on failure
 ************************************************************************/
RVAPI RvStatus RVCALLCONV RvH323TimerCancel(
    IN    RvH323TimerPoolHandle timersH,
    INOUT RvTimer               **timer)
{
    RvH323Timers * timers = (RvH323Timers *) timersH;
    RvStatus ret = RV_OK;

    if(timers == NULL)
        return RV_ERROR_UNKNOWN;

    if (*timer != NULL)
    {
        RvLogEnter(&RvH323TimersLog, (&RvH323TimersLog,
            "RvH323TimerCancel(tH=0x%p,timer=0x%p)", timersH, *timer));

        ret = RvTimerCancel(*timer, RV_TRUE);
        if (ret!= RV_OK)
        {
            RvLogError(&RvH323TimersLog, (&RvH323TimersLog,
                "Error canceling timer(timer=0x%p)=%d", *timer, ret));
        }

        ret = raDelete(timers->array, (RAElement)*timer);

        RvLogLeave(&RvH323TimersLog, (&RvH323TimersLog,
            "RvH323TimerCancel(tH=0x%p,timer=0x%p)=%d", timersH, *timer, ret));

        if (ret > 0)
            ret = RV_OK;

        *timer = NULL;
    }

    return ret;
}


/************************************************************************
 * RvH323TimerClear
 * purpose: Clear a timer from the array
 * input  : timers  - pointer to timers array
 *          timer   - Timer to reset
 * output : none
 * return : RV_OK on success, other on failure
 ************************************************************************/
RVAPI RvStatus RVCALLCONV RvH323TimerClear(
    IN    RvH323TimerPoolHandle timersH,
    IN    RvTimer               **timer)
{
    RvH323Timers * timers = (RvH323Timers *) timersH;
    RvStatus ret = RV_OK;

    if (timers == NULL)
        return RV_ERROR_UNKNOWN;

    if (*timer != NULL)
    {
        RvLogEnter(&RvH323TimersLog, (&RvH323TimersLog, "RvH323TimerClear(tH=0x%p,timer=0x%p)",
            timersH, *timer));

        ret = raDelete(timers->array, (RAElement)*timer);

        RvLogLeave(&RvH323TimersLog, (&RvH323TimersLog, "RvH323TimerClear(tH=0x%p,timer=0x%p)",
            timersH, *timer));

        if (ret > 0)
            ret = RV_OK;

        *timer = NULL;
    }

    return ret;
}


/************************************************************************
 * RvH323TimerStatistics
 * purpose: Get timer pool statistics
 * input  : timers      - pointer to timers array
 * output : statistics  - Statistics information about the timer pool
 * return : RV_OK on success, other on failure
 ************************************************************************/
RVAPI RvStatus RVCALLCONV RvH323TimerStatistics(
    IN    RvH323TimerPoolHandle timersH,
    OUT   RvRaStatistics*       statistics)
{
    RvH323Timers * timers = (RvH323Timers *) timersH;
    RvStatus ret;

    ret = raGetStatistics(timers->array, statistics);
    if (ret > 0)
        ret = RV_OK;

    return ret;
}



#ifdef __cplusplus
}
#endif