chvapi.cpp.old

Windows上的MUD客户端程序

				case TNT_SESSION_INCOMING_CALL:
				{
					TNT_RETCODE				retCode;
					unsigned long			dwResponse;
					TNT_SESSION_HANDLE		hSession;

					TRACE( "TNT: Incoming call.\n" );

					hSession = pSessionInfo->hSession;

					if (m_tntSessions.AllSessionsInUse())
					{
						dwResponse = TNT_SESSION_RESPONSE_BUSY;
					}
					else
					{
						dwResponse = TNT_SESSION_RESPONSE_ACCEPT;
					}

					retCode = tntSessionResponse( hTNT, 0, 0, hSession,
													dwResponse );
					if (TNT_NO_ERROR != retCode)
					{
						#if defined( CH_DEBUG )
						{
							sprintf( cBuffer,
										"TNT: Error calling "
										"tntSessionResponse (%hu)\n",
										retCode );
							TRACE( cBuffer );
						}
						#endif	// defined( CH_DEBUG )
					}
					break;
				}

				case TNT_SESSION_HANGUP:
				{
											// Clear the active session handle

					m_tntSessions.ClearSessionHdl( pSessionInfo->hSession );

					TRACE( "TNT: Hung up!\n" );
					break;
				}

				case TNT_SESSION_XMIT:
				{
					return TNT_NO_ERROR;
				}

				case TNT_SESSION_RECV:
				{
					return TNT_NO_ERROR;
				}

				case TNT_SESSION_UNKNOWN_STATUS:
				{
					break;
				}

				default:
				{
					#if defined( CH_DEBUG )
					{
						//wsprintf(cBuffer, "Unknown response from remote user (%ld).", dwParam1);
						//SendMessage(GetDlgItem(hNotifyDlg, IDC_NOTIFY_LIST), LB_INSERTSTRING, (WPARAM)-1, (long)cBuffer);
					}
					#endif	// defined( CH_DEBUG )
					break;
				}
			}
			break;
		}	

		case TNT_NOTIFY_SOUND_ENGINE_MODE:
		{
			switch( dwParam1 )
			{
				case TNT_SOUND_ENGINE_LISTEN_MODE:
				{
					break;
				}

				case TNT_SOUND_ENGINE_TALK_MODE:
				{
					break;
				}
			}
			break;
		}

		case TNT_NOTIFY_SESSION_RESPONSE:
		{
			if (TNT_SESSION_RESPONSE_ACCEPT == dwParam2)
			{
				#if defined( CH_DEBUG )
				{
											// Call accepted!

					strcpy( cBuffer, "TNT: Call has been accepted." );
				}
				#endif	// defined( CH_DEBUG )
			}
			else
			{
				switch (dwParam2)
				{
					case TNT_SESSION_RESPONSE_REJECT:
					{
						#if defined( CH_DEBUG )
						{
							strcpy( cBuffer, "TNT: Call has not been accepted." );
						}
						#endif	// defined( CH_DEBUG )
						break;
					}

					case TNT_SESSION_RESPONSE_BUSY:
					{
						#if defined( CH_DEBUG )
						{
							strcpy( cBuffer, "TNT: Caller is busy." );
						}
						#endif	// defined( CH_DEBUG )
						break;
					}

					case TNT_SESSION_RESPONSE_NOANSWER:
					{
						#if defined( CH_DEBUG )
						{
							strcpy( cBuffer, "TNT: Caller did not answer." );
						}
						#endif	// defined( CH_DEBUG )
						break;
					}

					case TNT_SESSION_RESPONSE_BLOCK:
					{
						#if defined( CH_DEBUG )
						{
							strcpy( cBuffer, "TNT: Caller is blocking calls." );
						}
						#endif	// defined( CH_DEBUG )
						break;
					}

					case TNT_SESSION_RESPONSE_VOICEMAIL:
					{
						#if defined( CH_DEBUG )
						{
							strcpy( cBuffer, "TNT: Speech mail system." );
						}
						#endif	// defined( CH_DEBUG )
						break;
					}

					default:
					{
						#if defined( CH_DEBUG )
						{
							strcpy( cBuffer, "TNT: UNKNOWN CALL RESPONSE\n" );
						}
						#endif	// defined( CH_DEBUG )
						break;
					}
				}
			}

			#if defined( CH_DEBUG )
			{
				TRACE( cBuffer );
			}
			#endif	// defined( CH_DEBUG )
			break;
		}

		#if defined( CH_DEBUG )

		case TNT_NOTIFY_DEBUG_MESSAGE:
		{
			char*	pstrError = (char*)dwParam2;

			TRACE( pstrError );
			TRACE( "\n" );
			break;
		}

		#endif	// defined( CH_DEBUG )

		default:
		{
			#if defined( CH_DEBUG )
			{
				sprintf( cBuffer, "TNT: Unknown notification message (%ld).",
									wMessage );
				TRACE( cBuffer );
			}
			#endif	// defined( CH_DEBUG )
			break;
		}
	}

	return TNT_NO_ERROR;
}


/*----------------------------------------------------------------------------
	ChTNTSessionMgr public methods
----------------------------------------------------------------------------*/

ChTNTSessionMgr::ChTNTSessionMgr() :
						m_iSessions( 0 )
{
	for (int iLoop = 0; iLoop < SESSION_LIMIT; iLoop++)
	{
		SetInUse( iLoop, false );
	}
}


ChTNTSessionMgr::~ChTNTSessionMgr()
{
}


