examples/Qt/qtbluetoothapp/bluetoothdiscovery_symbian.cpp

/*
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
 *    
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    
 *  * Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *  * Neither the name of Nokia Corporation nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *    
 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 *    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 *    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 *    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *    
 *    Description:  
 */
// INCLUDE FILES
#include <utf.h>
#include "bluetoothdiscovery_symbian.h"


BluetoothDiscoveryPrivate* BluetoothDiscoveryPrivate::NewL(BluetoothDiscovery* aWrapper)
    {
    BluetoothDiscoveryPrivate* self =
            BluetoothDiscoveryPrivate::NewLC(aWrapper);
    CleanupStack::Pop(self);
    return self;
    }


BluetoothDiscoveryPrivate* BluetoothDiscoveryPrivate::NewLC(
        BluetoothDiscovery* aWrapper)
    {
    BluetoothDiscoveryPrivate* self =
        new (ELeave) BluetoothDiscoveryPrivate(aWrapper);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }


// Standard EPOC 2nd phase constructor
void BluetoothDiscoveryPrivate::ConstructL()
    {
    // get socket server session
    User::LeaveIfError(iSocketServ.Connect());

    // init listener
    iListener = CListener::NewL(*this, iSocketServ);
    // init device discoverer
    iDeviceDiscoverer = CDeviceDiscoverer::NewL(iSocketServ, *this);
    
    // init service advertiser
    iServiceAdvertiser = CServiceAdvertiser::NewL();
    // init service discoverer
    iServiceDiscoverer = CServiceDiscoverer::NewL(*this);

    // clean connections table to begin with
    for ( TInt idx=0; idx<KMaxConnectedDevices; idx++ )
        {
        iConnectedDevices[idx] = NULL;
        }
    }

BluetoothDiscoveryPrivate::BluetoothDiscoveryPrivate(
        BluetoothDiscovery* aWrapper): iIsSlave(EFalse),
                                       iDiscovery(aWrapper)
    {
    //Nothing to do
    }

BluetoothDiscoveryPrivate::~BluetoothDiscoveryPrivate()
    {
    if ( IsDiscoveryActive() )
        {
        iDeviceDiscoverer->StopDiscovery();
        } 
    // disconnect all devices and clean up connections table
    DisconnectDevices();
    // stop and kill helpers

    delete iServiceAdvertiser;
    iServiceAdvertiser=NULL;

    delete iListener;
    iListener=NULL;
    
    iDeviceDiscoverer->Cancel();
    delete iDeviceDiscoverer;
    iDeviceDiscoverer = NULL;

    delete iServiceDiscoverer;
    iServiceDiscoverer=NULL;

    iSocketServ.Close();
    // wipe device data list
    iDevDataList.ResetAndDestroy();
    
    }

void BluetoothDiscoveryPrivate::DiscoverDevicesL()
    {
    //timing:
    iStartTime.HomeTime();
    iResponse = KDiscDevicesTxt;
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
    TRAPD(err,iDeviceDiscoverer->DiscoverDevicesL(&iDevDataList));
    if (err)
        {
        HandleDeviceDiscoveryComplete(err);
        }
    ChangeMenuOptions();
    }

void BluetoothDiscoveryPrivate::DiscoverServicesL()
    {
    iStartTime.HomeTime();
    iResponse = KDiscServicesTxt;
    iServiceDiscoverer->DiscoverServicesL(&iDevDataList);
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
    ChangeMenuOptions();
    }

void BluetoothDiscoveryPrivate::StartSlaveL()
    {
    if ( iIsSlave )
        return;
    
    iResponse = KSlaveInitTxt;
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
      
    TInt channel;
    iListener->StartListenerL(channel);
    TBuf<KThirty> msg;
    msg.AppendFormat(KListeningTxt, channel);
       
    emit(iDiscovery->showMessage(false,QString::fromUtf16(msg.Ptr(),msg.Length())));

    iServiceAdvertiser->StartAdvertiserL(channel);
    
    iResponse = KSlaveInitCompTxt;
    emit(iDiscovery->showMessage(false,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
    iIsSlave=ETrue;
    ChangeMenuOptions();
    }

void BluetoothDiscoveryPrivate::StopSlaveL()
    {
    if ( !iIsSlave )
        return;
    
    _LIT(KStopSlave,"Stopped the slave");
    iResponse = KStopSlave;
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));

    iListener->StopListener();
    iServiceAdvertiser->StopAdvertiserL();
    iIsSlave = EFalse;
    ChangeMenuOptions();
    }

