/*
* 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;			
		}		
	}