bluetoothchatappui.cpp

来自「series60 应用程序开发的源代码 series60 应用程序开发的源代码」· C++ 代码 · 共 384 行

/**
*
* @brief Definition of CBluetoothChatAppUi
*
* Copyright (c) EMCC Software Ltd 2003
* @version 1.0
*/

// Class include
#include "BluetoothChatAppUi.h"

// System includes
#include <AknGlobalNote.h>
#include <AknNoteWrappers.h>
#include <AknQueryDialog.h>
#include <AknWaitDialog.h>
#include <BluetoothChat.rsg>        // R_BLUETOOTHCHAT_DIALOG
#include <eikmenup.h>
#include <stringloader.h>        // StringLoader

// User includes
#include "BluetoothChatDialog.h"    // CBluetoothChatDialog
#include "BluetoothChat.hrh"        // commands
#include "BluetoothDeviceSearcher.h"    // CBluetoothDeviceSearcher
#include "BluetoothServiceSearcher.h"    // CBluetoothServiceSearcher
#include "BluetoothClient.h"        // CBluetoothClient
#include "BluetoothServer.h"        // CBluetoothServer


// Constants
const TInt KFormattedMessagePrefixLength = 10;
_LIT(KFormattedMessagePrefix, "Message:\n");
const TInt KServerCleanupDelayMicroSeconds = 4000000;


// ================= MEMBER FUNCTIONS =======================

/**
* Symbian OS 2nd phase constructor.
* Constructs and executes the application's dialog,
* setting itself as the dialog's MOP parent, and adds it to the control
* stack.
*
* Creates an instance of the Bluetooth Client and Server
*
* @param none
* @return none
*/
void CBluetoothChatAppUi::ConstructL()
{
    BaseConstructL();
    iAppDialog = new (ELeave) CBluetoothChatDialog;
    iAppDialog->SetMopParent(this);
    iAppDialog->ExecuteLD(R_BLUETOOTHCHAT_DIALOG);
    AddToStackL(iAppDialog);

    iClient = CBluetoothClient::NewL(*this);
    iServer = CBluetoothServer::NewL(*this);
}

/**
* Destructor.
* Removes the application's dialog from the stack and deletes it.
*
* Deletes the Bluetooth Client and Server, and message buffer
*
*/
CBluetoothChatAppUi::~CBluetoothChatAppUi()
{
    if (iAppDialog)
    {
        RemoveFromStack(iAppDialog);
        delete iAppDialog;
    }

    delete iWaitDialog;

    delete iClient;
    delete iServer;

    delete iMessage;
}

/**
* Dynamic Menu Construction
*
* Restricts options available to the User via the Menu
* Performs checks on the state of the Client and Server to see what should be offered
*
* @param aResourceId
* @param @aMenuPane
* @return none
*/
void CBluetoothChatAppUi::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)
{
    if (aResourceId == R_BLUETOOTHCHAT_MENU_PANE)
    {
        if (iClient->IsConnected() || iServer->IsConnected())
        {
            aMenuPane->SetItemDimmed(EBluetoothChatConnect, ETrue);
            aMenuPane->SetItemDimmed(EBluetoothChatReceive, ETrue);
            if (iClient->IsConnected())
            {
                aMenuPane->SetItemDimmed(EBluetoothChatStopReceive, ETrue);
            }
            if (!iClient->AvailableToSend() && !iServer->AvailableToSend())
            {
                aMenuPane->SetItemDimmed(EBluetoothChatSend, ETrue);
            }
        }
        else
        {
            aMenuPane->SetItemDimmed(EBluetoothChatStopReceive, ETrue);
            aMenuPane->SetItemDimmed(EBluetoothChatSend, ETrue);
        }
    }
}

/**
* From CEikAppUi, takes care of command handling.
*
* @param aCommand command to be handled
* @return none
*/
void CBluetoothChatAppUi::HandleCommandL(TInt aCommand)
{
    switch (aCommand)
    {
        case EBluetoothChatConnect:
        {
            FindRemoteDeviceL();
            break;
        }

        case EBluetoothChatReceive:
        {
            StartReceivingL();
            break;
        }

        case EBluetoothChatStopReceive:
        {
            iServer->StopL();
            break;
        }

        case EBluetoothChatSend:
        {
            if (ComposeMessageL())
            {
                if (iClient->AvailableToSend())
                {
                    iClient->Send(*iMessage);
                }
                else if (iServer->AvailableToSend())
                {
                    iServer->Send(*iMessage);
                }
            }
            break;
        }

        case EEikCmdExit:
        {
            Exit();
            break;
        }

        default:
            break;
    }
}

/**
* Begin Client side communication.
*
* Find a Device
* Find Service on device and obtain Port information
* Pass to the Client to form a connection
* @param none
* @return none
*/
void CBluetoothChatAppUi::FindRemoteDeviceL()
{
    iDeviceSearcher = CBluetoothDeviceSearcher::NewL(*this);
    iDeviceSelectionResponse = new (ELeave) TBTDeviceResponseParamsPckg();
    iDeviceSearcher->SelectDeviceL(*iDeviceSelectionResponse);
}