void BluetoothDiscoveryPrivate::DisconnectDevices()
    {
    for ( TInt idx=0; idx<KMaxConnectedDevices; idx++ )
        {
        if ( iConnectedDevices[idx] )
            {
            delete iConnectedDevices[idx];
            iConnectedDevices[idx]=NULL;
            }
        }
    
    iResponse = KDisconnDevicesTxt;
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
    iIsMaster = EFalse;
    ChangeMenuOptions();
    }

void BluetoothDiscoveryPrivate::ConnectDevicesL()
     {
     // close and delete all existing connections
     DisconnectDevices();

     iResponse = KConnectingTxt;
     emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
     // now attempt to connect
     for ( TInt idx=0; idx<(iDevDataList.Count()); idx++ )
         {
         if ( iConnectedDeviceCount>=KMaxConnectedDevices )
             return;

         TDeviceData *dev = iDevDataList[idx];

         // if matching service on remote device was found, the service port
         // is set and will be > 0.  if so, we can attempt to connect.
         if ( dev->iDeviceServicePort>0 )
             {
             CConnector* connector = CConnector::NewLC(*this, iSocketServ);
             if ( (connector->ConnectL(dev->iDeviceName,
                                       dev->iDeviceAddr,
                                       dev->iDeviceServicePort))==KErrNone )
                 {
                 iConnectedDevices[iConnectedDeviceCount] = connector;
                 iConnectedDeviceCount++;
                 CleanupStack::Pop(connector);
                 }
             else
                 {
                 // connection to device failed!!
                 CleanupStack::PopAndDestroy();
                 }
             }
         }

     ShowConnectedDevicesL();
     ChangeMenuOptions();
     }

