/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Maintain a Bluetooth devices data model for UI components.

*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include "btdevmodel.h"

#include "btpairedmodel.h"

#include "btblockedmodel.h"

#include "debug.h"

// --------------------------------------------------------------------------------------------

// CBTDevModel::CBTDevModel

// --------------------------------------------------------------------------------------------                            

CBTDevModel::CBTDevModel()

    {

    }

// --------------------------------------------------------------------------------------------

// CBTDevModel::NewL

// --------------------------------------------------------------------------------------------                            

EXPORT_C CBTDevModel* CBTDevModel::NewL(const TBTDeviceGroup aGroup,

                                        MBTDeviceObserver* aObserver,

                                        TBTDeviceSortOrder* aOrder 

                                         )

    {

    CBTDevModel* self = new (ELeave) CBTDevModel();

    CleanupStack::PushL(self);

    TBTDeviceSortOrder *order=NULL;    

    if(aOrder == NULL)

    	{

    	order=new(ELeave) TBTDeviceSortOrder(TBTDeviceComparison::CompareAphabetically);    	

    	// Order ownership goes to btdevmodel - don't push it to stack

    	self->ConstructL(aGroup, aObserver, order);

    	}    	

    else

		{

    	order=aOrder;		

		self->ConstructL(aGroup, aObserver, order);    	

		}        

    CleanupStack::Pop(self);

    return self;

    }    

// --------------------------------------------------------------------------------------------

// CBTDevModel::~CBTDevModel

//

// Destructor

// --------------------------------------------------------------------------------------------

CBTDevModel::~CBTDevModel()

    {

	TRACE_FUNC_ENTRY

    delete iDevModel;

    }

// --------------------------------------------------------------------------------------------

// CBTDevModel::ConstructL

//

// Constructs CBTPairedModel or CBTBlockedModel, depending on aGroup

// --------------------------------------------------------------------------------------------                                

void CBTDevModel::ConstructL(const TBTDeviceGroup aGroup,

                             MBTDeviceObserver* aObserver,

                             TBTDeviceSortOrder* aOrder  )

    { 

	TRACE_FUNC_ENTRY    

    iGroup=aGroup;

    switch (aGroup)

        {

        case EGroupPaired:

            iDevModel = CBTPairedModel::NewL(aObserver, aOrder);

            break;

        case EGroupBlocked:

            iDevModel = CBTBlockedModel::NewL(aObserver, aOrder);

            break;

        default:

            break;

        }

	TRACE_FUNC_EXIT

    }

EXPORT_C TBool CBTDevModel::IsAnyDeviceConnected()

	{

	return iDevModel->IsAnyDeviceConnected();

	}

// --------------------------------------------------------------------------------------------

// CBTDevModel::GetDevice

// wrapper function

// --------------------------------------------------------------------------------------------                                

EXPORT_C TInt CBTDevModel::GetDevice(TBTDevice& aDevice)

    {

    return iDevModel->GetDevice(aDevice);

    }

// --------------------------------------------------------------------------------------------

// CBTDevModel::CreateDevice 

// wrapper function

// --------------------------------------------------------------------------------------------                                

EXPORT_C TBTDevice* CBTDevModel::CreateDeviceL(const CBTDevice* aRegDevice, 

        TNameEntry* aNameEntry)

	{

		return iDevModel->CreateDeviceL(aRegDevice, aNameEntry);

	}

// --------------------------------------------------------------------------------------------

// CBTDevModel::GetDeviceType

// wrapper function

// --------------------------------------------------------------------------------------------                                    

EXPORT_C void CBTDevModel::ChangeAllDevices(const TBTDeviceOp aOperation)

    {

    iDevModel->ChangeAllDevices(aOperation);

    }

// --------------------------------------------------------------------------------------------

// CBTDevModel::ChangeDevice

// wrapper function

// --------------------------------------------------------------------------------------------    

EXPORT_C void CBTDevModel::ChangeDevice(const TBTDevice& aDevice)

    {

    iDevModel->ChangeDevice(aDevice);    

    }

// --------------------------------------------------------------------------------------------

// CBTDevModel::ChangeDevice

// --------------------------------------------------------------------------------------------       

EXPORT_C void CBTDevModel::ChangeDevice(const CBTDevice* aDevice,

        TNameEntry* aNameEntry, TBTDeviceOp aOp)

    {

    	TRACE_FUNC_ENTRY

		TBTDevice *tmp=NULL;      	

    	TInt err = KErrNone;

		if(aOp == EOpPair)

    		{

    		if(iGroup !=EGroupPaired )

    			{

    			err = KErrNotSupported;

    			}

    		else

    			{

    			TInt err2 = KErrNone;

    			TRAP(err, err2 = static_cast<CBTPairedModel*>(iDevModel)->PairDeviceL( aDevice, aNameEntry));

    			err = (err2 != KErrNone) ? err2 : err;

    			}

    		}

		else 

			{

			TRAP(err, tmp=iDevModel->CreateDeviceL(aDevice, aNameEntry ));

			if(err == KErrNone)

				{

				tmp->iOperation=aOp;

				iDevModel->ChangeDevice(*tmp );

				}

			}

		if(err != KErrNone)

		    {

		    iDevModel->HandleLeave(err,tmp);

		    }

    	TRACE_FUNC_EXIT

    }        

// --------------------------------------------------------------------------------------------

// CBTDevModel::CancelChange

// wrapper function

// --------------------------------------------------------------------------------------------        

EXPORT_C void CBTDevModel::CancelChange(const TBTDevice& aDevice)

    {

    iDevModel->CancelChange(aDevice);

    }

// --------------------------------------------------------------------------------------------

// CBTDevModel::DeviceChangeInProgress

// wrapper function

// --------------------------------------------------------------------------------------------        

EXPORT_C TBool CBTDevModel::DeviceChangeInProgress()

	{

	return iDevModel->DeviceChangeInProgress();

	}

// --------------------------------------------------------------------------------------------

// TBTDeviceComparison::CompareAphabetically

// --------------------------------------------------------------------------------------------

EXPORT_C TInt TBTDeviceComparison::CompareAphabetically(

	  const TBTDevice& aFirstDevice, const TBTDevice& aSecondDevice) 

	{  	

	// This funtion is used when sorting devicelists, so the tracing has been omnitted

	// in order decreas the amount of trash in the logs.

	TInt rvalue= aFirstDevice.iName.CompareC(aSecondDevice.iName);

	if(rvalue !=0)

		{

		return rvalue;

		}		

	if( aFirstDevice.iAddr <= aSecondDevice.iAddr )

		{

		return  -1;

		}			

	else

		{

		return 1;			

		}		

	}

// --------------------------------------------------------------------------------------------

// TBTDeviceComparison::ReverseCompareAphabetically

// --------------------------------------------------------------------------------------------	

EXPORT_C TInt TBTDeviceComparison::ReverseCompareAphabetically(

        const TBTDevice& aFirstDevice, const TBTDevice& aSecondDevice) 

	{  	

	// This funtion is used when sorting devicelists, so the tracing has been omnitted

	// in order decreas the amount of trash in the logs.

	TInt rvalue= aSecondDevice.iName.CompareC(aFirstDevice.iName);

	if(rvalue !=0)

		{

		return rvalue;

		}		

	if(aFirstDevice.iAddr <= aSecondDevice.iAddr )

		{

		return 1;

		}			

	else

		{

		return -1;			

		}		

	}