btdiscoverer.cpp

Go to the documentation of this file.

/*
 * btdiscoverer.cpp,v 1.13 2003/11/25 19:29:56 mattid Exp
 *
 * COBAIN - Communications API for EPOC Environments
 * Copyright (C) 2002-2003 Matti Dahlbom, Matti Kokkola
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Contact: Matti Dahlbom <matti@777-team.org>
 *          Matti Kokkola <matti.kokkola@iki.fi>
 */

#include <es_sock.h>
#include <bt_sock.h>

#include "bluetoothcommunicator.h"
#include "btdiscoverer.h"
#include "cobainserver.h"
#include "serversession.h"
#include "Log.h"

CBTDiscoverer * CBTDiscoverer::NewL(RMessage &aMessage, CServerSession &aSession)
{
    CBTDiscoverer *d = new (ELeave) CBTDiscoverer(aMessage, aSession);
    CleanupStack::PushL(d);
    d->ConstructL();
    CleanupStack::Pop(); // d

    return d;
}

void CBTDiscoverer::ConstructL()
{
    // create the SDP search pattern
    iSdpPattern = CSdpSearchPattern::NewL();
//    iSdpPattern->AddL(KL2CAP);
//    iSdpPattern->AddL(KRFCOMM);

    // extract service class id from the message
    TUint aServiceClassID = iMessage.Int2();
    iSdpPattern->AddL(aServiceClassID);                        

    // create the attribute match list
//    iMatchList = CSdpAttrIdMatchList::NewL();

    //iMatchList->AddL(TAttrRange(0x0000, 0xFFFF));
    //use here:
    //KSdpAttrIdProtocolDescriptorList instead of attr range
}

CBTDiscoverer::CBTDiscoverer(RMessage &aMessage, CServerSession &aSession) 
    : CActive(CActive::EPriorityStandard), 
      iMessage(aMessage), 
      iSession(aSession),
      iCurrentDeviceIndex(-1)
{
}

CBTDiscoverer::~CBTDiscoverer()
{
    iDeviceAddresses.ResetAndDestroy();
    delete iSdpPattern;
    delete iAgent;
}

void CBTDiscoverer::DoCancel()
{
    // must close host resolver
    iHr.Close();

    delete iPeerList;
    iPeerList = NULL;
}

void CBTDiscoverer::StartL(RSocketServ &aSocketServ)
{
   // //Log::Print(_L("CBTDiscoverer::StartL()"));

    iPeerList = new (ELeave) TPeerDataList();

    TProtocolDesc pInfo;
    User::LeaveIfError(aSocketServ.FindProtocol(_L("BTLinkManager"), pInfo));

    // create and initialise an RHostResolver
    User::LeaveIfError(iHr.Open(aSocketServ, pInfo.iAddrFamily, pInfo.iProtocol));

    // set up a discovery query 
    TInquirySockAddr addr;
    TNameEntry name;
    addr.SetIAC(KGIAC);
    addr.SetAction(KHostResName | KHostResInquiry);

    // add to active scheduler
    CActiveScheduler::Add(this);

    // initiate discovery of the first device
    TRequestStatus status;
    iHr.GetByAddress(addr, iNameEntry, iStatus);

    // wait for completion
    SetActive();
}

void CBTDiscoverer::DiscoverServices(TNameRecord &aNameRecord)
{
    delete iAgent;
    iAgent = NULL;

    //Log::Print(_L("DiscoverServices(): %S"), &(aNameRecord.iName));

    // extract bluetooth address
    TBTDevAddr btaddr = static_cast<TBTSockAddr>(aNameRecord.iAddr).BTAddr();

    TRAPD(err, (iAgent = CSdpAgent::NewL(*this, btaddr)));
    if( err != KErrNone ) {
        User::Panic(KBTDiscovererPanic, KErrBtdiscovererAllocFailed);
    }   

    iAgent->SetRecordFilterL(*iSdpPattern);
    iAgent->NextRecordRequestL(); // will result in NextRecordRequestComplete()
}