void BluetoothDiscoveryPrivate::ShowConnectedDevicesL()
    {
    TInt count=0;
    iResponse = KConnDevicesTxt;
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
    for (TInt idx=0; idx<KMaxConnectedDevices; idx++)
        {
        if ( iConnectedDevices[idx] )
            {
            THostName name;
            name = iConnectedDevices[idx]->iName;
            name.Append(KNewLine);
            emit(iDiscovery->showMessage(false,QString::fromUtf16(name.Ptr(),name.Length())));
            count++;
            }
        }
    if ( count==0 )
        {
        // no connections!
        // this may be because of no devices has been discovered,
        // or no devices are offering the requested service.
        iResponse = KNoConns; 
        emit(iDiscovery->showMessage(false,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
        }
    }

void BluetoothDiscoveryPrivate::SendMessageL()
    {
    _LIT(KSendMessage,"Hi friends");
    TBuf<KEighty> msg(KSendMessage);
    // explicitly convert from 16bit to 8bit character set
    CnvUtfConverter::ConvertFromUnicodeToUtf8(iMsgtext8, msg);

    if(iIsSlave)
        {
        // slave sending data
        iListener->SendData(iMsgtext8);
        emit(iDiscovery->showMessage(false,QString::fromUtf16(msg.Ptr(),msg.Length())));
        }
    else
        {
        // master sending data
        for (TInt idx=0; idx<KMaxConnectedDevices; idx++)
            {
            if ( iConnectedDevices[idx])
                {
                iConnectedDevices[idx]->SendData(iMsgtext8);
                THostName name;
                name=iConnectedDevices[idx]->iName;
                msg.Format(KFormatStr2, &name, &iMsgtext);
                emit(iDiscovery->showMessage(false,QString::fromUtf16(msg.Ptr(),msg.Length())));
                }
            }
        }
    }

void BluetoothDiscoveryPrivate::HandleListenerDataReceivedL(const TDesC& aData)
    {
    // display received message
    TBuf<KEighty> msg;
    msg.Format(KFormatStr1, &aData);
    emit(iDiscovery->showMessage(false,QString::fromUtf16(msg.Ptr(),msg.Length())));
    }

void BluetoothDiscoveryPrivate::HandleListenerConnectedL()
    {
    iResponse = KConnMsg; 
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
    }

void BluetoothDiscoveryPrivate::HandleListenerDisconnectedL()
    {
    if ( !iIsSlave )
        return;
    // Stop listener and advertiser
    // Set app to init mode
    StopSlaveL();
    iResponse = KDisconMsg;
    emit(iDiscovery->showMessage(true,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
    }

void BluetoothDiscoveryPrivate::HandleConnectorDataReceivedL(THostName aName,
                                                              const TDesC& aData)
    {
    // display received message
    TBuf<KEighty> msg;
    msg.Format(KFormatStr, &aName, &aData);
    emit(iDiscovery->showMessage(true,QString::fromUtf16(msg.Ptr(),msg.Length())));

    // echo the message to other slaves
    _LIT8(KSeparator, ":");

    TBuf8<KEighty> buf; //should use HBufC so the size will be big enough
    TPtr8 msgtext8((TUint8*)buf.Ptr(), aData.Size()+KSeparator().Length() + aName.Size());
    CnvUtfConverter::ConvertFromUnicodeToUtf8(msgtext8, aData);

    //convert name to UTF8 so other slaves see
    //the sender name
    TBuf8<KEighty> bufName;
    TPtr8 name8((TUint8*)bufName.Ptr(), aName.Size());
    CnvUtfConverter::ConvertFromUnicodeToUtf8(name8, aName);

    //add the separator and name in the beginning;
    msgtext8.Insert(0, KSeparator );
    msgtext8.Insert(0, name8);

    for (TInt idx=0; idx<KMaxConnectedDevices; idx++)
        {
        if ( iConnectedDevices[idx])
            {
            THostName name;
            name=iConnectedDevices[idx]->iName;

            //echo to other slaves than the sender
            if( name.Compare(aName) != 0)
                iConnectedDevices[idx]->SendData(msgtext8);
            }
        }
    }

void BluetoothDiscoveryPrivate::HandleConnectorErrorL(THostName aName, TInt aError)
    {
    if (aError)
        {
        // display received message
        TBuf<KEighty> msg;
        msg.Format(KDeviceDisconMsg, &aName);
        emit(iDiscovery->showMessage(false,QString::fromUtf16(msg.Ptr(),msg.Length())));

        for (TInt idx=0; idx<KMaxConnectedDevices; idx++)
            {
            if ( iConnectedDevices[idx])
                {
                THostName name;
                name=iConnectedDevices[idx]->iName;

                //echo to other slaves than the sender
                if( name.Compare(aName) == 0)
                    {
                    delete iConnectedDevices[idx];
                    iConnectedDevices[idx] = NULL;
                    }
                }
            } 
    }
    }

void BluetoothDiscoveryPrivate::HandleDeviceDiscoveryComplete(TInt aError)
    {
    if (aError)
        {
        iIsMaster = ETrue;
        }
    else
        {
        iIsMaster = EFalse;
        }
    
    iEndTime.HomeTime();

    TTimeIntervalSeconds seconds;
    iEndTime.SecondsFrom(iStartTime, seconds);

    TInt time = seconds.Int();
    TBuf<KTwelve> temp = KTimeTxt();
    temp.AppendNum(time);
    temp.Append(KSecTxt);
    TRAPD(err,emit(iDiscovery->showMessage(false,QString::fromUtf16(temp.Ptr(),temp.Length()))));

    // iterate and display found devices, if any
    if ( iDevDataList.Count()> 0 )
        {
        TBuf<KTwenty> count = KFoundTxt();
        count.AppendNum( iDevDataList.Count() );
        count.Append( KDevices );
        TRAP(err,emit(iDiscovery->showMessage(false,QString::fromUtf16(count.Ptr(),count.Length()))));
        }
    else
        {
        // no devices found
        iResponse = KNoDevFound;
        TRAP(err,emit(iDiscovery->showMessage(false,QString::fromUtf16(iResponse.Ptr(),iResponse.Length()))));
        }
    emit iDiscovery->changeMenu(BluetoothDiscoveryPrivate::EDeviceDiscoveryComplete);
    }

void BluetoothDiscoveryPrivate::HandleServiceDiscoveryCompleteL()
    {
    iEndTime.HomeTime();

    TTimeIntervalSeconds seconds;
    iEndTime.SecondsFrom(iStartTime, seconds);

    TInt time = seconds.Int();
    TBuf<KTwelve> temp = KTimeTxt();
    temp.AppendNum(time);
    temp.Append(KSecTxt);
    emit(iDiscovery->showMessage(true,QString::fromUtf16(temp.Ptr(),temp.Length())));

    TInt count=0;
    // display devices with service we can use
    for ( TInt idx=0; idx<(iDevDataList.Count()); idx++ )
        {
        TDeviceData *dev = iDevDataList[idx];
        if ( dev->iDeviceServicePort>0 )
            {
            THostName name = dev->iDeviceName;
            name.Append(KNewLine);
            emit(iDiscovery->showMessage(false,QString::fromUtf16(name.Ptr(),name.Length())));
            count++;
            }
        }
    if ( count==0 )
        {
        iResponse = KNoServiceFound;
        emit(iDiscovery->showMessage(false,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
        }
    else
        {
        iResponse = KServiceFound;
        emit(iDiscovery->showMessage(false,QString::fromUtf16(iResponse.Ptr(),iResponse.Length())));
        }
    }

TBool BluetoothDiscoveryPrivate::HasConnections()
    {
    TBool exists = EFalse;
    for (TInt idx=0; idx<KMaxConnectedDevices; idx++)
        {
        if ( iConnectedDevices[idx])
            {
            exists = ETrue;
            break;
            }
        }
    return exists;
    }


// ----------------------------------------------------------------------------
// CBluetoothPMPExampleEngine::DeviceDiscovered
// ----------------------------------------------------------------------------
//a callback to indicate that a device has been found
//main reason for this is that the UI can react so user
//knows that something is going on and the app is not "frozen"
void BluetoothDiscoveryPrivate::DeviceDiscovered(const TDeviceData &aDevice)
    {
    
    TInt len = aDevice.iDeviceName.Length();
    if (len >80)
        len=80;
    TBuf<80> name(aDevice.iDeviceName.MidTPtr(0,len));
   
    name.Trim();

    if( name.Length() == 0 )
        name.Append(KDeviceWithNoName);
        name.Append(KNewLine);
    emit(iDiscovery->showMessage(false,QString::fromUtf16(name.Ptr(),name.Length())));
    iIsMaster = ETrue;
    emit(iDiscovery->showMessage(false,QString("\n")));
    ChangeMenuOptions();
    }

// ----------------------------------------------------------------------------
// CBluetoothPMPExampleEngine::ReportServiceDiscoveryErrorL
// ----------------------------------------------------------------------------
void BluetoothDiscoveryPrivate::ReportServiceDiscoveryErrorL(TInt aError)
    {
    TBuf<KThirty> discError = KServiceDiscoveryError();
    discError.AppendNum(aError);
    emit(iDiscovery->showMessage(false,QString::fromUtf16(discError.Ptr(),discError.Length())));
    }

// ----------------------------------------------------------------------------
// CBluetoothPMPExampleEngine::TurnBtOnL
// ----------------------------------------------------------------------------
//Uses the Notifier API to ask the user to turn on Bluetooth
//if it's not on already.
void BluetoothDiscoveryPrivate::TurnBtOnL()
    {
    //the constant is from btnotifierapi.h which is not in all SDKs
    //so it's hard coded here
    const TUid KPowerModeSettingNotifierUid = {0x100059E2};
    //const TUid KBTPowerStateNotifierUid = {0x101F808E}; //S80 and 7710
    
    RNotifier notifier;
    User::LeaveIfError( notifier.Connect() );
    TPckgBuf<TBool> dummy(ETrue);
    TPckgBuf<TBool> reply(EFalse);
    TRequestStatus stat;
    notifier.StartNotifierAndGetResponse(stat, KPowerModeSettingNotifierUid, dummy, reply);
    User::WaitForRequest(stat);
    notifier.CancelNotifier(KPowerModeSettingNotifierUid);
    notifier.Close();
    }

// ----------------------------------------------------------------------------
// CBluetoothPMPExampleEngine::IsDiscoveryActive
// ----------------------------------------------------------------------------
TBool BluetoothDiscoveryPrivate::IsDiscoveryActive()
    {
    return iDeviceDiscoverer->IsActive();
    }

// ----------------------------------------------------------------------------
// CBluetoothPMPExampleEngine::StopDiscovery
// ----------------------------------------------------------------------------
void BluetoothDiscoveryPrivate::StopDiscovery()
    {
    if ( IsDiscoveryActive() )
        {
        iDeviceDiscoverer->StopDiscovery();
        ChangeMenuOptions();
        } 
    }

// Change the menu options.
void BluetoothDiscoveryPrivate::ChangeMenuOptions()
    {
    // Arrange the menu items.
    
    // Slave Mode =========================================================
    
    if (iIsSlave)
        {
        if ( iListener->IsConnected() )
            {
            // Show the Send Message option
            emit iDiscovery->changeMenu(BluetoothDiscoveryPrivate::ESendMessage);
            }
        emit iDiscovery->changeMenu(BluetoothDiscoveryPrivate::EStopSlave);
        }
    
    TBool myActiveDiscovery(IsDiscoveryActive());
    
    if(myActiveDiscovery)
        {
        emit iDiscovery->changeMenu(BluetoothDiscoveryPrivate::EStopDeviceDiscovery);
        }
    
    // Master Mode ========================================================
    if (iIsMaster) 
        {
        if(!iIsSlave)
            {
            if ( iDeviceDiscoverer->HasDevices() && !iDeviceDiscoverer->IsActive())
                {
                // we have found devices, show discover services item
                emit iDiscovery->changeMenu(BluetoothDiscoveryPrivate::EHasDevices);
                }
            if ( iServiceDiscoverer->HasServices() && !iServiceDiscoverer->iRunning)
                {
                // we have found services, show connect item
                emit iDiscovery->changeMenu(BluetoothDiscoveryPrivate::EHasServices);
                }
            if ( HasConnections() )
                {
                // we are connected
                emit iDiscovery->changeMenu(BluetoothDiscoveryPrivate::EHasConnections);
                }
            }
        }
    }

---