Пример #1
0
// -----------------------------------------------------------------------------
// CSIPExSIPIdleState::SendInviteL()
// Create and send an INVITE request to the recipient.
// -----------------------------------------------------------------------------
void CSIPExSIPIdleState::SendInviteL( 
    CSIPExSIPEngine& aEngine,
	const TDesC8& aSipUri )
	{
	// Retrieve the active profile and connection
	CSIPProfile& prof = aEngine.Profile();
	CSIPConnection& conn = aEngine.ConnectionL();

    // Create CUri8 from passed descriptor
    CUri8* uri8 = aEngine.ConvertToUri8LC( aSipUri );
    
	// Get dialog association, save for future use
	// The ownership of uri8 is transferred
	CSIPInviteDialogAssoc* dialogAssoc =
		CSIPInviteDialogAssoc::NewL( conn, uri8, prof );
	CleanupStack::Pop( uri8 );	
		
	aEngine.SetDialogAssoc( *dialogAssoc ); //Ownership is transferred!!

	// Create the necessary message elements
	CSIPMessageElements* msgElements = aEngine.CreateMessageElementsLC();

	// Send the INVITE in the dialog
	// The ownership of msgElements is transferred
	CSIPClientTransaction* tx = dialogAssoc->SendInviteL( msgElements );
	CleanupStack::Pop( msgElements );

	// Save the pointer to the transaction to the Engine
	aEngine.SetClientTx( tx );

	// Change machine state
	aEngine.SetCurrentState( iClientEstablishingState );
	}
/**
 * INPUT:
 *   Headers:		To*, From*, Contact*
 *   Parameters:	RemoteURI
 *   IDs:			ProfileId, RegistryId
 *
 * OUTPUT:
 *   Parameters:	-
 *   IDs:			TransactionId, InviteDialogId
 */
void TCmdSendInviteUsingProfile::ExecuteL()
	{
	// -- Setup ---------------------------------------------------------------

	// Extract required headers (From may be either mandatory or optional)
	CSIPToHeader* toHeader = ExtractToHeaderLC( EFalse );
	CSIPFromHeader* fromHeader = ExtractFromHeaderLC( EFalse );
    CSIPContactHeader* contactHeader = ExtractContactHeaderLC( EFalse );

	// Extract remote URI
	CUri8* uri = ExtractRemoteURILC( ETrue );

    // Get selected registry
    CTcSIPProfileContainer& container = SelectProfileL();

	// Get profile from the profile registry
	CSIPProfile& profile = GetProfileL( container );

	CSIPConnection* sipConnection = container.ProfileRegistry().ConnectionL( profile );
	
	// Ownership is not really transferred if SIPTester has opened already 
	// CSIPConnection for same IAP as profile is using!!
	if ( sipConnection != &(iContext.Connection().Connection()) )
		{
		// Have to store because needs longer lifetime than just current ExecuteL
		iContext.Registry().AddObjectL( sipConnection );	
		}		

    CSIPInviteDialogAssoc* inviteDialogAssoc = 
        CSIPInviteDialogAssoc::NewL( *sipConnection,
                                     uri,
                                     profile,
                                     fromHeader,
                                     toHeader,
                                     contactHeader );
                                                                    
    CleanupStack::Pop( iPushed ); // toHeader; fromheader, uri
    iPushed = 0;

    CleanupStack::PushL( inviteDialogAssoc );
    
    // Extract rest of headers (if provided)
    CSIPMessageElements* elements = ExtractHeadersAndContentLC();
    
     // -- Execution -----------------------------------------------------------
     
    // Start SIP Invite transaction.
	CSIPClientTransaction* transaction = inviteDialogAssoc->SendInviteL( elements );
    CleanupStack::Pop( elements );

	// -- Response creation ---------------------------------------------------

    AddIdResponseL( KTransactionId, transaction );
	AddIdResponseL( KInviteDialogId, inviteDialogAssoc );

    CleanupStack::Pop( inviteDialogAssoc );
	}
/**
 * INPUT:
 *   Headers:		Contact*, Content-Type*, Content-Encoding*, Route*
 *   Parameters:	Content*
 *   IDs:			InviteDialogId*, SubscribeDialogId*
 *
 * OUTPUT:
 *   Parameters:	-
 *   IDs:			TransactionId, InviteDialogId
 */