// initializes client's peer list and completes client call 
void CBTDiscoverer::FinishDiscovery()
{
    //Log::Print(_L("FinishDiscovery()"));

    iCurrentDeviceIndex = -1;

    // give up peer list
    iSession.SetPeerList(iPeerList);
    iPeerList = NULL;

    // write number of peers and complete the original call
    TBuf8<sizeof(TInt)> buf;
    buf.Copy((const TUint8 *)(&iNumPeers), sizeof(TInt));
    iMessage.WriteL(iMessage.Ptr1(), buf);

    iMessage.Complete(KErrNone);

    // release memory
    iDeviceAddresses.ResetAndDestroy();
}

void CBTDiscoverer::DeviceDiscovered()
{
    if( iStatus == KErrNone ) {
        TNameRecord record = iNameEntry();

  //      //Log::Print(_L("found device %S"), &(record.iName));

        // create new instance
        TNameRecord *new_record = NULL;
        TRAPD(err, (new_record = new (ELeave) TNameRecord()));
        if( err != KErrNone ) {
            User::Panic(KBTDiscovererPanic, KErrBtdiscovererAllocFailed);
        } 

        // initialize the new instance
        Mem::Copy(new_record, &record, sizeof(TNameRecord));

        // add the instance to device address list 
        iDeviceAddresses.Append(new_record);

        // discover next device
        iHr.Next(iNameEntry, iStatus);
        SetActive();
    } else {
//        //Log::Print(_L("** no more devices"));

        // no more devices; all done
        iHr.Close();

        // start discovering services
        if( iDeviceAddresses.Count() > 0 ) {
            // create service discover agent
            iCurrentDeviceIndex = 0;
            DiscoverServices(*iDeviceAddresses[iCurrentDeviceIndex]);
        } else {
            // no devices found! list is empty; allow client call return
            FinishDiscovery(); 
        }
    }
}

void CBTDiscoverer::RunL()
{
  //  //Log::Print(_L("CBTDiscoverer::RunL()"));

    DeviceDiscovered();
}

TInt CBTDiscoverer::RunError(TInt aError)
{
    //Log::Print(_L("RunError(): %d"), aError);

    return aError;
}

// from MSdpAgentNotifier

void CBTDiscoverer::AttributeRequestComplete(TSdpServRecordHandle /*aHandle*/, 
                                             TInt aError)
{
    //Log::Print(_L("AttributeRequestComplete()"));

    if( aError != KErrNone ) {
        //Log::Print(_L("AttributeRequestComplete(): %d"), aError);
        //##TODO## handle
    } else {
        // attributes done - request next service record
        TRAPD(err, iAgent->NextRecordRequestL());
        if( err != KErrNone ) {
            //Log::Print(_L("iAgent->NextRecordRequestL() error: %d"), err);
            //##TODO## handle
        }
    }
}

void CBTDiscoverer::AttributeRequestResult(TSdpServRecordHandle /*aHandle*/, 
                                           TSdpAttributeID /*aAttrID*/, 
                                           CSdpAttrValue* aAttrValue)
{
    // initiate attribute list traversal
    iAttrNum = 0;
    iPeerOk = ETrue;

    //Log::Print(_L("AttributeRequestResult()"));

    // parse through the attributes - will result in calls to 
    // VisitAttributeValueL()
    TRAPD(err, aAttrValue->AcceptVisitorL(*this));
    if( err != KErrNone )
    {
        //Log::Print(_L("aAttrValue->AcceptVisitorL() error: %d"), err);
            //##TODO## handle
    }
}

