34 const TInt KMaxLength=256;

    35 _LIT( KNoSound, "z:\\resource\\No_Sound.wav" );

   163         delete iRingingTypeObserverAO;

   164         delete iMessageToneObserverAO;

   165         delete iEmailToneObserverAO;

   166         delete iVideoCallObserverAO;

   167         delete iRingingTone1ObserverAO;

   168         delete iRingingTone2ObserverAO;

   169         delete iKeypadToneObserverAO;

   170         delete iSilenceModeObserverAO;

   241 

   242 

   243 

   244 TDesC& CGlobalAudioSettingsImpl::MessageAlertTone()

   245     {

   246      return *iGlobalAudioSettingsData.iMessageToneName;

   247     

   248     }

   249 

   250 TBool CGlobalAudioSettingsImpl::IsMessageAlertToneEnabled()

   251     {

   252      if(iGlobalAudioSettingsData.iMessageToneName->CompareF(KNoSound)==0)

   253          return EFalse;

   254      else

   255          return ETrue;

   256     

   257     }

   258  TDesC& CGlobalAudioSettingsImpl::EmailAlertTone()

   259     {

   260     return *iGlobalAudioSettingsData.iEmailToneName;

   261         

   262     }

   263  TBool CGlobalAudioSettingsImpl::IsEmailAlertToneEnabled()

   264      {

   265       if(iGlobalAudioSettingsData.iEmailToneName->CompareF(KNoSound)==0)

   266           return EFalse;

   267       else

   268           return ETrue;

   269      

   270      }

   271   CGlobalAudioSettings::TGASRingingType CGlobalAudioSettingsImpl::RingingType()

   272     {

   273     CGlobalAudioSettings::TGASRingingType type;

   274    type= ( CGlobalAudioSettings::TGASRingingType)iGlobalAudioSettingsData.iRingingType;

   275  

   276       return type;

   277     }

   278   

   279   TDesC& CGlobalAudioSettingsImpl::VideoCallAlertTone()

   280       {

   281       return *iGlobalAudioSettingsData.iVideoCallToneName;

   282       }

   283   TBool CGlobalAudioSettingsImpl::IsVideoCallAlertToneEnabled()

   284       {

   285        if(iGlobalAudioSettingsData.iVideoCallToneName->CompareF(KNoSound)==0)

   286            return EFalse;

   287        else

   288            return ETrue;

   289       

   290       }

   291   TDesC& CGlobalAudioSettingsImpl::RingingAlertTone1()

   292      {

   293      return *iGlobalAudioSettingsData.iRingingTone1Name;

   294      }

   295   TBool CGlobalAudioSettingsImpl::IsRingingAlertTone1Enabled()

   296       {

   297        if(iGlobalAudioSettingsData.iRingingTone1Name->CompareF(KNoSound)==0)

   298            return EFalse;

   299        else

   300            return ETrue;

   301       

   302       }

   303   TDesC& CGlobalAudioSettingsImpl::RingingAlertTone2()

   304      {

   305      return *iGlobalAudioSettingsData.iRingingTone2Name;

   306      }

   307   

   308   TBool CGlobalAudioSettingsImpl::IsRingingAlertTone2Enabled()

   309       {

   310        if(iGlobalAudioSettingsData.iRingingTone2Name->CompareF(KNoSound)==0)

   311            return EFalse;

   312        else

   313            return ETrue;

   314       

   315       }

   316  CGlobalAudioSettings::TGASKeypadVolume CGlobalAudioSettingsImpl::KeyPadToneVolume()

   317      {

   318      return (CGlobalAudioSettings::TGASKeypadVolume)iGlobalAudioSettingsData.iKeyPadVolume;

   319      }

   320  

   321  TBool CGlobalAudioSettingsImpl::IsSilenceModeEnabled()

   322      {

   323       return iGlobalAudioSettingsData.iSilenceMode;

   324      }

   738 //////////////////////////////////////////////////////////////////////

   739 //  CRingingTypeObserverAO                                                //

   740 //////////////////////////////////////////////////////////////////////

   741 CRingingTypeObserverAO::CRingingTypeObserverAO(

   742                         CGlobalAudioSettings &aGlobalAudioSettings,

   743                         MAudioSettingsObserver& aAudioSettingsObserver,

   744                         TGlobalAudioSettings& aGlobalAudioSettingsData)

   745 :CActive(EPriorityStandard),

   746  iGlobalAudioSettings(aGlobalAudioSettings),

   747  iAudioSettingsObserver(aAudioSettingsObserver),

   748  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

   749     {

   750     CActiveScheduler::Add(this);

   751     }

   752 

   753 CRingingTypeObserverAO::~CRingingTypeObserverAO()

   754     {

   755     Cancel();

   756     iRingingTypeProperty.Close();

   757     }

   758 

   759 CRingingTypeObserverAO* CRingingTypeObserverAO::NewL(

   760                             CGlobalAudioSettings &aGlobalAudioSettings,

   761                             MAudioSettingsObserver& aAudioSettingsObserver,

   762                             TGlobalAudioSettings& aGlobalAudioSettingsData)

   763     {

   764     CRingingTypeObserverAO* self = new (ELeave) CRingingTypeObserverAO(

   765                                             aGlobalAudioSettings,

   766                                             aAudioSettingsObserver, 

   767                                             aGlobalAudioSettingsData);

   768     CleanupStack::PushL(self);

   769     self->ConstructL();

   770     CleanupStack::Pop();

   771     return self;

   772     }

   773 

   774 void CRingingTypeObserverAO::ConstructL()

   775     {

   776     User::LeaveIfError(iRingingTypeProperty.Attach(KGASPSUidGlobalAudioSettings, KGASRingingType));

   777     TInt value=KErrNone;

   778     User::LeaveIfError(iRingingTypeProperty.Get(value));

   779     iGlobalAudioSettingsData.iRingingType=(CGlobalAudioSettings::TGASRingingType)value;

   780     

   781     }

   782     

   783 void CRingingTypeObserverAO::Subscribe()

   784     {

   785     if (!IsActive())

   786         {

   787         SetActive();

   788         

   789         iRingingTypeProperty.Subscribe(iStatus);

   790         }

   791     }

   792 

   793 void CRingingTypeObserverAO::RunL()

   794     {

   795     TInt status(iStatus.Int());

   796 #ifdef PRINT_MESSAGE

   797     RDebug::Print(_L(" CRingingTypeObserverAO::RunL:iStatus[%d]"), status);

   798 #endif // PRINT_MESSAGE

   799     if ( status == KErrNone )

   800         {

   801         Subscribe();

   802         TInt value=KErrNone;

   803         status=(iRingingTypeProperty.Get(value));

   804         iGlobalAudioSettingsData.iRingingType=(CGlobalAudioSettings::TGASRingingType)value;

   805         if( status == KErrNone)

   806             {

   807         MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASRingingType;

   808             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

   809             }

   810 #ifdef PRINT_MESSAGE

   811         else

   812             {

   813             RDebug::Print(_L(" CRingingTypeObserverAO::RunL:Property.Get Error[%d]"), status);

   814             }

   815 #endif // PRINT_MESSAGE

   816         }

   817     }

   818 

   819 void CRingingTypeObserverAO::DoCancel()

   820     {

   821     iRingingTypeProperty.Cancel();

   822     }

   823 

   824 TInt CRingingTypeObserverAO::RunError(TInt /*aError*/)

   825     {

   826     return KErrNone;

   827     }

   828 

   829 //////////////////////////////////////////////////////////////////////

   830 //  CMessageToneObserverAO                                                //

   831 //////////////////////////////////////////////////////////////////////

   832 CMessageToneObserverAO::CMessageToneObserverAO(

   833                         CGlobalAudioSettings &aGlobalAudioSettings,

   834                         MAudioSettingsObserver& aAudioSettingsObserver,

   835                         TGlobalAudioSettings& aGlobalAudioSettingsData)

   836 :CActive(EPriorityStandard),

   837  iGlobalAudioSettings(aGlobalAudioSettings),

   838  iAudioSettingsObserver(aAudioSettingsObserver),

   839  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

   840     {

   841     CActiveScheduler::Add(this);

   842     }

   843 

   844 CMessageToneObserverAO::~CMessageToneObserverAO()

   845     {

   846     Cancel();

   847     iMessageToneNameProperty.Close();

   848     if( iGlobalAudioSettingsData.iMessageToneName)

   849         {

   850           delete  iGlobalAudioSettingsData.iMessageToneName;

   851           iGlobalAudioSettingsData.iMessageToneName=NULL;

   852         }

   853     }

   854 

   855 CMessageToneObserverAO* CMessageToneObserverAO::NewL(

   856                             CGlobalAudioSettings &aGlobalAudioSettings,

   857                             MAudioSettingsObserver& aAudioSettingsObserver,

   858                             TGlobalAudioSettings& aGlobalAudioSettingsData)

   859     {

   860     CMessageToneObserverAO* self = new (ELeave) CMessageToneObserverAO(

   861                                             aGlobalAudioSettings,

   862                                             aAudioSettingsObserver, 

   863                                             aGlobalAudioSettingsData);

   864     CleanupStack::PushL(self);

   865     self->ConstructL();

   866     CleanupStack::Pop();

   867     return self;

   868     }

   869 

   870 void CMessageToneObserverAO::ConstructL()

   871     {

   872     iGlobalAudioSettingsData.iMessageToneName=HBufC::NewL(KMaxLength);

   873     User::LeaveIfError(iMessageToneNameProperty.Attach(KGASPSUidGlobalAudioSettings, KGASMessageToneName));

   874     TPtr16 ptr=iGlobalAudioSettingsData.iMessageToneName->Des();

   875     User::LeaveIfError(iMessageToneNameProperty.Get(ptr));

   876     

   877     }

   878     

   879 void CMessageToneObserverAO::Subscribe()

   880     {

   881     if (!IsActive())

   882         {

   883         SetActive();

   884         

   885         iMessageToneNameProperty.Subscribe(iStatus);

   886         }

   887     }

   888 

   889 void CMessageToneObserverAO::RunL()

   890     {

   891     TInt status(iStatus.Int());

   892 #ifdef PRINT_MESSAGE

   893     RDebug::Print(_L(" CMessageToneObserverAO::RunL:iStatus[%d]"), status);

   894 #endif // PRINT_MESSAGE

   895     if ( status == KErrNone )

   896         {

   897         Subscribe();

   898         delete iGlobalAudioSettingsData.iMessageToneName;

   899         iGlobalAudioSettingsData.iMessageToneName=NULL;

   900         iGlobalAudioSettingsData.iMessageToneName=HBufC::NewL(KMaxLength);

   901         TPtr16 ptr=iGlobalAudioSettingsData.iMessageToneName->Des();

   902         status = iMessageToneNameProperty.Get(ptr);

   903         if( status == KErrNone)

   904             {

   905             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASMessageToneName;

   906             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

   907             }

   908 #ifdef PRINT_MESSAGE

   909         else

   910             {

   911             RDebug::Print(_L(" CMessageToneObserverAO::RunL:Property.Get Error[%d]"), status);

   912             }

   913 #endif // PRINT_MESSAGE

   914         }

   915     }

   916 

   917 void CMessageToneObserverAO::DoCancel()

   918     {

   919     iMessageToneNameProperty.Cancel();

   920     }

   921 

   922 TInt CMessageToneObserverAO::RunError(TInt /*aError*/)

   923     {

   924     return KErrNone;

   925     }

   926 

   927 

   928 /////////////////////////////////////////////////////////////////////

   929 //  CEmailToneObserverAO                                                //

   930 //////////////////////////////////////////////////////////////////////

   931 CEmailToneObserverAO::CEmailToneObserverAO(

   932                         CGlobalAudioSettings &aGlobalAudioSettings,

   933                         MAudioSettingsObserver& aAudioSettingsObserver,

   934                         TGlobalAudioSettings& aGlobalAudioSettingsData)

   935 :CActive(EPriorityStandard),

   936  iGlobalAudioSettings(aGlobalAudioSettings),

   937  iAudioSettingsObserver(aAudioSettingsObserver),

   938  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

   939     {

   940     CActiveScheduler::Add(this);

   941     }

   942 

   943 CEmailToneObserverAO::~CEmailToneObserverAO()

   944     {

   945     Cancel();

   946     iEmailToneNameProperty.Close();

   947     

   948     if(iGlobalAudioSettingsData.iEmailToneName)

   949         {

   950         delete  iGlobalAudioSettingsData.iEmailToneName;

   951         iGlobalAudioSettingsData.iEmailToneName=NULL;

   952         }

   953    

   954     }

   955 

   956 CEmailToneObserverAO* CEmailToneObserverAO::NewL(

   957                             CGlobalAudioSettings &aGlobalAudioSettings,

   958                             MAudioSettingsObserver& aAudioSettingsObserver,

   959                             TGlobalAudioSettings& aGlobalAudioSettingsData)

   960     {

   961     CEmailToneObserverAO* self = new (ELeave) CEmailToneObserverAO(

   962                                             aGlobalAudioSettings,

   963                                             aAudioSettingsObserver, 

   964                                             aGlobalAudioSettingsData);

   965     CleanupStack::PushL(self);

   966     self->ConstructL();

   967     CleanupStack::Pop();

   968     return self;

   969     }

   970 

   971 void CEmailToneObserverAO::ConstructL()

   972     {

   973     

   974     iGlobalAudioSettingsData.iEmailToneName=HBufC::NewL(KMaxLength);

   975     User::LeaveIfError(iEmailToneNameProperty.Attach(KGASPSUidGlobalAudioSettings, KGASEmailToneName));

   976     TPtr16 ptr=iGlobalAudioSettingsData.iEmailToneName->Des();

   977     User::LeaveIfError(iEmailToneNameProperty.Get(ptr));

   978     

   979     }

   980     

   981 void CEmailToneObserverAO::Subscribe()

   982     {

   983     if (!IsActive())

   984         {

   985         SetActive();

   986         

   987         iEmailToneNameProperty.Subscribe(iStatus);

   988         }

   989     }

   990 

   991 void CEmailToneObserverAO::RunL()

   992     {

   993     TInt status(iStatus.Int());

   994 #ifdef PRINT_MESSAGE

   995     RDebug::Print(_L(" CEmailToneObserverAO::RunL:iStatus[%d]"), status);

   996 #endif // PRINT_MESSAGE

   997     if ( status == KErrNone )

   998         {

   999         Subscribe();

  1000         delete iGlobalAudioSettingsData.iEmailToneName;

  1001         iGlobalAudioSettingsData.iEmailToneName=NULL;

  1002         iGlobalAudioSettingsData.iEmailToneName=HBufC::NewL(KMaxLength);

  1003         TPtr16 ptr=iGlobalAudioSettingsData.iEmailToneName->Des();

  1004         status = iEmailToneNameProperty.Get(ptr);

  1005         if( status == KErrNone)

  1006             {

  1007             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASEmailToneName;

  1008             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1009             }

  1010 #ifdef PRINT_MESSAGE

  1011         else

  1012             {

  1013             RDebug::Print(_L(" CEmailToneObserverAO::RunL:Property.Get Error[%d]"), status);

  1014             }

  1015 #endif // PRINT_MESSAGE

  1016         }

  1017     }

  1018 

  1019 void CEmailToneObserverAO::DoCancel()

  1020     {

  1021     iEmailToneNameProperty.Cancel();

  1022     }

  1023 

  1024 TInt CEmailToneObserverAO::RunError(TInt /*aError*/)

  1025     {

  1026     return KErrNone;

  1027     }

  1028 

  1029 

  1030 /////////////////////////////////////////////////////////////////////

  1031 //  CVideoCallToneObserverAO                                                //

  1032 //////////////////////////////////////////////////////////////////////

  1033 CVideoCallToneObserverAO::CVideoCallToneObserverAO(

  1034                         CGlobalAudioSettings &aGlobalAudioSettings,

  1035                         MAudioSettingsObserver& aAudioSettingsObserver,

  1036                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1037 :CActive(EPriorityStandard),

  1038  iGlobalAudioSettings(aGlobalAudioSettings),

  1039  iAudioSettingsObserver(aAudioSettingsObserver),

  1040  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1041     {

  1042     CActiveScheduler::Add(this);

  1043     }

  1044 

  1045 CVideoCallToneObserverAO::~CVideoCallToneObserverAO()

  1046     {

  1047     Cancel();

  1048     iVideoCallToneNameProperty.Close();

  1049     if( iGlobalAudioSettingsData.iVideoCallToneName)

  1050         {

  1051     delete  iGlobalAudioSettingsData.iVideoCallToneName;

  1052     iGlobalAudioSettingsData.iVideoCallToneName=NULL;

  1053         }

  1054      

  1055     

  1056     }

  1057 

  1058 CVideoCallToneObserverAO* CVideoCallToneObserverAO::NewL(

  1059                             CGlobalAudioSettings &aGlobalAudioSettings,

  1060                             MAudioSettingsObserver& aAudioSettingsObserver,

  1061                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1062     {

  1063     CVideoCallToneObserverAO* self = new (ELeave) CVideoCallToneObserverAO(

  1064                                             aGlobalAudioSettings,

  1065                                             aAudioSettingsObserver, 

  1066                                             aGlobalAudioSettingsData);

  1067     CleanupStack::PushL(self);

  1068     self->ConstructL();

  1069     CleanupStack::Pop();

  1070     return self;

  1071     }

  1072 

  1073 void CVideoCallToneObserverAO::ConstructL()

  1074     {

  1075     

  1076     iGlobalAudioSettingsData.iVideoCallToneName=HBufC::NewL(KMaxLength);

  1077     User::LeaveIfError(iVideoCallToneNameProperty.Attach(KGASPSUidGlobalAudioSettings, KGASVideoCallToneName));

  1078     TPtr16 ptr=iGlobalAudioSettingsData.iVideoCallToneName->Des();

  1079     User::LeaveIfError(iVideoCallToneNameProperty.Get(ptr));

  1080     

  1081     }

  1082     

  1083 void CVideoCallToneObserverAO::Subscribe()

  1084     {

  1085     if (!IsActive())

  1086         {

  1087         SetActive();

  1088         

  1089         iVideoCallToneNameProperty.Subscribe(iStatus);

  1090         }

  1091     }

  1092 

  1093 void CVideoCallToneObserverAO::RunL()

  1094     {

  1095     TInt status(iStatus.Int());

  1096 #ifdef PRINT_MESSAGE

  1097     RDebug::Print(_L(" CVideocallToneObserverAO::RunL:iStatus[%d]"), status);

  1098 #endif // PRINT_MESSAGE

  1099     if ( status == KErrNone )

  1100         {

  1101         Subscribe();

  1102         delete iGlobalAudioSettingsData.iVideoCallToneName;

  1103         iGlobalAudioSettingsData.iVideoCallToneName=NULL;

  1104         iGlobalAudioSettingsData.iVideoCallToneName=HBufC::NewL(KMaxLength);

  1105         TPtr16 ptr=iGlobalAudioSettingsData.iVideoCallToneName->Des();

  1106         status = iVideoCallToneNameProperty.Get(ptr);

  1107         if( status == KErrNone)

  1108             {

  1109         MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASVideoCallToneName;

  1110             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1111             }

  1112 #ifdef PRINT_MESSAGE

  1113         else

  1114             {

  1115             RDebug::Print(_L(" CVideoCallToneObserverAO::RunL:Property.Get Error[%d]"), status);

  1116             }

  1117 #endif // PRINT_MESSAGE

  1118         }

  1119     }

  1120 

  1121 void CVideoCallToneObserverAO::DoCancel()

  1122     {

  1123     iVideoCallToneNameProperty.Cancel();

  1124     }

  1125 

  1126 TInt CVideoCallToneObserverAO::RunError(TInt /*aError*/)

  1127     {

  1128     return KErrNone;

  1129     }

  1130 

  1131 /////////////////////////////////////////////////////////////////////

  1132 //  CRingingToneObserverAO                                                //

  1133 //////////////////////////////////////////////////////////////////////

  1134 CRingingTone1ObserverAO::CRingingTone1ObserverAO(

  1135                         CGlobalAudioSettings &aGlobalAudioSettings,

  1136                         MAudioSettingsObserver& aAudioSettingsObserver,

  1137                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1138 :CActive(EPriorityStandard),

  1139  iGlobalAudioSettings(aGlobalAudioSettings),

  1140  iAudioSettingsObserver(aAudioSettingsObserver),

  1141  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1142     {

  1143     CActiveScheduler::Add(this);

  1144     }

  1145 

  1146 CRingingTone1ObserverAO::~CRingingTone1ObserverAO()

  1147     {

  1148     Cancel();

  1149     iRingingTone1NameProperty.Close();

  1150     if( iGlobalAudioSettingsData.iRingingTone1Name)

  1151         {

  1152         delete  iGlobalAudioSettingsData.iRingingTone1Name;

  1153         iGlobalAudioSettingsData.iRingingTone1Name=NULL;

  1154         }

  1155     }

  1156 

  1157 CRingingTone1ObserverAO* CRingingTone1ObserverAO::NewL(

  1158                             CGlobalAudioSettings &aGlobalAudioSettings,

  1159                             MAudioSettingsObserver& aAudioSettingsObserver,

  1160                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1161     {

  1162     CRingingTone1ObserverAO* self = new (ELeave) CRingingTone1ObserverAO(

  1163                                             aGlobalAudioSettings,

  1164                                             aAudioSettingsObserver, 

  1165                                             aGlobalAudioSettingsData);

  1166     CleanupStack::PushL(self);

  1167     self->ConstructL();

  1168     CleanupStack::Pop();

  1169     return self;

  1170     }

  1171 

  1172 void CRingingTone1ObserverAO::ConstructL()

  1173     {

  1174     

  1175     iGlobalAudioSettingsData.iRingingTone1Name=HBufC::NewL(KMaxLength);

  1176     User::LeaveIfError(iRingingTone1NameProperty.Attach(KGASPSUidGlobalAudioSettings, KGASRingingTone1Name));

  1177     TPtr16 ptr=iGlobalAudioSettingsData.iRingingTone1Name->Des();

  1178     User::LeaveIfError(iRingingTone1NameProperty.Get(ptr));

  1179     

  1180     }

  1181     

  1182 void CRingingTone1ObserverAO::Subscribe()

  1183     {

  1184     if (!IsActive())

  1185         {

  1186         SetActive();

  1187         

  1188         iRingingTone1NameProperty.Subscribe(iStatus);

  1189         }

  1190     }

  1191 

  1192 void CRingingTone1ObserverAO::RunL()

  1193     {

  1194     TInt status(iStatus.Int());

  1195 #ifdef PRINT_MESSAGE

  1196     RDebug::Print(_L(" CRingingTone1ObserverAO::RunL:iStatus[%d]"), status);

  1197 #endif // PRINT_MESSAGE

  1198     if ( status == KErrNone )

  1199         {

  1200         Subscribe();

  1201         delete iGlobalAudioSettingsData.iRingingTone1Name;

  1202         iGlobalAudioSettingsData.iRingingTone1Name=NULL;

  1203         iGlobalAudioSettingsData.iRingingTone1Name=HBufC::NewL(KMaxLength);

  1204         TPtr16 ptr=iGlobalAudioSettingsData.iRingingTone1Name->Des();

  1205         status = iRingingTone1NameProperty.Get(ptr);

  1206         if( status == KErrNone)

  1207             {

  1208             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASRingingTone1Name;

  1209             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1210             }

  1211 #ifdef PRINT_MESSAGE

  1212         else

  1213             {

  1214             RDebug::Print(_L(" CRingingToneObserverAO::RunL:Property.Get Error[%d]"), status);

  1215             }

  1216 #endif // PRINT_MESSAGE

  1217         }

  1218     }

  1219 

  1220 void CRingingTone1ObserverAO::DoCancel()

  1221     {

  1222     iRingingTone1NameProperty.Cancel();

  1223     }

  1224 

  1225 TInt CRingingTone1ObserverAO::RunError(TInt /*aError*/)

  1226     {

  1227     return KErrNone;

  1228     }

  1229 

  1230 ////////////////////////////////////////////////////////////////////

  1231 //  CRingingToneObserverAO                                                //

  1232 //////////////////////////////////////////////////////////////////////

  1233 CRingingTone2ObserverAO::CRingingTone2ObserverAO(

  1234                         CGlobalAudioSettings &aGlobalAudioSettings,

  1235                         MAudioSettingsObserver& aAudioSettingsObserver,

  1236                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1237 :CActive(EPriorityStandard),

  1238  iGlobalAudioSettings(aGlobalAudioSettings),

  1239  iAudioSettingsObserver(aAudioSettingsObserver),

  1240  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1241     {

  1242     CActiveScheduler::Add(this);

  1243     }

  1244 

  1245 CRingingTone2ObserverAO::~CRingingTone2ObserverAO()

  1246     {

  1247     Cancel();

  1248     iRingingTone2NameProperty.Close();

  1249     if(iGlobalAudioSettingsData.iRingingTone2Name)

  1250         {

  1251     delete iGlobalAudioSettingsData.iRingingTone2Name;

  1252     iGlobalAudioSettingsData.iRingingTone2Name=NULL;

  1253         }

  1254      

  1255     

  1256     }

  1257 

  1258 CRingingTone2ObserverAO* CRingingTone2ObserverAO::NewL(

  1259                             CGlobalAudioSettings &aGlobalAudioSettings,

  1260                             MAudioSettingsObserver& aAudioSettingsObserver,

  1261                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1262     {

  1263     CRingingTone2ObserverAO* self = new (ELeave) CRingingTone2ObserverAO(

  1264                                             aGlobalAudioSettings,

  1265                                             aAudioSettingsObserver, 

  1266                                             aGlobalAudioSettingsData);

  1267     CleanupStack::PushL(self);

  1268     self->ConstructL();

  1269     CleanupStack::Pop();

  1270     return self;

  1271     }

  1272 

  1273 void CRingingTone2ObserverAO::ConstructL()

  1274     {

  1275     

  1276     iGlobalAudioSettingsData.iRingingTone2Name=HBufC::NewL(KMaxLength);

  1277     User::LeaveIfError(iRingingTone2NameProperty.Attach(KGASPSUidGlobalAudioSettings, KGASRingingTone2Name));

  1278     TPtr16 ptr=iGlobalAudioSettingsData.iRingingTone2Name->Des();

  1279     User::LeaveIfError(iRingingTone2NameProperty.Get(ptr));

  1280     

  1281     }

  1282     

  1283 void CRingingTone2ObserverAO::Subscribe()

  1284     {

  1285     if (!IsActive())

  1286         {

  1287         SetActive();

  1288         

  1289         iRingingTone2NameProperty.Subscribe(iStatus);

  1290         }

  1291     }

  1292 

  1293 void CRingingTone2ObserverAO::RunL()

  1294     {

  1295     TInt status(iStatus.Int());

  1296 #ifdef PRINT_MESSAGE

  1297     RDebug::Print(_L(" CRingingTone2ObserverAO::RunL:iStatus[%d]"), status);

  1298 #endif // PRINT_MESSAGE

  1299     if ( status == KErrNone )

  1300         {

  1301         Subscribe();

  1302         delete iGlobalAudioSettingsData.iRingingTone2Name;

  1303         iGlobalAudioSettingsData.iRingingTone2Name=NULL;

  1304         iGlobalAudioSettingsData.iRingingTone2Name=HBufC::NewL(KMaxLength);

  1305         TPtr16 ptr=iGlobalAudioSettingsData.iRingingTone2Name->Des();

  1306         status = iRingingTone2NameProperty.Get(ptr);

  1307         if( status == KErrNone)

  1308             {

  1309         MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASRingingTone2Name;

  1310             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1311             }

  1312 #ifdef PRINT_MESSAGE

  1313         else

  1314             {

  1315             RDebug::Print(_L(" CRingingToneObserverAO::RunL:Property.Get Error[%d]"), status);

  1316             }

  1317 #endif // PRINT_MESSAGE

  1318         }

  1319     }

  1320 

  1321 void CRingingTone2ObserverAO::DoCancel()

  1322     {

  1323     iRingingTone2NameProperty.Cancel();

  1324     }

  1325 

  1326 TInt CRingingTone2ObserverAO::RunError(TInt /*aError*/)

  1327     {

  1328     return KErrNone;

  1329     }

  1330 

  1331 /////////////////////////////////////////////////////////////////////

  1332 //  CKeypadToneObserverAO                                                //

  1333 //////////////////////////////////////////////////////////////////////

  1334 CKeypadToneObserverAO::CKeypadToneObserverAO(

  1335                         CGlobalAudioSettings &aGlobalAudioSettings,

  1336                         MAudioSettingsObserver& aAudioSettingsObserver,

  1337                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1338 :CActive(EPriorityStandard),

  1339  iGlobalAudioSettings(aGlobalAudioSettings),

  1340  iAudioSettingsObserver(aAudioSettingsObserver),

  1341  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1342     {

  1343     CActiveScheduler::Add(this);

  1344     }

  1345 

  1346 CKeypadToneObserverAO::~CKeypadToneObserverAO()

  1347     {

  1348     Cancel();

  1349     iKeypadToneVolumeProperty.Close();

  1350     }

  1351 

  1352 CKeypadToneObserverAO* CKeypadToneObserverAO::NewL(

  1353                             CGlobalAudioSettings &aGlobalAudioSettings,

  1354                             MAudioSettingsObserver& aAudioSettingsObserver,

  1355                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1356     {

  1357     CKeypadToneObserverAO* self = new (ELeave) CKeypadToneObserverAO(

  1358                                             aGlobalAudioSettings,

  1359                                             aAudioSettingsObserver, 

  1360                                             aGlobalAudioSettingsData);

  1361     CleanupStack::PushL(self);

  1362     self->ConstructL();

  1363     CleanupStack::Pop();

  1364     return self;

  1365     }

  1366 

  1367 void CKeypadToneObserverAO::ConstructL()

  1368     {

  1369     

  1370     

  1371     User::LeaveIfError(iKeypadToneVolumeProperty.Attach(KGASPSUidGlobalAudioSettings, KGASKeypadToneVolume));

  1372     TInt value=KErrNone;

  1373     User::LeaveIfError(iKeypadToneVolumeProperty.Get(value));

  1374     iGlobalAudioSettingsData.iKeyPadVolume=(CGlobalAudioSettings::TGASKeypadVolume)value;

  1375     }

  1376     

  1377 void CKeypadToneObserverAO::Subscribe()

  1378     {

  1379     if (!IsActive())

  1380         {

  1381         SetActive();

  1382         

  1383         iKeypadToneVolumeProperty.Subscribe(iStatus);

  1384         }

  1385     }

  1386 

  1387 void CKeypadToneObserverAO::RunL()

  1388     {

  1389     TInt status(iStatus.Int());

  1390 #ifdef PRINT_MESSAGE

  1391     RDebug::Print(_L(" CKeypadToneObserverAO::RunL:iStatus[%d]"), status);

  1392 #endif // PRINT_MESSAGE

  1393     if ( status == KErrNone )

  1394         {

  1395         Subscribe();

  1396         TInt value=KErrNone;

  1397             status=iKeypadToneVolumeProperty.Get(value);

  1398             iGlobalAudioSettingsData.iKeyPadVolume=(CGlobalAudioSettings::TGASKeypadVolume)value;

  1399         

  1400         

  1401         if( status == KErrNone)

  1402             {

  1403             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASKeyPadVolume;

  1404             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1405             }

  1406 #ifdef PRINT_MESSAGE

  1407         else

  1408             {

  1409             RDebug::Print(_L(" CKeypadToneObserverAO::RunL:Property.Get Error[%d]"), status);

  1410             }

  1411 #endif // PRINT_MESSAGE

  1412         }

  1413     }

  1414 

  1415 void CKeypadToneObserverAO::DoCancel()

  1416     {

  1417     iKeypadToneVolumeProperty.Cancel();

  1418     }

  1419 

  1420 TInt CKeypadToneObserverAO::RunError(TInt /*aError*/)

  1421     {

  1422     return KErrNone;

  1423     }

  1424 

  1425 

  1426 /////////////////////////////////////////////////////////////////////

  1427 //  CSilenceModeObserverAO                                                //

  1428 //////////////////////////////////////////////////////////////////////

  1429 CSilenceModeObserverAO::CSilenceModeObserverAO(

  1430                         CGlobalAudioSettings &aGlobalAudioSettings,

  1431                         MAudioSettingsObserver& aAudioSettingsObserver,

  1432                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1433 :CActive(EPriorityStandard),

  1434  iGlobalAudioSettings(aGlobalAudioSettings),

  1435  iAudioSettingsObserver(aAudioSettingsObserver),

  1436  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1437     {

  1438     CActiveScheduler::Add(this);

  1439     }

  1440 

  1441 CSilenceModeObserverAO::~CSilenceModeObserverAO()

  1442     {

  1443     Cancel();

  1444     iSilenceModeProperty.Close();

  1445     }

  1446 

  1447 CSilenceModeObserverAO* CSilenceModeObserverAO::NewL(

  1448                             CGlobalAudioSettings &aGlobalAudioSettings,

  1449                             MAudioSettingsObserver& aAudioSettingsObserver,

  1450                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1451     {

  1452     CSilenceModeObserverAO* self = new (ELeave) CSilenceModeObserverAO(

  1453                                             aGlobalAudioSettings,

  1454                                             aAudioSettingsObserver, 

  1455                                             aGlobalAudioSettingsData);

  1456     CleanupStack::PushL(self);

  1457     self->ConstructL();

  1458     CleanupStack::Pop();

  1459     return self;

  1460     }

  1461 

  1462 void CSilenceModeObserverAO::ConstructL()

  1463     {

  1464     

  1465     

  1466     User::LeaveIfError(iSilenceModeProperty.Attach(KGASPSUidGlobalAudioSettings, KGASSilenceMode));

  1467    

  1468     User::LeaveIfError(iSilenceModeProperty.Get(iGlobalAudioSettingsData.iSilenceMode));

  1469     RDebug::Printf("in constructL,silence mode %d",iGlobalAudioSettingsData.iSilenceMode);

  1470   

  1471     }

  1472     

  1473 void CSilenceModeObserverAO::Subscribe()

  1474     {

  1475     if (!IsActive())

  1476         {

  1477         SetActive();

  1478         

  1479         iSilenceModeProperty.Subscribe(iStatus);

  1480         }

  1481     }

  1482 

  1483 void CSilenceModeObserverAO::RunL()

  1484     {

  1485     TInt status(iStatus.Int());

  1486 #ifdef PRINT_MESSAGE

  1487     RDebug::Print(_L(" CSilenceModeObserverAO::RunL:iStatus[%d]"), status);

  1488 #endif // PRINT_MESSAGE

  1489     if ( status == KErrNone )

  1490         {

  1491         Subscribe();

  1492        

  1493             status=iSilenceModeProperty.Get(  iGlobalAudioSettingsData.iSilenceMode);

  1494             RDebug::Printf("value of silent mode :%d",iGlobalAudioSettingsData.iSilenceMode);

  1495         

  1496         

  1497         if( status == KErrNone)

  1498             {

  1499             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASSilenceMode;

  1500             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1501             }

  1502 #ifdef PRINT_MESSAGE

  1503         else

  1504             {

  1505             RDebug::Print(_L(" CKeypadToneObserverAO::RunL:Property.Get Error[%d]"), status);

  1506             }

  1507 #endif // PRINT_MESSAGE

  1508         }

  1509     }

  1510 

  1511 void CSilenceModeObserverAO::DoCancel()

  1512     {

  1513     iSilenceModeProperty.Cancel();

  1514     }

  1515 

  1516 TInt CSilenceModeObserverAO::RunError(TInt /*aError*/)

  1517     {

  1518     return KErrNone;

  1519     }

  1520