bool ChTNTSessionMgr::Set( const string& strCallId,
							TNT_SESSION_HANDLE hSession,
							chflag32 flOptions )
{
	bool			boolSuccess = false;
	ChTNTSession*	pFoundSession = 0;
	int				iLoc;

	if (0 == (pFoundSession = Find( strCallId, &iLoc )))
	{
		if (SESSION_LIMIT > GetSessionCount())
		{
			iLoc = 0;

			while ((0 == pFoundSession) && (iLoc < SESSION_LIMIT))
			{
				if (!IsInUse( iLoc ))
				{
					pFoundSession = GetSession( iLoc );
				}
				else
				{
					iLoc++;
				}
			}
		}
	}

	if (pFoundSession)
	{
		SetInUse( iLoc );

		pFoundSession->Set( hSession, strCallId, flOptions );

		boolSuccess = true;
	}

	return boolSuccess;
}


TNT_SESSION_HANDLE ChTNTSessionMgr::
						GetSessionHandle( const string& strCallId,
											chflag32* pflOptions )
{
	TNT_SESSION_HANDLE		hSession = 0;
	ChTNTSession*			pSession;

	if (pSession = Find( strCallId ))
	{
		hSession = pSession->GetSessionHdl();

		if (pflOptions)
		{
			*pflOptions = pSession->GetOptions();
		}
	}

	return hSession;
}


bool ChTNTSessionMgr::Hangup( TNT_HANDLE hTNT, const string& strCallId )
{
	TNT_SESSION_HANDLE		hSession = 0;
	bool					boolSuccess = true;

	if (!strCallId.IsEmpty())
	{										// Look up the session by call id

		hSession = GetSessionHandle( strCallId );
	}

	if (hSession)
	{
		boolSuccess = Hangup( hTNT, hSession );
	}
	else
	{
		for (int iLoop = 0; iLoop < SESSION_LIMIT; iLoop++)
		{
			if (IsInUse( iLoop ))
			{
				boolSuccess = boolSuccess &&
								Hangup( hTNT,
										GetSession( iLoop )->GetSessionHdl() );
			}
		}
	}

	return boolSuccess;
}


bool ChTNTSessionMgr::ClearSession( const string& strCallId )
{
	int		iLoc;
	bool	boolFound;

	if (boolFound = (0 != Find( strCallId, &iLoc )))
	{
		SetInUse( iLoc, false );
	}

	return boolFound;
}


bool ChTNTSessionMgr::ClearSessionHdl( TNT_SESSION_HANDLE hSession )
{
	bool		boolFound = false;
	int			iLoop;

	for (iLoop = 0; iLoop < SESSION_LIMIT; iLoop++)
	{
		if (IsInUse( iLoop ) &&
			(GetSession( iLoop )->GetSessionHdl() == hSession))
		{
			SetInUse( iLoop, false );

			boolFound = true;
		}
	}

	return boolFound;
}


/*----------------------------------------------------------------------------
	ChTNTSessionMgr protected methods
----------------------------------------------------------------------------*/

ChTNTSession* ChTNTSessionMgr::Find( const string& strCallId, int* piLoc )
{
	ChTNTSession*	pFoundSession = 0;

	if (0 != GetSessionCount())
	{
		int		iLoop = 0;

		while ((0 == pFoundSession) && (iLoop < SESSION_LIMIT))
		{
			if (IsInUse( iLoop ))
			{
				if (GetSession( iLoop )->GetId() == strCallId)
				{
					pFoundSession = GetSession( iLoop );

					if (piLoc)
					{
						*piLoc = iLoop;
					}
				}
			}

			iLoop++;
		}
	}

	return pFoundSession;
}


ChTNTSession* ChTNTSessionMgr::Find( TNT_SESSION_HANDLE hSession,
										int* piLoc )
{
	ChTNTSession*	pFoundSession = 0;

	if (0 != GetSessionCount())
	{
		int		iLoop = 0;

		while ((0 == pFoundSession) && (iLoop < SESSION_LIMIT))
		{
			if (IsInUse( iLoop ))
			{
				if (GetSession( iLoop )->GetSessionHdl() == hSession)
				{
					pFoundSession = GetSession( iLoop );

					if (piLoc)
					{
						*piLoc = iLoop;
					}
				}
			}

			iLoop++;
		}
	}

	return pFoundSession;
}


bool ChTNTSessionMgr::Hangup( TNT_HANDLE hTNT, TNT_SESSION_HANDLE hSession )
{
	TNT_RETCODE			retCode;
	TNT_TRANSACTION_HANDLE	hTransaction;
	bool					boolSuccess = true;

	retCode = tntSessionHangup( hTNT, &hTransaction, 0, hSession );
	if (TNT_NO_ERROR != retCode)
	{
		#if defined( CH_DEBUG )
		{
			char		cBuffer[160];

			sprintf( cBuffer, "TNT: Error calling tntHangupSession (%hu)\n",
								retCode );
			TRACE( cBuffer );
		}
		#endif	// defined( CH_DEBUG )

		boolSuccess = false;
	}

	return boolSuccess;
}


/*----------------------------------------------------------------------------
	ChTNTSession public methods
----------------------------------------------------------------------------*/

ChTNTSession::ChTNTSession()
{
}


ChTNTSession::~ChTNTSession()
{
}


#endif	// defined( CH_USE_VOXWARE )


// Local Variables: ***
// tab-width:4 ***
// End: ***