void CBluetoothChatAppUi::DeviceFoundL(TInt result)
{
    delete iDeviceSearcher;    // delete and cleanup
    iDeviceSearcher = 0;

    if (result == KErrNone)
    {
        TInt port = 0;
        CBluetoothServiceSearcher* serviceSearcher = CBluetoothServiceSearcher::NewLC(port);
        TInt serviceFound = serviceSearcher->FindServiceL((*iDeviceSelectionResponse)().BDAddr());
        CleanupStack::PopAndDestroy( serviceSearcher );

        if (serviceFound == KErrNone)
        {
            iClient->ConnectToServerL((*iDeviceSelectionResponse)().BDAddr(), port);
        }
        else
        {
            CAknGlobalNote* globalNote = CAknGlobalNote::NewLC();
            HBufC* warning = StringLoader::LoadLC(R_SERVICE_NOT_FOUND);
            globalNote->ShowNoteL(EAknGlobalWarningNote, *warning);
            CleanupStack::PopAndDestroy(globalNote);
            CleanupStack::PopAndDestroy(warning);

            // Permit clean up of Bluetooth server connection
            User::After(TTimeIntervalMicroSeconds32(KServerCleanupDelayMicroSeconds));
        }
    }

    delete iDeviceSelectionResponse;
    iDeviceSelectionResponse = 0;
}

/**
* Begin Server side communication.
*
* Starts Server - this will start the server and configure the security settings
*
* @param none
* @return none
*/
void CBluetoothChatAppUi::StartReceivingL()
{
    iServer->StartServerL();
}


/**
* React to completion of server startup.
*
* Starts advertising on server
* Display a dialog box with the option to cancel this listening process
*
* @param none
* @return none
*/
void CBluetoothChatAppUi::ServerStartedL()
{

    // start the server's advertiser.
    iServer->StartAdvertisingL();

    // display a dialog to allow a user to cancel listening if required.
    delete iWaitDialog;
    iWaitDialog = NULL;
    iWaitDialog = new (ELeave) CAknWaitDialog(NULL, ETrue);
    HBufC* waitingMessage = StringLoader::LoadLC(R_WAITING_MESSAGE);
    iWaitDialog->SetTextL(*waitingMessage);
    CleanupStack::PopAndDestroy(waitingMessage);
    TInt retVal = iWaitDialog->ExecuteLD(R_BLUETOOTH_CONNECTION_WAIT_DIALOG);
    iWaitDialog = NULL;

    if (retVal != EAknSoftkeyDone)
    {
        // User has cancelled this connection process
        iServer->StopL();
    }

}


/**
* Connection Made.
*
* Server - Remove the Cancel dialog
* Client - Provide feedback that a connection has been made
* @param none
* @return none
*/
void CBluetoothChatAppUi::ConnectedL()
{
    if (iWaitDialog)
    {
        iWaitDialog->ProcessFinishedL();
        iWaitDialog = NULL;
    }

    if (iClient->IsConnected())
    {
        CAknInformationNote* infoDialog = new (ELeave) CAknInformationNote();
        HBufC* message = StringLoader::LoadLC(R_CONNECTED);
        infoDialog->ExecuteLD(*message);
        CleanupStack::PopAndDestroy(message);
    }
}

/**
* Provides a UI Text Query Dialog requesting message to be sent.
*
* @param none
* @return true if message was composed by user
*/
TBool CBluetoothChatAppUi::ComposeMessageL()
{
    TBool retVal = EFalse;

    delete iMessage;
    iMessage = NULL;
    iMessage = HBufC::NewL(KMaxMessageLength);
    TPtr message = iMessage->Des();

    HBufC* titleBuf = StringLoader::LoadLC(R_CHAT_TITLE);
    CAknTextQueryDialog* messageDialog = new (ELeave) CAknTextQueryDialog(message, *titleBuf, CAknTextQueryDialog::ENoTone);
    CleanupStack::PopAndDestroy(titleBuf);
    messageDialog->SetMaxLength(KMaxMessageLength);

    if (messageDialog->ExecuteLD(R_BLUETOOTH_CHAT_MESSAGE_DIALOG))
    {
        retVal = ETrue;
    }

    return retVal;
}

/**
* Display the message received from remote device.
* @param aMessage the message received
* @return none
*/
void CBluetoothChatAppUi::DataReceivedL(const TDesC& aMessage)
{
    TBuf<KMaxMessageLength + KFormattedMessagePrefixLength> formattedMessage;
    formattedMessage.Append(KFormattedMessagePrefix);
    formattedMessage.Append(aMessage);
    CAknQueryDialog* queryDialog = new (ELeave) CAknQueryDialog(formattedMessage, CAknQueryDialog::ENoTone);

    if (queryDialog->ExecuteLD(R_BLUETOOTH_CHAT_REPLY_DIALOG) == EBluetoothReply)
    {
        HandleCommandL(EBluetoothChatSend);
    }
}

/**
* Provide UI feedback of errors occured during communication
* @param aErrorCode code repesenting the error that occured
*/
void CBluetoothChatAppUi::HandleErrorL(TInt aErrorCode)
{
    HBufC* message;

    switch (aErrorCode)
    {
        case (KErrDisconnected):
        case (KErrAbort):
        {
            message = StringLoader::LoadLC(R_DISCONNECTED);
            break;
        }

        case (KErrNotReady):
        {
            message = StringLoader::LoadLC(R_CONNECTION_LOST);
            break;
        }

        case (KErrCouldNotConnect):
        {
            message = StringLoader::LoadLC(R_COULD_NOT_CONNECT);
            break;
        }

        default:
        {
            message = StringLoader::LoadLC(R_UNKNOWN_ERROR);
            break;
        }
    }

    CAknWarningNote* errorDialog = new (ELeave) CAknWarningNote();
    errorDialog->ExecuteLD(*message);
    CleanupStack::PopAndDestroy(message);
}

// End of File