1 /*

     2 * Copyright (c) 2004 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:

    15 *

    16 */

    17 

    18 

    19 #include "CSipSseTestTls.h"

    20 #include "musavaobserver.h"

    21 #include <sipstrings.h>

    22 #include <SipStrConsts.h>

    23 #include <sipprofileregistry.h>

    24 #include <sipprofileregistryobserver.h>

    25 #include "SipResponseElements.h"

    26 #include "siprequestelements.h"

    27 #include "mussettingskeys.h"

    28 

    29 

    30 TBool CSipSseTestTls::iSipRegisterStatus = EFalse;

    31 

    32 

    33 void CSipSseTestTls::OpenL ()

    34 	{

    35     CSipSseTestTls* self = new (ELeave) CSipSseTestTls();

    36     self->ClientRequest( NULL );

    37     self->ClientResponse( SIPStrings::StringF( SipStrConsts::EEmpty ), NULL );

    38     Dll::SetTls( self );

    39 	

    40     User::LeaveIfError( self->Set ( MusSettingsKeys::KActivation,

    41                             MusSettingsKeys::EAlwaysActive ) );

    42     User::LeaveIfError( self->Set ( MusSettingsKeys::KAuditoryNotification,

    43                             MusSettingsKeys::EAuditoryNotificationOff ) );

    44     User::LeaveIfError( self->Set ( MusSettingsKeys::KPopupNotification,

    45                             MusSettingsKeys::EPopupNotificationOff ) );

    46     User::LeaveIfError( self->Set ( MusSettingsKeys::KPopupNotificationType,

    47                             MusSettingsKeys::ENotificationTypeQueryUser ) );

    48     User::LeaveIfError( self->Set ( MusSettingsKeys::KEdgeDtmSupport,

    49                             MusSettingsKeys::EDtmModeNotAllowed ) );

    50     User::LeaveIfError( self->Set ( MusSettingsKeys::KForceInternetSignaling,

    51                             MusSettingsKeys::EFollowProfileConfiguration ) );

    52     User::LeaveIfError( self->Set ( MusSettingsKeys::KAutoRecord,

    53                             MusSettingsKeys::EAutoRecordOn ) );

    54     User::LeaveIfError( self->Set ( MusSettingsKeys::KSipProfileId,

    55                             0  ) ); //default profile

    56     User::LeaveIfError( self->Set ( MusSettingsKeys::KUiOrientation,

    57                             MusSettingsKeys::EPortrait ) );                    

    58     User::LeaveIfError( self->Set ( MusSettingsKeys::KCapabilityQuery,

    59                             MusSettingsKeys::ENoOptions ) );

    60 

    61 	}

    62 

    63 void CSipSseTestTls::Close ()

    64 	{

    65 	CSipSseTestTls* self = Storage();

    66     delete self;

    67     Dll::SetTls( NULL );

    68 	}

    69 

    70 	

    71 CSipSseTestTls* CSipSseTestTls::Storage()

    72 	{

    73 	return static_cast<CSipSseTestTls*>(Dll::Tls());

    74 	}

    75 

    76 CSipSseTestTls::CSipSseTestTls()

    77     : iError( KErrNone )

    78 	{

    79 	}

    80 	

    81 CSipSseTestTls::~CSipSseTestTls()

    82 	{

    83    	delete iClientRequest;

    84 	delete iClientResponse;

    85 	iKeys.Reset();

    86     iValues.Reset();

    87 	}

    88     

    89 void CSipSseTestTls::Reset()

    90     {

    91     Storage()->Set ( MusSettingsKeys::KActivation,

    92         MusSettingsKeys::EAlwaysActive );

    93     Storage()->Set ( MusSettingsKeys::KAuditoryNotification,

    94         MusSettingsKeys::EAuditoryNotificationOff );

    95     Storage()->Set ( MusSettingsKeys::KPopupNotification,

    96         MusSettingsKeys::EPopupNotificationOff );

    97     Storage()->Set ( MusSettingsKeys::KPopupNotificationType,

    98         MusSettingsKeys::ENotificationTypeQueryUser );

    99     Storage()->Set ( MusSettingsKeys::KEdgeDtmSupport,

   100         MusSettingsKeys::EDtmModeNotAllowed );

   101     Storage()->Set ( MusSettingsKeys::KForceInternetSignaling,

   102         MusSettingsKeys::EFollowProfileConfiguration );

   103     Storage()->Set ( MusSettingsKeys::KAutoRecord,

   104         MusSettingsKeys::EAutoRecordOn );

   105     Storage()->Set ( MusSettingsKeys::KSipProfileId,

   106         0  ); //default profile

   107     Storage()->Set ( MusSettingsKeys::KUiOrientation,

   108         MusSettingsKeys::EPortrait );

   109     Storage()->Set ( MusSettingsKeys::KCapabilityQuery,

   110         MusSettingsKeys::ENoOptions );

   111 

   112     iRegistryBehavior = 0;

   113     iProfileBehavior = 0;

   114     iConnectionBehavior = 0;

   115     }

   116     

   117 TInt CSipSseTestTls::Set(TUint32 aKey, TInt aValue)

   118     {

   119     // Setting of any other value

   120     for ( TInt i = 0; i < iKeys.Count(); ++i )

   121         {

   122         if ( iKeys[i] == aKey )

   123             {

   124             iValues[i] = aValue;

   125             return KErrNone;

   126             }

   127         }

   128     

   129     // No wise error handling implemented

   130     TInt error = iKeys.Append( aKey );

   131     if ( error == KErrNone )

   132         {

   133         error = iValues.Append( aValue );

   134         }

   135         

   136     return error;

   137     }

   138     

   139 TInt CSipSseTestTls::Get(TUint32 aKey, TInt& aValue)

   140     {

   141     for ( TInt i = 0; i < iKeys.Count(); ++i )

   142         {

   143         if ( iKeys[i] == aKey )

   144             {

   145             aValue = iValues[i];

   146             return KErrNone;

   147             }

   148         }

   149 

   150     return KErrNotFound;

   151     }

   152     

   153 void CSipSseTestTls::SetError( TInt aError )

   154     {

   155     iError = aError;

   156     }

   157 

   158 TInt CSipSseTestTls::Error() const

   159     {

   160     return iError;

   161     }

   162 

   163 

   164 void CSipSseTestTls::Clear()

   165     {

   166     iError = KErrNone;

   167     //iState = MMusAvaObserver::EMusAvaNotStateDefined; 

   168     iStatus = MMusAvaObserver::EMusAvaStatusNotExecuted;

   169     iName = MMusAvaObserver::EMusAvaNameNotDefined;

   170     iConnectionCount = 0;

   171     iSubConnectionCount = 0;

   172     iUintAttributeValue = 0;

   173     iConnectionId = 0; 

   174     iIntAttributeValue = 0;

   175     iRequestStatus = KErrNone;

   176     iPhoneRegistrationStatus = RMobilePhone::ERegistrationUnknown;

   177     iPhoneRegistrationStatusPointer = NULL;

   178     iPhoneNetworkMode = RMobilePhone::ENetworkModeUnknown;

   179     ClientRequest( NULL );

   180     //iResponseToRequest = SIPStrings::StringF( SipStrConsts::EEmpty );

   181     }

   182 

   183 void CSipSseTestTls::SetRequestStatus( TRequestStatus& aStatus ) 

   184     {

   185     iRequestStatus = aStatus;

   186     }

   187 

   188 

   189 TBool CSipSseTestTls::RegisterStatus() 

   190     {

   191     

   192     return iSipRegisterStatus; 

   193     }

   194 void CSipSseTestTls::SetRegisterStatus( TBool aStatus )

   195     {

   196     iSipRegisterStatus = aStatus;

   197     }

   198 TBool CSipSseTestTls::RegisterSent() 

   199     {

   200     if ( !iSipRegisterStatus )

   201         {

   202         iSipRegisterStatus = ETrue;

   203         }

   204     return iSipRegisterStatus; 

   205     }

   206     

   207 void CSipSseTestTls::StoreRegistry( MSIPProfileRegistryObserver& aRegistry )

   208     {

   209     iRegistry = &aRegistry;

   210     }

   211     

   212 void CSipSseTestTls::ProfileRegistryEventOccurred(TUint32 aProfileId, MSIPProfileRegistryObserver::TEvent aEvent )

   213     {

   214     iRegistry->ProfileRegistryEventOccurred( aProfileId,aEvent );

   215     }

   216 /*	

   217 void CSipSseTestTls::AvailabilityState( MMusAvaObserver::TAvailabilityState aState, 

   218                          MMusAvaObserver::TAvailabilityStatus aStatus,

   219                          MMusAvaObserver::TAvailabilityName aName )

   220 	{

   221     iState = aState; 

   222     iStatus = aStatus;

   223     iName = aName;                      	

   224     }

   225   */  

   226 void CSipSseTestTls::SetState( MMusAvaObserver::TAvailabilityStatus aStatus )

   227     {

   228     iStatus = aStatus;

   229     }

   230     

   231 TInt CSipSseTestTls::ConnectionCount()

   232     {

   233     return iConnectionCount;

   234     }

   235 void CSipSseTestTls::SetConnectionCount( TInt aCount )

   236     {

   237     iConnectionCount = aCount;

   238     }

   239     

   240 void CSipSseTestTls::ConnectionInfo( const TUint& aIndex, 

   241                      TUint& aConnectionId, 

   242                      TUint& aSubConnectionCount )

   243     {

   244     aConnectionId = iConnectionId;

   245     aSubConnectionCount = iSubConnectionCount;

   246     }

   247                      

   248 void CSipSseTestTls::SetConnectionInfo( TUint aConnectionId, 

   249                                         TUint aSubConnectionCount )

   250     {

   251     iConnectionId = aConnectionId;

   252     iSubConnectionCount = aSubConnectionCount;

   253     }

   254     

   255 void CSipSseTestTls::GetUintAttribute(  const TUint aConnectionId, 

   256                                         const TUint aSubConnectionId, 

   257                                         const TUint aAttribute, 

   258                                         TUint& aValue, 

   259                                         TRequestStatus& aStatus )

   260     {

   261     aValue = iUintAttributeValue;

   262     aStatus = iRequestStatus;

   263     }

   264 void CSipSseTestTls::SetUintAttribute(  TUint aConnectionId, 

   265                                         TUint aSubConnectionId, 

   266                                         TUint aAttribute, 

   267                                         TUint aValue, 

   268                                         TRequestStatus& aStatus )

   269     {

   270     iUintAttributeValue = aValue;

   271     iRequestStatus =  aStatus;

   272     }

   273     

   274 void CSipSseTestTls::GetIntAttribute(  const TUint aConnectionId, 

   275                                         const TUint aSubConnectionId, 

   276                                         const TUint aAttribute, 

   277                                         TInt& aValue, 

   278                                         TRequestStatus& aStatus )

   279     {

   280     aValue = iIntAttributeValue;

   281     aStatus = iRequestStatus;

   282     }

   283 void CSipSseTestTls::SetIntAttribute(  TUint aConnectionId, 

   284                                         TUint aSubConnectionId, 

   285                                         TUint aAttribute, 

   286                                         TInt aValue, 

   287                                         TRequestStatus& aStatus )

   288     {

   289     iIntAttributeValue = aValue;

   290     iRequestStatus =  aStatus;

   291     }

   292     

   293 void CSipSseTestTls::SetEvent(const CConnMonEventBase& aConnMonEvent)

   294     {

   295     iConnMonEventBase = const_cast<CConnMonEventBase*>( &aConnMonEvent );

   296     }

   297     

   298 const CConnMonEventBase& CSipSseTestTls::Event()

   299     {

   300     return *iConnMonEventBase;

   301     }

   302     

   303 void CSipSseTestTls::SetRegistrationStatus( RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus )

   304     {

   305     iPhoneRegistrationStatus = aRegStatus;

   306     }

   307     

   308 void CSipSseTestTls::SetRegistrationStatus( RMobilePhone::TMobilePhoneRegistrationStatus* aRegStatus )

   309     {

   310     iPhoneRegistrationStatusPointer = aRegStatus;

   311     }

   312 

   313 void CSipSseTestTls::RegistrationStatus( RMobilePhone::TMobilePhoneRegistrationStatus& aReqStatus )

   314     {

   315     aReqStatus = iPhoneRegistrationStatus;

   316     }

   317     

   318 void CSipSseTestTls::SetPhoneNetworkModeStatus( RMobilePhone::TMobilePhoneNetworkMode aStatus )

   319     {

   320     iPhoneNetworkMode = aStatus;

   321     }

   322     

   323 RMobilePhone::TMobilePhoneNetworkMode& CSipSseTestTls::PhoneNetworkModeStatus()

   324     {

   325     return iPhoneNetworkMode;

   326     }

   327  

   328  void CSipSseTestTls::ClientRequest( CSIPRequestElements* aRequest )

   329     {

   330     delete iClientRequest;

   331     iClientRequest = aRequest;

   332     }

   333 	

   334 void CSipSseTestTls::ClientResponse( RStringF aMethod, CSIPResponseElements* aResponse )

   335     {

   336     iResponseToRequest = aMethod;

   337     delete iClientResponse;

   338     iClientResponse = aResponse;

   339     }

   340 

   341 //end of file