/*

* Copyright (c) 2009 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:  Implementation of message settings handling.

*

*/

// INCLUDE FILES

#include "HtiMessagesServicePlugin.h"

#include "HtiMsgSettingsHandler.h"

#include <HtiDispatcherInterface.h>

#include <HTILogging.h>

#include <cmconnectionmethod.h>

#include <cmconnectionmethoddef.h>

#include <cmdestination.h>

#include <cmmanager.h>

#include <csmsaccount.h>

#include <mmssettings.h>

#include <smutset.h>

#include <CentralRepository.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TUid KCRUidSmum = { 0x101F87EF }; // from MessagingInternalCRKeys.h

const TInt KMinSetDefaultSmsCenterLength = 4;

const TInt KMinDeleteSmsCenterLength     = 2;

const TInt KMinSetMmsSettingsLength      = 10;

// set SMS settings has a fixed length

const TInt KSetSmsSettingsLength         = 6;

// message validity times in seconds

const TInt KValidityTimeMax  = 0;

const TInt KValidityTime1h   = 3600;

const TInt KValidityTime6h   = 6 * 3600;

const TInt KValidityTime24h  = 24 * 3600;

const TInt KValidityTime3d   = 3 * 24 * 3600;

const TInt KValidityTime1w   = 7 * 24 * 3600;

// from MmsSettingsDefs.h

const TInt KMmsUniImageSmallWidth = 640;

const TInt KMmsUniImageSmallHeight = 480;

const TInt KMmsUniImageLargeWidth = 1600;

const TInt KMmsUniImageLargeHeight = 1200;

const TInt KApMaxConnNameLength = 30;

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT8( KErrorInvalidParameters, "Invalid command parameters" );

_LIT8( KErrorSetDefaultSmsCenterFailed, "Setting default SMS center failed" );

_LIT8( KErrorDeleteSmsCenterFailed, "SMS center deletion failed" );

_LIT8( KErrorSmsCenterAlreadyExists, "SMS center with given name already exists with different number" );

_LIT8( KErrorSmsCenterNotFound, "SMS center with given name not found" );

_LIT8( KErrorSetSmsSettingsFailed, "Setting SMS service settings failed" );

_LIT8( KErrorSetMmsSettingsFailed, "Setting MMS service settings failed" );

_LIT8( KErrorApNotFound, "Access Point not found" );

_LIT8( KErrorUnrecognizedCommand, "Unrecognized command" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CHtiMsgSettingsHandler::NewL

// Two-phased constructor.

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

CHtiMsgSettingsHandler* CHtiMsgSettingsHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::NewL" );

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

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::NewL" );

    return self;

    }

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

// CHtiMsgSettingsHandler::CHtiMsgSettingsHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

CHtiMsgSettingsHandler::CHtiMsgSettingsHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::CHtiMsgSettingsHandler" );

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::CHtiMsgSettingsHandler" );

    }

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

// CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler

// Destructor.

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

CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler" );

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler" );

    }

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

// CHtiMsgSettingsHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CHtiMsgSettingsHandler::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::ConstructL" );

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::ConstructL" );

    }

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

// CHtiMsgSettingsHandler::SetDispatcher

// Sets the dispatcher pointer.

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

void CHtiMsgSettingsHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::SetDispatcher" );

    iDispatcher = aDispatcher;

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::SetDispatcher" );

    }

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

// CHtiMsgSettingsHandler::ProcessMessageL

// Parses the received message and calls handler functions.

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

void CHtiMsgSettingsHandler::ProcessMessageL( const TDesC8& aMessage,

                                              THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::ProcessMessageL" );

    // Zero length message and command code validity already checked

    // in HtiMessagesServicePlugin.

    if ( aMessage[0] == CHtiMessagesServicePlugin::ESetDefaultSmsCenter )

        {

        if ( aMessage.Length() < 1 + KMinSetDefaultSmsCenterLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleSetDefaultSmsCenterL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorSetDefaultSmsCenterFailed );

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteSmsCenter )

        {

        if ( aMessage.Length() < 1 + KMinDeleteSmsCenterLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleDeleteSmsCenterL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorDeleteSmsCenterFailed );

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::ESetSmsSettings )

        {

        if ( aMessage.Length() != 1 + KSetSmsSettingsLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleSetSmsSettingsL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorSetSmsSettingsFailed );

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::ESetMmsSettings )

        {

        if ( aMessage.Length() < 1 + KMinSetMmsSettingsLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleSetMmsSettingsL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorSetMmsSettingsFailed );

                }

            }

        }

    else

        {

        SendErrorMessageL( KErrArgument, KErrorUnrecognizedCommand );

        }

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::ProcessMessageL" );

    }

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

// CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL

// Creates new default SMS center.

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

void CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL" );

    TBuf<255> name;

    TBuf<255> number;

    TInt dataLength = aData.Length();

    TInt offset = 0;

    TInt fieldLength = aData[offset];

    offset++;

    if ( offset + fieldLength > dataLength )

        {

        HTI_LOG_TEXT( "Invalid length specified for name" );

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    name.Copy( aData.Mid( offset, fieldLength ) );

    offset += fieldLength;

    fieldLength = aData[offset];

    offset++;

    if ( offset + fieldLength > dataLength )

        {

        HTI_LOG_TEXT( "Invalid length specified for number" );

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    number.Copy( aData.Mid( offset, fieldLength ) );

    HTI_LOG_FORMAT( "SMS center name: %S", &name );

    HTI_LOG_FORMAT( "SMS center number: %S", &number );

    HTI_LOG_TEXT( "Loading current settings..." );

    CSmsSettings* smsSettings = CSmsSettings::NewLC();

    CSmsAccount* smsAccount = CSmsAccount::NewLC();

    smsAccount->LoadSettingsL( *smsSettings );

    HTI_LOG_TEXT( "Looping through existing SMS centers..." );

    TInt i = 0;

    for ( i = 0; i < smsSettings->ServiceCenterCount(); i++ )

        {

        CSmsServiceCenter &center = smsSettings->GetServiceCenter( i );

        HTI_LOG_FORMAT( "Found SMS center: %S", &( center.Name() ) );

        if ( center.Name() == name && center.Address() != number )

            {

            HTI_LOG_TEXT( "Error, SMS center with given name already exists" );

            SendErrorMessageL( KErrAlreadyExists, KErrorSmsCenterAlreadyExists );

            CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings

            return;

            }

        else if ( center.Name() == name && center.Address() == number )

            {

            HTI_LOG_TEXT( "The defined SMS center already exists, setting it to default" );

            smsSettings->SetDefaultServiceCenter( i );

            smsAccount->SaveSettingsL( *smsSettings );

            CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings

            SendOkMsgL( KNullDesC8 );

            return;

            }

        }

    HTI_LOG_TEXT( "Creating new default SMS center" );

    smsSettings->AddServiceCenterL( name, number );

    smsSettings->SetDefaultServiceCenter( i );

    smsAccount->SaveSettingsL( *smsSettings );

    CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings

    SendOkMsgL( KNullDesC8 );

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL" );

    }

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

// CHtiMsgSettingsHandler::HandleDeleteSmsCenterL

// Deletes the defined SMS center.

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

void CHtiMsgSettingsHandler::HandleDeleteSmsCenterL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::HandleDeleteSmsCenterL" );

    TBuf<255> name;

    TInt dataLength = aData.Length();

    TInt offset = 0;

    TInt fieldLength = aData[offset];

    offset++;

    if ( offset + fieldLength > dataLength )

        {

        HTI_LOG_TEXT( "Invalid length specified for name" );

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    name.Copy( aData.Mid( offset, fieldLength ) );

    HTI_LOG_FORMAT( "SMS center name: %S", &name );

    HTI_LOG_TEXT( "Loading current settings..." );

    CSmsSettings* smsSettings = CSmsSettings::NewLC();

    CSmsAccount* smsAccount = CSmsAccount::NewLC();

    smsAccount->LoadSettingsL( *smsSettings );

    HTI_LOG_TEXT( "Looping through existing SMS centers..." );

    TInt i = 0;

    for ( i = 0; i < smsSettings->ServiceCenterCount(); i++ )

        {

        CSmsServiceCenter &center = smsSettings->GetServiceCenter( i );

        HTI_LOG_FORMAT( "Found SMS center: %S", &( center.Name() ) );

        if ( center.Name() == name )

            {

            HTI_LOG_TEXT( "Name matches, deleting..." );

            smsSettings->RemoveServiceCenter( i );

            smsAccount->SaveSettingsL( *smsSettings );

            CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings

            SendOkMsgL( KNullDesC8 );

            return;

            }

        }

    CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings

    SendErrorMessageL( KErrNotFound, KErrorSmsCenterNotFound );

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::HandleDeleteSmsCenterL" );

    }

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

// CHtiMsgSettingsHandler::HandleSetSmsSettingsL

// Sets the SMS service settings.

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

void CHtiMsgSettingsHandler::HandleSetSmsSettingsL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::HandleSetSmsSettingsL" );

    // extract values

    TInt offset = 0;

    TInt characterSupport = aData[offset];

    offset++;

    HTI_LOG_FORMAT( "Character support     = %d", characterSupport );

    TBool deliveryReport = aData[offset];

    offset++;

    HTI_LOG_FORMAT( "Delivery report       = %d", deliveryReport );

    TInt validityPeriod = aData[offset];

    offset++;

    HTI_LOG_FORMAT( "Validity period       = %d", validityPeriod );

    TInt messageConversion = aData[offset];

    offset++;

    HTI_LOG_FORMAT( "Message conversion    = %d", messageConversion );

    TInt preferredConnection = aData[offset];

    offset++;

    HTI_LOG_FORMAT( "Preferred connection  = %d", preferredConnection );

    TBool replyViaSameCenter = aData[offset];

    offset++;

    HTI_LOG_FORMAT( "Reply via same center = %d", replyViaSameCenter );

    // Validate values

    if ( characterSupport > 1 || validityPeriod > 5 ||

         messageConversion > 3 || preferredConnection > 1 )

        {

        HTI_LOG_TEXT( "Invalid values found" );

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    HTI_LOG_TEXT( "Loading current settings..." );

    CSmsSettings* smsSettings = CSmsSettings::NewLC();

    CSmsAccount* smsAccount = CSmsAccount::NewLC();

    smsAccount->LoadSettingsL( *smsSettings );

    HTI_LOG_TEXT( "Opening SMS settings Central Repository" );

    CRepository* cenRep = CRepository::NewLC( KCRUidSmum );

    HTI_LOG_TEXT( "Setting character support setting to SMS settings Central Repository" );

    TUint32 KSmumCharSupport = 0x00000008; // from MessagingInternalCRKeys.h

    switch ( characterSupport )

        {

        case 0:

            cenRep->Set( KSmumCharSupport, ECharSetFull );

            break;

        case 1:

            cenRep->Set( KSmumCharSupport, ECharSetReduced );

            break;

        default:

            User::Leave( KErrArgument );

            break;

        }

    CleanupStack::PopAndDestroy( cenRep );

    HTI_LOG_TEXT( "SMS settings Central Repository closed" );

    smsSettings->SetDeliveryReport( deliveryReport );

    switch ( validityPeriod )

        {

        case 0:

            smsSettings->SetValidityPeriod( TTimeIntervalMinutes( 0 ) );

            break;

        case 1:

            smsSettings->SetValidityPeriod(

                TTimeIntervalMinutes( KValidityTime1h / 60 ) );

            break;

        case 2:

            smsSettings->SetValidityPeriod(

                TTimeIntervalMinutes( KValidityTime6h / 60 ) );

            break;

        case 3:

            smsSettings->SetValidityPeriod(

                TTimeIntervalMinutes( KValidityTime24h / 60 ) );

            break;

        case 4:

            smsSettings->SetValidityPeriod(

                TTimeIntervalMinutes( KValidityTime3d / 60 ) );

            break;

        case 5:

            smsSettings->SetValidityPeriod(

                TTimeIntervalMinutes( KValidityTime1w / 60 ) );

            break;

        default:

            User::Leave( KErrArgument );

            break;

        }

    switch ( messageConversion )

        {

        case 0:

            smsSettings->SetMessageConversion( ESmsConvPIDNone );

            break;

        case 1:

            smsSettings->SetMessageConversion( ESmsConvFax );

            break;

        case 2:

            smsSettings->SetMessageConversion( ESmsConvPaging );

            break;

        case 3:

            smsSettings->SetMessageConversion( ESmsConvMail );

            break;

        default:

            User::Leave( KErrArgument );

            break;

        }

    switch ( preferredConnection )

        {

        case 0:

            smsSettings->SetSmsBearer( CSmsSettings::ESmsBearerCircuitPreferred );

            break;

        case 1:

            smsSettings->SetSmsBearer( CSmsSettings::ESmsBearerPacketPreferred );

            break;

        default:

            User::Leave( KErrArgument );

            break;

        }

    smsSettings->SetReplyPath( replyViaSameCenter );

    HTI_LOG_TEXT( "Saving the settings" );

    smsAccount->SaveSettingsL( *smsSettings );

    CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings

    SendOkMsgL( KNullDesC8 );

    HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::HandleSetSmsSettingsL" );

    }