Exemplo n.º 1
0
/*!
 * \brief Call this function to initialize the UPnP library and start the TV
 * Control Point.  This function creates a timer thread and provides a
 * callback handler to process any UPnP events that are received.
 *
 * \return TV_SUCCESS if everything went well, else TV_ERROR.
 */
int TvCtrlPointStart(print_string printFunctionPtr, state_update updateFunctionPtr, int combo)
{
	ithread_t timer_thread;
	int rc;
	unsigned short port = 0;
	char *ip_address = NULL;

	SampleUtil_Initialize(printFunctionPtr);
	SampleUtil_RegisterUpdateFunction(updateFunctionPtr);

	ithread_mutex_init(&DeviceListMutex, 0);

	SampleUtil_Print("Initializing UPnP Sdk with\n"
			 "\tipaddress = %s port = %u\n",
			 ip_address ? ip_address : "{NULL}", port);

	rc = UpnpInit(ip_address, port);
	if (rc != UPNP_E_SUCCESS) {
		SampleUtil_Print("WinCEStart: UpnpInit() Error: %d\n", rc);
		if (!combo) {
			UpnpFinish();

			return TV_ERROR;
		}
	}
	if (!ip_address) {
		ip_address = UpnpGetServerIpAddress();
	}
	if (!port) {
		port = UpnpGetServerPort();
	}

	SampleUtil_Print("UPnP Initialized\n"
			 "\tipaddress = %s port = %u\n",
			 ip_address ? ip_address : "{NULL}", port);
	SampleUtil_Print("Registering Control Point\n");
	rc = UpnpRegisterClient(TvCtrlPointCallbackEventHandler,
				&ctrlpt_handle, &ctrlpt_handle);
	if (rc != UPNP_E_SUCCESS) {
		SampleUtil_Print("Error registering CP: %d\n", rc);
		UpnpFinish();

		return TV_ERROR;
	}

	SampleUtil_Print("Control Point Registered\n");

	TvCtrlPointRefresh();

	/* start a timer thread */
	ithread_create(&timer_thread, NULL, TvCtrlPointTimerLoop, NULL);
	ithread_detach(timer_thread);

	return TV_SUCCESS;
}
Exemplo n.º 2
0
/****************************************************************************
 * Function: CreateWorker
 *
 *  Description:
 *      Creates a worker thread, if the thread pool
 *      does not already have max threads.
 *      Internal to thread pool.
 *  Parameters:
 *      ThreadPool *tp
 *
 *  Returns:
 *      0 on success, <0 on failure
 *      EMAXTHREADS if already max threads reached
 *      EAGAIN if system can not create thread
 *
 *****************************************************************************/
static int CreateWorker( ThreadPool *tp )
{
	//printf("%s, %d\n", __FUNCTION__, __LINE__);

	ithread_t temp;
	int rc = 1;
	int currentThreads = tp->totalThreads + 1;
	//printf("%s, %d\n", __FUNCTION__, __LINE__);

	assert( tp != NULL );

	if ( tp->attr.maxThreads != INFINITE_THREADS &&
	     currentThreads > tp->attr.maxThreads ) {
		return EMAXTHREADS;
	}
	//printf("%s, %d\n", __FUNCTION__, __LINE__);

	//rc = ithread_create( &temp, NULL, WorkerThread, tp );

	rc = pthread_create( &temp, NULL, WorkerThread, tp );
	//printf("%s, %d, %d\n", __FUNCTION__, __LINE__, rc);
	//pthread_join(temp, NULL);
	
	//printf("%s, %d\n", __FUNCTION__, __LINE__);
	if( rc == 0 ) {
		rc = ithread_detach( temp );
		//printf("%s, %d, totalThreads: %d, currentThreads: %d\n", __FUNCTION__, __LINE__, tp->totalThreads, currentThreads);
		while( tp->totalThreads < currentThreads ) {
			//printf("%s, %d\n", __FUNCTION__, __LINE__, tp->totalThreads, currentThreads);
			ithread_cond_wait( &tp->start_and_shutdown, &tp->mutex );
		}
	}
	//printf("%s, %d\n", __FUNCTION__, __LINE__);

	if( tp->stats.maxThreads < tp->totalThreads ) {
		tp->stats.maxThreads = tp->totalThreads;
	}
	//printf("%s, %d\n", __FUNCTION__, __LINE__);

	return rc;
}
Exemplo n.º 3
0
/*!
 * \brief Creates a worker thread, if the thread pool does not already have
 * max threads.
 *
 * \remark The ThreadPool object mutex must be locked prior to calling this
 * function.
 *
 * \internal
 *
 * \return
 *	\li \c 0 on success, < 0 on failure.
 *	\li \c EMAXTHREADS if already max threads reached.
 *	\li \c EAGAIN if system can not create thread.
 */
static int CreateWorker(
	/*! A pointer to the ThreadPool object. */
	ThreadPool *tp)
{
	ithread_t temp;
	int rc = 0;
	ithread_attr_t attr;

	/* if a new worker is the process of starting, wait until it fully starts */
	while (tp->pendingWorkerThreadStart) {
		ithread_cond_wait(&tp->start_and_shutdown, &tp->mutex);
	}

	if (tp->attr.maxThreads != INFINITE_THREADS &&
	    tp->totalThreads + 1 > tp->attr.maxThreads) {
		return EMAXTHREADS;
	}
	ithread_attr_init(&attr);
	ithread_attr_setstacksize(&attr, tp->attr.stackSize);
	ithread_attr_setdetachstate(&attr, ITHREAD_CREATE_DETACHED);
	rc = ithread_create(&temp, &attr, WorkerThread, tp);
	ithread_attr_destroy(&attr);
	if (rc == 0) {
		rc = ithread_detach(temp);
		/* ithread_detach will return EINVAL if thread has been
		 successfully detached by ithread_create */
		if (rc == EINVAL)
			rc = 0;
		tp->pendingWorkerThreadStart = 1;
		/* wait until the new worker thread starts */
		while (tp->pendingWorkerThreadStart) {
			ithread_cond_wait(&tp->start_and_shutdown, &tp->mutex);
		}
	}
	if (tp->stats.maxThreads < tp->totalThreads) {
		tp->stats.maxThreads = tp->totalThreads;
	}

	return rc;
}