htiui/HtiServicePlugins/HtiMessagesServicePlugin/src/HtiMsgSettingsHandler.cpp
changeset 0 d6fe6244b863
child 11 454d022d514b
equal deleted inserted replaced
-1:000000000000 0:d6fe6244b863
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  Implementation of message settings handling.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 // INCLUDE FILES
       
    20 #include "HtiMessagesServicePlugin.h"
       
    21 #include "HtiMsgSettingsHandler.h"
       
    22 
       
    23 #include <HtiDispatcherInterface.h>
       
    24 #include <HTILogging.h>
       
    25 
       
    26 #include <cmconnectionmethod.h>
       
    27 #include <cmconnectionmethoddef.h>
       
    28 #include <cmdestination.h>
       
    29 #include <cmmanager.h>
       
    30 
       
    31 #include <csmsaccount.h>
       
    32 #include <mmssettings.h>
       
    33 #include <smutset.h>
       
    34 #include <CentralRepository.h>
       
    35 
       
    36 // EXTERNAL DATA STRUCTURES
       
    37 
       
    38 // EXTERNAL FUNCTION PROTOTYPES
       
    39 
       
    40 // CONSTANTS
       
    41 const TUid KCRUidSmum = { 0x101F87EF }; // from MessagingInternalCRKeys.h
       
    42 
       
    43 const TInt KMinSetDefaultSmsCenterLength = 4;
       
    44 const TInt KMinDeleteSmsCenterLength     = 2;
       
    45 const TInt KMinSetMmsSettingsLength      = 10;
       
    46 
       
    47 // set SMS settings has a fixed length
       
    48 const TInt KSetSmsSettingsLength         = 6;
       
    49 
       
    50 // message validity times in seconds
       
    51 const TInt KValidityTimeMax  = 0;
       
    52 const TInt KValidityTime1h   = 3600;
       
    53 const TInt KValidityTime6h   = 6 * 3600;
       
    54 const TInt KValidityTime24h  = 24 * 3600;
       
    55 const TInt KValidityTime3d   = 3 * 24 * 3600;
       
    56 const TInt KValidityTime1w   = 7 * 24 * 3600;
       
    57 
       
    58 // from MmsSettingsDefs.h
       
    59 const TInt KMmsUniImageSmallWidth = 640;
       
    60 const TInt KMmsUniImageSmallHeight = 480;
       
    61 const TInt KMmsUniImageLargeWidth = 1600;
       
    62 const TInt KMmsUniImageLargeHeight = 1200;
       
    63 
       
    64 const TInt KApMaxConnNameLength = 30;
       
    65 
       
    66 // MACROS
       
    67 
       
    68 // LOCAL CONSTANTS AND MACROS
       
    69 
       
    70 _LIT8( KErrorInvalidParameters, "Invalid command parameters" );
       
    71 _LIT8( KErrorSetDefaultSmsCenterFailed, "Setting default SMS center failed" );
       
    72 _LIT8( KErrorDeleteSmsCenterFailed, "SMS center deletion failed" );
       
    73 _LIT8( KErrorSmsCenterAlreadyExists, "SMS center with given name already exists with different number" );
       
    74 _LIT8( KErrorSmsCenterNotFound, "SMS center with given name not found" );
       
    75 _LIT8( KErrorSetSmsSettingsFailed, "Setting SMS service settings failed" );
       
    76 _LIT8( KErrorSetMmsSettingsFailed, "Setting MMS service settings failed" );
       
    77 _LIT8( KErrorApNotFound, "Access Point not found" );
       
    78 _LIT8( KErrorUnrecognizedCommand, "Unrecognized command" );
       
    79 
       
    80 // MODULE DATA STRUCTURES
       
    81 
       
    82 // LOCAL FUNCTION PROTOTYPES
       
    83 
       
    84 // FORWARD DECLARATIONS
       
    85 
       
    86 // ============================ MEMBER FUNCTIONS ===============================
       
    87 
       
    88 // -----------------------------------------------------------------------------
       
    89 // CHtiMsgSettingsHandler::NewL
       
    90 // Two-phased constructor.
       
    91 // -----------------------------------------------------------------------------
       
    92 CHtiMsgSettingsHandler* CHtiMsgSettingsHandler::NewL()
       
    93     {
       
    94     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::NewL" );
       
    95     CHtiMsgSettingsHandler* self = new (ELeave) CHtiMsgSettingsHandler();
       
    96     CleanupStack::PushL ( self );
       
    97     self->ConstructL();
       
    98     CleanupStack::Pop();
       
    99     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::NewL" );
       
   100     return self;
       
   101     }
       
   102 
       
   103 
       
   104 // ----------------------------------------------------------------------------
       
   105 // CHtiMsgSettingsHandler::CHtiMsgSettingsHandler
       
   106 // C++ default constructor can NOT contain any code, that
       
   107 // might leave.
       
   108 // ----------------------------------------------------------------------------
       
   109 CHtiMsgSettingsHandler::CHtiMsgSettingsHandler()
       
   110     {
       
   111     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::CHtiMsgSettingsHandler" );
       
   112 
       
   113     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::CHtiMsgSettingsHandler" );
       
   114     }
       
   115 
       
   116 
       
   117 // -----------------------------------------------------------------------------
       
   118 // CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler
       
   119 // Destructor.
       
   120 // -----------------------------------------------------------------------------
       
   121 CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler()
       
   122     {
       
   123     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler" );
       
   124 
       
   125     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::~CHtiMsgSettingsHandler" );
       
   126     }
       
   127 
       
   128 
       
   129 // -----------------------------------------------------------------------------
       
   130 // CHtiMsgSettingsHandler::ConstructL
       
   131 // Symbian 2nd phase constructor can leave.
       
   132 // -----------------------------------------------------------------------------
       
   133 void CHtiMsgSettingsHandler::ConstructL()
       
   134     {
       
   135     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::ConstructL" );
       
   136 
       
   137     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::ConstructL" );
       
   138     }
       
   139 
       
   140 
       
   141 // -----------------------------------------------------------------------------
       
   142 // CHtiMsgSettingsHandler::SetDispatcher
       
   143 // Sets the dispatcher pointer.
       
   144 // -----------------------------------------------------------------------------
       
   145 
       
   146 void CHtiMsgSettingsHandler::SetDispatcher( MHtiDispatcher* aDispatcher )
       
   147     {
       
   148     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::SetDispatcher" );
       
   149     iDispatcher = aDispatcher;
       
   150     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::SetDispatcher" );
       
   151     }
       
   152 
       
   153 
       
   154 // -----------------------------------------------------------------------------
       
   155 // CHtiMsgSettingsHandler::ProcessMessageL
       
   156 // Parses the received message and calls handler functions.
       
   157 // -----------------------------------------------------------------------------
       
   158 void CHtiMsgSettingsHandler::ProcessMessageL( const TDesC8& aMessage,
       
   159                                               THtiMessagePriority /*aPriority*/ )
       
   160     {
       
   161     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::ProcessMessageL" );
       
   162 
       
   163     // Zero length message and command code validity already checked
       
   164     // in HtiMessagesServicePlugin.
       
   165 
       
   166     if ( aMessage[0] == CHtiMessagesServicePlugin::ESetDefaultSmsCenter )
       
   167         {
       
   168         if ( aMessage.Length() < 1 + KMinSetDefaultSmsCenterLength )
       
   169             {
       
   170             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   171             }
       
   172         else
       
   173             {
       
   174             TRAPD( err, HandleSetDefaultSmsCenterL(
       
   175                     aMessage.Right( aMessage.Length() - 1 ) ) );
       
   176             if ( err != KErrNone )
       
   177                 {
       
   178                 SendErrorMessageL( err, KErrorSetDefaultSmsCenterFailed );
       
   179                 }
       
   180             }
       
   181         }
       
   182 
       
   183     else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteSmsCenter )
       
   184         {
       
   185         if ( aMessage.Length() < 1 + KMinDeleteSmsCenterLength )
       
   186             {
       
   187             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   188             }
       
   189         else
       
   190             {
       
   191             TRAPD( err, HandleDeleteSmsCenterL(
       
   192                     aMessage.Right( aMessage.Length() - 1 ) ) );
       
   193             if ( err != KErrNone )
       
   194                 {
       
   195                 SendErrorMessageL( err, KErrorDeleteSmsCenterFailed );
       
   196                 }
       
   197             }
       
   198         }
       
   199 
       
   200     else if ( aMessage[0] == CHtiMessagesServicePlugin::ESetSmsSettings )
       
   201         {
       
   202         if ( aMessage.Length() != 1 + KSetSmsSettingsLength )
       
   203             {
       
   204             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   205             }
       
   206         else
       
   207             {
       
   208             TRAPD( err, HandleSetSmsSettingsL(
       
   209                     aMessage.Right( aMessage.Length() - 1 ) ) );
       
   210             if ( err != KErrNone )
       
   211                 {
       
   212                 SendErrorMessageL( err, KErrorSetSmsSettingsFailed );
       
   213                 }
       
   214             }
       
   215         }
       
   216 
       
   217     else if ( aMessage[0] == CHtiMessagesServicePlugin::ESetMmsSettings )
       
   218         {
       
   219         if ( aMessage.Length() < 1 + KMinSetMmsSettingsLength )
       
   220             {
       
   221             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   222             }
       
   223         else
       
   224             {
       
   225             TRAPD( err, HandleSetMmsSettingsL(
       
   226                     aMessage.Right( aMessage.Length() - 1 ) ) );
       
   227             if ( err != KErrNone )
       
   228                 {
       
   229                 SendErrorMessageL( err, KErrorSetMmsSettingsFailed );
       
   230                 }
       
   231             }
       
   232         }
       
   233 
       
   234     else
       
   235         {
       
   236         SendErrorMessageL( KErrArgument, KErrorUnrecognizedCommand );
       
   237         }
       
   238 
       
   239     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::ProcessMessageL" );
       
   240     }
       
   241 
       
   242 
       
   243 // ----------------------------------------------------------------------------
       
   244 // CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL
       
   245 // Creates new default SMS center.
       
   246 // ----------------------------------------------------------------------------
       
   247 void CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL( const TDesC8& aData )
       
   248     {
       
   249     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL" );
       
   250 
       
   251     TBuf<255> name;
       
   252     TBuf<255> number;
       
   253 
       
   254     TInt dataLength = aData.Length();
       
   255     TInt offset = 0;
       
   256     TInt fieldLength = aData[offset];
       
   257     offset++;
       
   258 
       
   259     if ( offset + fieldLength > dataLength )
       
   260         {
       
   261         HTI_LOG_TEXT( "Invalid length specified for name" );
       
   262         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   263         return;
       
   264         }
       
   265     name.Copy( aData.Mid( offset, fieldLength ) );
       
   266     offset += fieldLength;
       
   267     fieldLength = aData[offset];
       
   268     offset++;
       
   269 
       
   270     if ( offset + fieldLength > dataLength )
       
   271         {
       
   272         HTI_LOG_TEXT( "Invalid length specified for number" );
       
   273         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   274         return;
       
   275         }
       
   276     number.Copy( aData.Mid( offset, fieldLength ) );
       
   277 
       
   278     HTI_LOG_FORMAT( "SMS center name: %S", &name );
       
   279     HTI_LOG_FORMAT( "SMS center number: %S", &number );
       
   280 
       
   281     HTI_LOG_TEXT( "Loading current settings..." );
       
   282     CSmsSettings* smsSettings = CSmsSettings::NewLC();
       
   283     CSmsAccount* smsAccount = CSmsAccount::NewLC();
       
   284     smsAccount->LoadSettingsL( *smsSettings );
       
   285 
       
   286     HTI_LOG_TEXT( "Looping through existing SMS centers..." );
       
   287     TInt i = 0;
       
   288     for ( i = 0; i < smsSettings->ServiceCenterCount(); i++ )
       
   289         {
       
   290         CSmsServiceCenter &center = smsSettings->GetServiceCenter( i );
       
   291 
       
   292         HTI_LOG_FORMAT( "Found SMS center: %S", &( center.Name() ) );
       
   293 
       
   294         if ( center.Name() == name && center.Address() != number )
       
   295             {
       
   296             HTI_LOG_TEXT( "Error, SMS center with given name already exists" );
       
   297             SendErrorMessageL( KErrAlreadyExists, KErrorSmsCenterAlreadyExists );
       
   298             CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings
       
   299             return;
       
   300             }
       
   301         else if ( center.Name() == name && center.Address() == number )
       
   302             {
       
   303             HTI_LOG_TEXT( "The defined SMS center already exists, setting it to default" );
       
   304             smsSettings->SetDefaultServiceCenter( i );
       
   305             smsAccount->SaveSettingsL( *smsSettings );
       
   306 
       
   307             CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings
       
   308             SendOkMsgL( KNullDesC8 );
       
   309 
       
   310             return;
       
   311             }
       
   312         }
       
   313 
       
   314     HTI_LOG_TEXT( "Creating new default SMS center" );
       
   315     smsSettings->AddServiceCenterL( name, number );
       
   316     smsSettings->SetDefaultServiceCenter( i );
       
   317     smsAccount->SaveSettingsL( *smsSettings );
       
   318 
       
   319     CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings
       
   320 
       
   321     SendOkMsgL( KNullDesC8 );
       
   322 
       
   323     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::HandleSetDefaultSmsCenterL" );
       
   324     }
       
   325 
       
   326 
       
   327 // ----------------------------------------------------------------------------
       
   328 // CHtiMsgSettingsHandler::HandleDeleteSmsCenterL
       
   329 // Deletes the defined SMS center.
       
   330 // ----------------------------------------------------------------------------
       
   331 void CHtiMsgSettingsHandler::HandleDeleteSmsCenterL( const TDesC8& aData )
       
   332     {
       
   333     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::HandleDeleteSmsCenterL" );
       
   334 
       
   335     TBuf<255> name;
       
   336 
       
   337     TInt dataLength = aData.Length();
       
   338     TInt offset = 0;
       
   339     TInt fieldLength = aData[offset];
       
   340     offset++;
       
   341 
       
   342     if ( offset + fieldLength > dataLength )
       
   343         {
       
   344         HTI_LOG_TEXT( "Invalid length specified for name" );
       
   345         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   346         return;
       
   347         }
       
   348     name.Copy( aData.Mid( offset, fieldLength ) );
       
   349 
       
   350     HTI_LOG_FORMAT( "SMS center name: %S", &name );
       
   351 
       
   352     HTI_LOG_TEXT( "Loading current settings..." );
       
   353     CSmsSettings* smsSettings = CSmsSettings::NewLC();
       
   354     CSmsAccount* smsAccount = CSmsAccount::NewLC();
       
   355     smsAccount->LoadSettingsL( *smsSettings );
       
   356 
       
   357     HTI_LOG_TEXT( "Looping through existing SMS centers..." );
       
   358     TInt i = 0;
       
   359     for ( i = 0; i < smsSettings->ServiceCenterCount(); i++ )
       
   360         {
       
   361         CSmsServiceCenter &center = smsSettings->GetServiceCenter( i );
       
   362 
       
   363         HTI_LOG_FORMAT( "Found SMS center: %S", &( center.Name() ) );
       
   364 
       
   365         if ( center.Name() == name )
       
   366             {
       
   367             HTI_LOG_TEXT( "Name matches, deleting..." );
       
   368             smsSettings->RemoveServiceCenter( i );
       
   369             smsAccount->SaveSettingsL( *smsSettings );
       
   370 
       
   371             CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings
       
   372 
       
   373             SendOkMsgL( KNullDesC8 );
       
   374             return;
       
   375             }
       
   376         }
       
   377 
       
   378     CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings
       
   379 
       
   380     SendErrorMessageL( KErrNotFound, KErrorSmsCenterNotFound );
       
   381 
       
   382     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::HandleDeleteSmsCenterL" );
       
   383     }
       
   384 
       
   385 
       
   386 // ----------------------------------------------------------------------------
       
   387 // CHtiMsgSettingsHandler::HandleSetSmsSettingsL
       
   388 // Sets the SMS service settings.
       
   389 // ----------------------------------------------------------------------------
       
   390 void CHtiMsgSettingsHandler::HandleSetSmsSettingsL( const TDesC8& aData )
       
   391     {
       
   392     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::HandleSetSmsSettingsL" );
       
   393 
       
   394     // extract values
       
   395     TInt offset = 0;
       
   396     TInt characterSupport = aData[offset];
       
   397     offset++;
       
   398     HTI_LOG_FORMAT( "Character support     = %d", characterSupport );
       
   399 
       
   400     TBool deliveryReport = aData[offset];
       
   401     offset++;
       
   402     HTI_LOG_FORMAT( "Delivery report       = %d", deliveryReport );
       
   403 
       
   404     TInt validityPeriod = aData[offset];
       
   405     offset++;
       
   406     HTI_LOG_FORMAT( "Validity period       = %d", validityPeriod );
       
   407 
       
   408     TInt messageConversion = aData[offset];
       
   409     offset++;
       
   410     HTI_LOG_FORMAT( "Message conversion    = %d", messageConversion );
       
   411 
       
   412     TInt preferredConnection = aData[offset];
       
   413     offset++;
       
   414     HTI_LOG_FORMAT( "Preferred connection  = %d", preferredConnection );
       
   415 
       
   416     TBool replyViaSameCenter = aData[offset];
       
   417     offset++;
       
   418     HTI_LOG_FORMAT( "Reply via same center = %d", replyViaSameCenter );
       
   419 
       
   420     // Validate values
       
   421     if ( characterSupport > 1 || validityPeriod > 5 ||
       
   422          messageConversion > 3 || preferredConnection > 1 )
       
   423         {
       
   424         HTI_LOG_TEXT( "Invalid values found" );
       
   425         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   426         return;
       
   427         }
       
   428 
       
   429     HTI_LOG_TEXT( "Loading current settings..." );
       
   430     CSmsSettings* smsSettings = CSmsSettings::NewLC();
       
   431     CSmsAccount* smsAccount = CSmsAccount::NewLC();
       
   432     smsAccount->LoadSettingsL( *smsSettings );
       
   433 
       
   434     HTI_LOG_TEXT( "Opening SMS settings Central Repository" );
       
   435     CRepository* cenRep = CRepository::NewLC( KCRUidSmum );
       
   436     HTI_LOG_TEXT( "Setting character support setting to SMS settings Central Repository" );
       
   437     TUint32 KSmumCharSupport = 0x00000008; // from MessagingInternalCRKeys.h
       
   438     switch ( characterSupport )
       
   439         {
       
   440         case 0:
       
   441             cenRep->Set( KSmumCharSupport, ECharSetFull );
       
   442             break;
       
   443         case 1:
       
   444             cenRep->Set( KSmumCharSupport, ECharSetReduced );
       
   445             break;
       
   446         default:
       
   447             User::Leave( KErrArgument );
       
   448             break;
       
   449         }
       
   450     CleanupStack::PopAndDestroy( cenRep );
       
   451     HTI_LOG_TEXT( "SMS settings Central Repository closed" );
       
   452 
       
   453     smsSettings->SetDeliveryReport( deliveryReport );
       
   454 
       
   455     switch ( validityPeriod )
       
   456         {
       
   457         case 0:
       
   458             smsSettings->SetValidityPeriod( TTimeIntervalMinutes( 0 ) );
       
   459             break;
       
   460         case 1:
       
   461             smsSettings->SetValidityPeriod(
       
   462                 TTimeIntervalMinutes( KValidityTime1h / 60 ) );
       
   463             break;
       
   464         case 2:
       
   465             smsSettings->SetValidityPeriod(
       
   466                 TTimeIntervalMinutes( KValidityTime6h / 60 ) );
       
   467             break;
       
   468         case 3:
       
   469             smsSettings->SetValidityPeriod(
       
   470                 TTimeIntervalMinutes( KValidityTime24h / 60 ) );
       
   471             break;
       
   472         case 4:
       
   473             smsSettings->SetValidityPeriod(
       
   474                 TTimeIntervalMinutes( KValidityTime3d / 60 ) );
       
   475             break;
       
   476         case 5:
       
   477             smsSettings->SetValidityPeriod(
       
   478                 TTimeIntervalMinutes( KValidityTime1w / 60 ) );
       
   479             break;
       
   480         default:
       
   481             User::Leave( KErrArgument );
       
   482             break;
       
   483         }
       
   484 
       
   485     switch ( messageConversion )
       
   486         {
       
   487         case 0:
       
   488             smsSettings->SetMessageConversion( ESmsConvPIDNone );
       
   489             break;
       
   490         case 1:
       
   491             smsSettings->SetMessageConversion( ESmsConvFax );
       
   492             break;
       
   493         case 2:
       
   494             smsSettings->SetMessageConversion( ESmsConvPaging );
       
   495             break;
       
   496         case 3:
       
   497             smsSettings->SetMessageConversion( ESmsConvMail );
       
   498             break;
       
   499         default:
       
   500             User::Leave( KErrArgument );
       
   501             break;
       
   502         }
       
   503 
       
   504     switch ( preferredConnection )
       
   505         {
       
   506         case 0:
       
   507             smsSettings->SetSmsBearer( CSmsSettings::ESmsBearerCircuitPreferred );
       
   508             break;
       
   509         case 1:
       
   510             smsSettings->SetSmsBearer( CSmsSettings::ESmsBearerPacketPreferred );
       
   511             break;
       
   512         default:
       
   513             User::Leave( KErrArgument );
       
   514             break;
       
   515         }
       
   516 
       
   517     smsSettings->SetReplyPath( replyViaSameCenter );
       
   518 
       
   519     HTI_LOG_TEXT( "Saving the settings" );
       
   520     smsAccount->SaveSettingsL( *smsSettings );
       
   521 
       
   522     CleanupStack::PopAndDestroy( 2 ); // smsAccount, smsSettings
       
   523 
       
   524     SendOkMsgL( KNullDesC8 );
       
   525 
       
   526     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::HandleSetSmsSettingsL" );
       
   527     }
       
   528 
       
   529 
       
   530 // ----------------------------------------------------------------------------
       
   531 // CHtiMsgSettingsHandler::HandleSetMmsSettingsL
       
   532 // Sets the MMS service settings.
       
   533 // ----------------------------------------------------------------------------
       
   534 void CHtiMsgSettingsHandler::HandleSetMmsSettingsL( const TDesC8& aData )
       
   535     {
       
   536     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::HandleSetMmsSettingsL" );
       
   537     TInt offset = 0;
       
   538 
       
   539     // Get the access point name and search UID for that AP.
       
   540     TInt apNameLength = aData[offset];
       
   541     offset++;
       
   542     if ( apNameLength > KApMaxConnNameLength ||
       
   543          aData.Length() != ( KMinSetMmsSettingsLength + apNameLength - 1 ) )
       
   544         {
       
   545         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   546         return;
       
   547         }
       
   548 
       
   549     TBuf<KApMaxConnNameLength> apName;
       
   550     apName.Copy( aData.Mid( offset, apNameLength ) );
       
   551     offset += apNameLength;
       
   552     HTI_LOG_FORMAT( "Searching AP with name: %S", &apName );
       
   553     TInt apUid = GetAccessPointUIDL( apName );
       
   554     if ( apUid == KErrNotFound )
       
   555         {
       
   556         SendErrorMessageL( KErrNotFound, KErrorApNotFound );
       
   557         return;
       
   558         }
       
   559 
       
   560     // Extract other values
       
   561     TMmsCreationMode creationMode = ( TMmsCreationMode ) aData[offset];
       
   562     offset++;
       
   563     HTI_LOG_FORMAT( "creation mode      = %d", creationMode );
       
   564 
       
   565     TInt imageSize = aData[offset];
       
   566     offset++;
       
   567     HTI_LOG_FORMAT( "image size         = %d", imageSize );
       
   568 
       
   569     TInt receptionMode = aData[offset];
       
   570     offset++;
       
   571     HTI_LOG_FORMAT( "reception mode     = %d", receptionMode );
       
   572 
       
   573     TBool receiveAnonymous = aData[offset];
       
   574     offset++;
       
   575     HTI_LOG_FORMAT( "receive anonymous  = %d", receiveAnonymous );
       
   576 
       
   577     TBool receiveAdvert = aData[offset];
       
   578     offset++;
       
   579     HTI_LOG_FORMAT( "receive adverts    = %d", receiveAdvert );
       
   580 
       
   581     TBool requestDeliveryReport = aData[offset];
       
   582     offset++;
       
   583     HTI_LOG_FORMAT( "request deliv reps = %d", requestDeliveryReport );
       
   584 
       
   585     TBool sendDeliveryReport = aData[offset];
       
   586     offset++;
       
   587     HTI_LOG_FORMAT( "send deliv reps    = %d", sendDeliveryReport );
       
   588 
       
   589     TInt validityPeriod = aData[offset];
       
   590     offset++;
       
   591     HTI_LOG_FORMAT( "validity period    = %d", validityPeriod );
       
   592 
       
   593     // Validate values
       
   594     if ( creationMode > 2 || imageSize > 2 ||
       
   595          receptionMode > 3 || validityPeriod > 5 ||
       
   596          ( creationMode == 0 && imageSize == 2 ) )
       
   597         {
       
   598         HTI_LOG_TEXT( "Invalid values found" );
       
   599         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   600         return;
       
   601         }
       
   602 
       
   603     // Load current settings
       
   604     CMmsSettings* mmsSettings = CMmsSettings::NewL();
       
   605     CleanupStack::PushL( mmsSettings );
       
   606     mmsSettings->LoadSettingsL();
       
   607     HTI_LOG_TEXT( "Settings loaded - now updating" );
       
   608 
       
   609     // Update the values
       
   610     if ( mmsSettings->AccessPointCount() > 0 )
       
   611         {
       
   612         mmsSettings->DeleteAccessPointL( 0 );
       
   613         }
       
   614     mmsSettings->AddAccessPointL( apUid, 0 );
       
   615 
       
   616     mmsSettings->SetCreationMode( creationMode );
       
   617 
       
   618     switch ( imageSize )
       
   619         {
       
   620         case 0:
       
   621             mmsSettings->SetImageWidth( KMmsUniImageSmallWidth );
       
   622             mmsSettings->SetImageHeight( KMmsUniImageSmallHeight );
       
   623             break;
       
   624         case 1:
       
   625             mmsSettings->SetImageWidth( KMmsUniImageLargeWidth );
       
   626             mmsSettings->SetImageHeight( KMmsUniImageLargeHeight );
       
   627             break;
       
   628         default:
       
   629             User::Leave( KErrArgument );
       
   630             break;
       
   631         }
       
   632 
       
   633     switch ( receptionMode )
       
   634         {
       
   635         case 0:
       
   636             mmsSettings->SetReceivingModeHome( EMmsReceivingAutomatic );
       
   637             mmsSettings->SetReceivingModeForeign( EMmsReceivingAutomatic );
       
   638             break;
       
   639         case 1:
       
   640             mmsSettings->SetReceivingModeHome( EMmsReceivingAutomatic );
       
   641             mmsSettings->SetReceivingModeForeign( EMmsReceivingManual );
       
   642             break;
       
   643         case 2:
       
   644             mmsSettings->SetReceivingModeHome( EMmsReceivingManual );
       
   645             mmsSettings->SetReceivingModeForeign( EMmsReceivingManual );
       
   646             break;
       
   647         case 3:
       
   648             mmsSettings->SetReceivingModeHome( EMmsReceivingReject );
       
   649             mmsSettings->SetReceivingModeForeign( EMmsReceivingReject );
       
   650             break;
       
   651         default:
       
   652             User::Leave( KErrArgument );
       
   653             break;
       
   654         }
       
   655 
       
   656     mmsSettings->SetAcceptAnonymousMessages( receiveAnonymous );
       
   657     mmsSettings->SetAcceptAdvertisementMessages( receiveAdvert );
       
   658 
       
   659     if ( requestDeliveryReport )
       
   660         {
       
   661         mmsSettings->SetDeliveryReportWanted( KMmsYes );
       
   662         }
       
   663     else
       
   664         {
       
   665         mmsSettings->SetDeliveryReportWanted( KMmsNo );
       
   666         }
       
   667 
       
   668     if ( sendDeliveryReport )
       
   669         {
       
   670         mmsSettings->SetDeliveryReportSendingAllowed( KMmsYes );
       
   671         }
       
   672     else
       
   673         {
       
   674         mmsSettings->SetDeliveryReportSendingAllowed( KMmsNo );
       
   675         }
       
   676 
       
   677     switch ( validityPeriod )
       
   678         {
       
   679         case 0:
       
   680             mmsSettings->SetExpiryInterval( KValidityTimeMax );
       
   681             break;
       
   682         case 1:
       
   683             mmsSettings->SetExpiryInterval( KValidityTime1h );
       
   684             break;
       
   685         case 2:
       
   686             mmsSettings->SetExpiryInterval( KValidityTime6h );
       
   687             break;
       
   688         case 3:
       
   689             mmsSettings->SetExpiryInterval( KValidityTime24h );
       
   690             break;
       
   691         case 4:
       
   692             mmsSettings->SetExpiryInterval( KValidityTime3d );
       
   693             break;
       
   694         case 5:
       
   695             mmsSettings->SetExpiryInterval( KValidityTime1w );
       
   696             break;
       
   697         default:
       
   698             User::Leave( KErrArgument );
       
   699             break;
       
   700         }
       
   701 
       
   702     // Check validity of updated settings and save if valid.
       
   703     if ( mmsSettings->ValidateSettings() != KErrNone )
       
   704         {
       
   705         HTI_LOG_TEXT( "Settings not valid - won't save" );
       
   706         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );
       
   707         }
       
   708     else
       
   709         {
       
   710         HTI_LOG_TEXT( "Settings valid - now saving" );
       
   711         mmsSettings->SaveSettingsL();
       
   712         SendOkMsgL( KNullDesC8 );
       
   713         }
       
   714 
       
   715     CleanupStack::PopAndDestroy(); // mmsSettings
       
   716     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::HandleSetMmsSettingsL" );
       
   717     }
       
   718 
       
   719 
       
   720 // ----------------------------------------------------------------------------
       
   721 // CHtiMsgSettingsHandler::GetAccessPointUIDL
       
   722 // Gets the UID of Access Point named by aApName.
       
   723 // Returns KErrNotFound if AP not found.
       
   724 // ----------------------------------------------------------------------------
       
   725 TInt CHtiMsgSettingsHandler::GetAccessPointUIDL( const TDesC& aApName )
       
   726     {
       
   727     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::GetAccessPointUIDL" );
       
   728     TInt uid = KErrNotFound;
       
   729 
       
   730     RCmManager cmManager;
       
   731     cmManager.OpenL();
       
   732     CleanupClosePushL( cmManager );
       
   733 
       
   734     // Search from uncategorised first
       
   735     RArray<TUint32> array = RArray<TUint32>();
       
   736     cmManager.ConnectionMethodL( array );
       
   737     CleanupClosePushL( array );
       
   738     TInt i = 0;
       
   739     while ( i < array.Count() && uid == KErrNotFound )
       
   740         {
       
   741         RCmConnectionMethod cm = cmManager.ConnectionMethodL( array[i] );
       
   742         CleanupClosePushL( cm );
       
   743         HBufC* name = cm.GetStringAttributeL( CMManager::ECmName );
       
   744         HTI_LOG_FORMAT( "Found name: %S", name );
       
   745         CleanupStack::PushL( name );
       
   746         if ( aApName.Compare( *name ) == 0 )
       
   747             {
       
   748             uid = cm.GetIntAttributeL( CMManager::ECmWapId );
       
   749             HTI_LOG_FORMAT( "Match: UID = %d", uid );
       
   750             }
       
   751         CleanupStack::PopAndDestroy(); // name
       
   752         CleanupStack::PopAndDestroy(); // cm
       
   753         i++;
       
   754         }
       
   755     CleanupStack::PopAndDestroy(); // array
       
   756 
       
   757     // If not found from uncategorised, search from all destinations
       
   758     if ( uid == KErrNotFound )
       
   759         {
       
   760         HTI_LOG_TEXT( "Not found from uncategorised" );
       
   761         RArray<TUint32> destIdArray = RArray<TUint32>();
       
   762         cmManager.AllDestinationsL( destIdArray );
       
   763         CleanupClosePushL( destIdArray );
       
   764         i = 0;
       
   765         while ( i < destIdArray.Count() && uid == KErrNotFound )
       
   766             {
       
   767             RCmDestination dest = cmManager.DestinationL( destIdArray[i] );
       
   768             CleanupClosePushL( dest );
       
   769             TInt j = 0;
       
   770             while ( j < dest.ConnectionMethodCount() && uid == KErrNotFound )
       
   771                 {
       
   772                 HBufC* name = dest.ConnectionMethodL( j ).GetStringAttributeL(
       
   773                         CMManager::ECmName );
       
   774                 CleanupStack::PushL( name );
       
   775                 HTI_LOG_FORMAT( "Found name: %S", name );
       
   776                 if ( aApName.Compare( *name ) == 0 )
       
   777                     {
       
   778                     uid = dest.ConnectionMethodL( j ).GetIntAttributeL(
       
   779                             CMManager::ECmWapId );
       
   780                     HTI_LOG_FORMAT( "Match: UID = %d", uid );
       
   781                     }
       
   782                 CleanupStack::PopAndDestroy(); // name
       
   783                 j++;
       
   784                 }
       
   785             CleanupStack::PopAndDestroy(); // dest
       
   786             i++;
       
   787             }
       
   788         CleanupStack::PopAndDestroy(); // destIdArray
       
   789         }
       
   790 
       
   791     CleanupStack::PopAndDestroy(); // cmManager
       
   792 
       
   793     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::GetAccessPointUIDL" );
       
   794     return uid;
       
   795     }
       
   796 
       
   797 
       
   798 // ----------------------------------------------------------------------------
       
   799 // CHtiMsgSettingsHandler::SendOkMsgL
       
   800 // Helper function for sending response messages.
       
   801 // ----------------------------------------------------------------------------
       
   802 void CHtiMsgSettingsHandler::SendOkMsgL( const TDesC8& aData )
       
   803     {
       
   804     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::SendOkMsgL" );
       
   805     User::LeaveIfNull( iDispatcher );
       
   806     HBufC8* temp = HBufC8::NewL( aData.Length() + 1 );
       
   807     TPtr8 response = temp->Des();
       
   808     response.Append( ( TChar ) CHtiMessagesServicePlugin::EResultOk );
       
   809     response.Append( aData );
       
   810     User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(
       
   811         temp, KHtiMessagesServiceUid ) );
       
   812     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::SendOkMsgL" );
       
   813     }
       
   814 
       
   815 
       
   816 // ----------------------------------------------------------------------------
       
   817 // CHtiMsgSettingsHandler::SendErrorMessageL
       
   818 // Helper function for sending error response messages.
       
   819 // ----------------------------------------------------------------------------
       
   820 void CHtiMsgSettingsHandler::SendErrorMessageL( TInt aError, const TDesC8& aDescription )
       
   821     {
       
   822     HTI_LOG_FUNC_IN( "CHtiMsgSettingsHandler::SendErrorMessageL" );
       
   823     User::LeaveIfNull( iDispatcher );
       
   824     User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage(
       
   825         aError, aDescription, KHtiMessagesServiceUid ) );
       
   826     HTI_LOG_FUNC_OUT( "CHtiMsgSettingsHandler::SendErrorMessageL" );
       
   827     }
       
   828 
       
   829 // End of file