// called when discovery of a advertised service completes
void CBTDiscoverer::NextRecordRequestComplete(TInt aError, 
                                              TSdpServRecordHandle aHandle, 
                                              TInt aTotalRecordsCount)
{
    //Log::Print(_L("NRRC(): error: %d, count: %d, handle: %d"), 
   //                aError, aTotalRecordsCount, aHandle);

    if( (aError == KErrNone) && (aTotalRecordsCount > 0) ) {
        // retrieve the service attributes - will result in call to 
        // VisitAttributeValueL() for every attribute of the service

        // request protocol descriptor to get the port. will result in 
        // call to VisitAttributeValueL()
        TRAPD(err, iAgent->AttributeRequestL(aHandle, KSdpAttrIdProtocolDescriptorList));
        if( err != KErrNone ) {
            //Log::Print(_L("iAgent->AttributeRequestL() error: %d"), err);
            //##TODO## panic!
        }
    } else {
        // no more services for this device - discover the services of next device
        // if devicesw left
        iCurrentDeviceIndex++;

        if( iCurrentDeviceIndex < iDeviceAddresses.Count() ) {
            DiscoverServices(*iDeviceAddresses[iCurrentDeviceIndex]);
        } else {
            // all devices processed - all done!
            FinishDiscovery();
        }
    }
}

// from MSdpAttributeValueVisitor
/*
// cobain protocol stack resources
const TInt KCobainProtocolStackSize = 6;

static const TSdpElementType KCtalkStack[KCobainProtocolStackSize] = 
    { ETypeDES, ETypeDES, ETypeUUID, ETypeDES, ETypeUUID, ETypeUint };
*/
// cobain protocol stack resources
const TInt KCobainProtocolStackSize = 4;

static const TSdpElementType KCtalkStack[KCobainProtocolStackSize] = 
    { ETypeDES, ETypeDES, ETypeUUID, ETypeUint };

void CBTDiscoverer::VisitAttributeValueL(CSdpAttrValue &aValue, 
                                         TSdpElementType aType)
{
    // check stack format
    if( !iPeerOk || 
        (iAttrNum >= KCobainProtocolStackSize) ||
        (KCtalkStack[iAttrNum++] != aType) ) {
        iPeerOk = EFalse;

        //Log::Print(_L("rejecting 1"));
        return;
    }

    TBuf<64> buf;
   // const TDesC8 *uuid;
    TBuf8<16> uuid;
    TUint *val;

    switch( aType ) {
        case ETypeUUID:
            //uuid = &(aValue.UUID().ShortestForm());
            uuid = aValue.UUID().ShortestForm();
            val = (TUint*)uuid.Ptr();
            //Log::Print(_L("UUID: %d"), *val);
            break;
        case ETypeUint:
            //Log::Print(_L("Uint: %d"), aValue.Uint());

            // if the protocol stack descriptor is of correct format, this is the
            // port number. add a peer entry
            if( iAttrNum == KCobainProtocolStackSize ) {
                //TBTDevAddr btaddr = static_cast<TBTSockAddr>(iNameEntry().iAddr).BTAddr();
                TNameRecord *record = iDeviceAddresses[iCurrentDeviceIndex];
                TBTDevAddr btaddr = static_cast<TBTSockAddr>(record->iAddr).BTAddr();
                TPeerData *data = new (ELeave) TPeerData();
                data->iDeviceName = record->iName;
                data->iDeviceAddress = btaddr.Des();
                //##TODO##
                //data->iServiceID = ?? // - what is this anyway?
                // -> well it is a textual service description of course
                data->iPort = aValue.Uint();

                //Log::Print(_L("found port %d for device %S"), 
//                    data->iPort, &(data->iDeviceName));

                iPeerList->Append(data);
                iNumPeers++;
            } else {
                //Log::Print(_L("rejecting 2"));
            }
            break;
        case ETypeDES:
            //Log::Print(_L("DES"));
            break;
        case ETypeNil:
            //Log::Print(_L("Nil"));
            break;
        case ETypeInt:
           //Log::Print(_L("Int"));
            break;
        case ETypeString:
           //Log::Print(_L("String"));
            break;
        case ETypeBoolean:
           //Log::Print(_L("Boolean"));
            break;
        case ETypeDEA:
           //Log::Print(_L("DEA"));
            break;
        case ETypeURL:
           //Log::Print(_L("URL"));
            break;
        case ETypeEncoded:
           //Log::Print(_L("Encoded"));
            break;
        default:
            // dont really care..
            break;
    }
}

void CBTDiscoverer::StartListL(CSdpAttrValueList& /*aList*/)
{
    // no implementation
}

void CBTDiscoverer::EndListL()
{
    // no implementation
}

---