void TCmdSendInviteWithinDriver::ExecuteL()
{
    // -- Setup ---------------------------------------------------------------

    // Get SIP objects from registry
    CSIPSubscribeDialogAssoc* subscribeDialogAssoc =
        GetSubscribeDialogAssocL( EFalse );

    // If there was a SubscribeDialogId, use it to create a new InviteDialogAssoc
    // If not, try to use a InviteDialogId for an existing InviteDialogAssoc
    CSIPInviteDialogAssoc* inviteDialogAssocOrg;
    CSIPInviteDialogAssoc* inviteDialogAssoc;
    if( subscribeDialogAssoc )
    {
        // Create a new dialog association
        inviteDialogAssoc =
            CSIPInviteDialogAssoc::NewLC( subscribeDialogAssoc->Dialog() );
    }
    else
    {
        // Get invitedialog
        inviteDialogAssocOrg = GetInviteDialogAssocL();
        // Create a new dialog association
        inviteDialogAssoc =
            CSIPInviteDialogAssoc::NewLC( inviteDialogAssocOrg->Dialog() );
    }

    // Extract both headers (that are still left) and content.
    CSIPMessageElements* elements = ExtractHeadersAndContentLC();

    // -- Execution -----------------------------------------------------------

    // Start SIP Invite transaction.
    CSIPClientTransaction* transaction = inviteDialogAssoc->SendInviteL( elements );
    CleanupStack::Pop( elements );

    // -- Response creation ---------------------------------------------------

    AddIdResponseL( KTransactionId, transaction );
    // If subscribeDialogAssoc is valid, inviteDialogAssoc ptr is in CleanupStack
    if( subscribeDialogAssoc )
    {
        CleanupStack::Pop( inviteDialogAssoc );
    }
    AddIdResponseL( KInviteDialogId, inviteDialogAssoc );
}
Пример #4
0
/**
 * INPUT:
 *   Headers:		Contact*, Content-Type*, Content-Encoding*,
 *					Event*, Expires*
 *   Parameters:	Content*
 *   IDs:			InviteDialogId
 *
 * OUTPUT:
 *   Parameters:	-
 *   IDs:			TransactionId
 */
void TCmdUpdateInvite::ExecuteL()
	{
	// -- Setup ---------------------------------------------------------------

	// Get SIP objects from registry
	CSIPInviteDialogAssoc* dialogAssoc = GetInviteDialogAssocL();

	// Extract both headers (that are still left) and content.
	CSIPMessageElements* elements = ExtractHeadersAndContentLC();

	// -- Execution -----------------------------------------------------------

	// Start SIP Subscribe transaction.
	CSIPClientTransaction* transaction =
							dialogAssoc->SendInviteL( elements );
	CleanupStack::Pop( elements );

	// -- Response creation ---------------------------------------------------

	AddIdResponseL( KTransactionId, transaction );
	}
Пример #5
0
/**
 * INPUT:
 *   Headers:		From, To*, Contact*, Content-Type*
 *   Parameters:	Content*, RemoteURI*
 *   IDs:			RegistrationId*, InviteDialogId, ConnectionId*
 *
 * OUTPUT:
 *   Parameters:	-
 *   IDs:			TransactionId, InviteDialogId
 */
void TCmdSendInvite::ExecuteL()
{
    // -- Setup ---------------------------------------------------------------

    // Select connection; either default or user specified (and existing)
    CSIPConnection& connection = SelectConnectionL().Connection();

    // Get SIP objects from registry
    CSIPRegistrationBinding* registration = GetRegistrationL( EFalse );
    TBool fromHeaderMandatory( ETrue );
    if( registration )
    {
        fromHeaderMandatory = EFalse;
    }

    // Extract required headers (From may be either mandatory or optional)
    CSIPFromHeader* fromHeader = ExtractFromHeaderLC( fromHeaderMandatory );

    // Extract optional headers
    CSIPToHeader* toHeader = ExtractToHeaderLC( EFalse );
    CSIPContactHeader* contactHeader = ExtractContactHeaderLC( EFalse );

    // Conditionally create remote URI
    CUri8* remoteUri = ExtractRemoteURILC();

    // Construct the dialog association object
    CSIPInviteDialogAssoc* dialogAssoc;

    if( registration )
    {
        dialogAssoc = CSIPInviteDialogAssoc::NewL(
                          connection, remoteUri, *registration,
                          fromHeader, toHeader, contactHeader );
    }
    else
    {
        dialogAssoc = CSIPInviteDialogAssoc::NewL(
                          connection, fromHeader,
                          remoteUri, toHeader, contactHeader );
    }

    // Purge items from cleanup stack, now they are owned by CSIPInviteDialogAssoc
    // Some items are optional (i.e. NULL), so we've been tracking the number
    // of items in pushed to CleanupStack
    CleanupStack::Pop( iPushed );
    iPushed = 0;

    CleanupStack::PushL( dialogAssoc );

    // Extract both headers (that are still left) and content.
    CSIPMessageElements* elements = ExtractHeadersAndContentLC();

    // -- Execution -----------------------------------------------------------

    // Start SIP Invite transaction.
    CSIPClientTransaction* transaction = dialogAssoc->SendInviteL( elements );
    CleanupStack::Pop( elements );

    // -- Response creation ---------------------------------------------------

    AddIdResponseL( KTransactionId, transaction );
    CleanupStack::Pop( dialogAssoc );
    AddIdResponseL( KInviteDialogId, dialogAssoc );
}