34 const TInt KMaxLength=256;

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

   159         delete iRingingTypeObserverAO;

   160         delete iMessageToneObserverAO;

   161         delete iEmailToneObserverAO;

   162         delete iVideoCallObserverAO;

   163         delete iRingingTone1ObserverAO;

   164         delete iRingingTone2ObserverAO;

   165         delete iKeypadToneObserverAO;

   236 

   237 

   238 

   239 TDesC& CGlobalAudioSettingsImpl::MessageAlertTone()

   240     {

   241      return *iGlobalAudioSettingsData.iMessageToneName;

   242     

   243     }

   244 

   245 TBool CGlobalAudioSettingsImpl::IsMessageAlertToneEnabled()

   246     {

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

   248          return EFalse;

   249      else

   250          return ETrue;

   251     

   252     }

   253  TDesC& CGlobalAudioSettingsImpl::EmailAlertTone()

   254     {

   255     return *iGlobalAudioSettingsData.iEmailToneName;

   256         

   257     }

   258  TBool CGlobalAudioSettingsImpl::IsEmailAlertToneEnabled()

   259      {

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

   261           return EFalse;

   262       else

   263           return ETrue;

   264      

   265      }

   266   CGlobalAudioSettings::TGASRingingType CGlobalAudioSettingsImpl::RingingType()

   267     {

   268     CGlobalAudioSettings::TGASRingingType type;

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

   270  

   271       return type;

   272     }

   273   

   274   TDesC& CGlobalAudioSettingsImpl::VideoCallAlertTone()

   275       {

   276       return *iGlobalAudioSettingsData.iVideoCallToneName;

   277       }

   278   TBool CGlobalAudioSettingsImpl::IsVideoCallAlertToneEnabled()

   279       {

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

   281            return EFalse;

   282        else

   283            return ETrue;

   284       

   285       }

   286   TDesC& CGlobalAudioSettingsImpl::RingingAlertTone1()

   287      {

   288      return *iGlobalAudioSettingsData.iRingingTone1Name;

   289      }

   290   TBool CGlobalAudioSettingsImpl::IsRingingAlertTone1Enabled()

   291       {

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

   293            return EFalse;

   294        else

   295            return ETrue;

   296       

   297       }

   298   TDesC& CGlobalAudioSettingsImpl::RingingAlertTone2()

   299      {

   300      return *iGlobalAudioSettingsData.iRingingTone2Name;

   301      }

   302   

   303   TBool CGlobalAudioSettingsImpl::IsRingingAlertTone2Enabled()

   304       {

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

   306            return EFalse;

   307        else

   308            return ETrue;

   309       

   310       }

   311  CGlobalAudioSettings::TGASKeypadVolume CGlobalAudioSettingsImpl::KeyPadToneVolume()

   312      {

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

   314      }

   728 //////////////////////////////////////////////////////////////////////

   729 //  CRingingTypeObserverAO                                                //

   730 //////////////////////////////////////////////////////////////////////

   731 CRingingTypeObserverAO::CRingingTypeObserverAO(

   732                         CGlobalAudioSettings &aGlobalAudioSettings,

   733                         MAudioSettingsObserver& aAudioSettingsObserver,

   734                         TGlobalAudioSettings& aGlobalAudioSettingsData)

   735 :CActive(EPriorityStandard),

   736  iGlobalAudioSettings(aGlobalAudioSettings),

   737  iAudioSettingsObserver(aAudioSettingsObserver),

   738  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

   739     {

   740     CActiveScheduler::Add(this);

   741     }

   742 

   743 CRingingTypeObserverAO::~CRingingTypeObserverAO()

   744     {

   745     Cancel();

   746     iRingingTypeProperty.Close();

   747     }

   748 

   749 CRingingTypeObserverAO* CRingingTypeObserverAO::NewL(

   750                             CGlobalAudioSettings &aGlobalAudioSettings,

   751                             MAudioSettingsObserver& aAudioSettingsObserver,

   752                             TGlobalAudioSettings& aGlobalAudioSettingsData)

   753     {

   754     CRingingTypeObserverAO* self = new (ELeave) CRingingTypeObserverAO(

   755                                             aGlobalAudioSettings,

   756                                             aAudioSettingsObserver, 

   757                                             aGlobalAudioSettingsData);

   758     CleanupStack::PushL(self);

   759     self->ConstructL();

   760     CleanupStack::Pop();

   761     return self;

   762     }

   763 

   764 void CRingingTypeObserverAO::ConstructL()

   765     {

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

   767     TInt value=KErrNone;

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

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

   770     

   771     }

   772     

   773 void CRingingTypeObserverAO::Subscribe()

   774     {

   775     if (!IsActive())

   776         {

   777         SetActive();

   778         

   779         iRingingTypeProperty.Subscribe(iStatus);

   780         }

   781     }

   782 

   783 void CRingingTypeObserverAO::RunL()

   784     {

   785     TInt status(iStatus.Int());

   786 #ifdef PRINT_MESSAGE

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

   788 #endif // PRINT_MESSAGE

   789     if ( status == KErrNone )

   790         {

   791         Subscribe();

   792         TInt value=KErrNone;

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

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

   795         if( status == KErrNone)

   796             {

   797         MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASRingingType;

   798             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

   799             }

   800 #ifdef PRINT_MESSAGE

   801         else

   802             {

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

   804             }

   805 #endif // PRINT_MESSAGE

   806         }

   807     }

   808 

   809 void CRingingTypeObserverAO::DoCancel()

   810     {

   811     iRingingTypeProperty.Cancel();

   812     }

   813 

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

   815     {

   816     return KErrNone;

   817     }

   818 

   819 //////////////////////////////////////////////////////////////////////

   820 //  CMessageToneObserverAO                                                //

   821 //////////////////////////////////////////////////////////////////////

   822 CMessageToneObserverAO::CMessageToneObserverAO(

   823                         CGlobalAudioSettings &aGlobalAudioSettings,

   824                         MAudioSettingsObserver& aAudioSettingsObserver,

   825                         TGlobalAudioSettings& aGlobalAudioSettingsData)

   826 :CActive(EPriorityStandard),

   827  iGlobalAudioSettings(aGlobalAudioSettings),

   828  iAudioSettingsObserver(aAudioSettingsObserver),

   829  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

   830     {

   831     CActiveScheduler::Add(this);

   832     }

   833 

   834 CMessageToneObserverAO::~CMessageToneObserverAO()

   835     {

   836     Cancel();

   837     iMessageToneNameProperty.Close();

   838     if( iGlobalAudioSettingsData.iMessageToneName)

   839         {

   840           delete  iGlobalAudioSettingsData.iMessageToneName;

   841           iGlobalAudioSettingsData.iMessageToneName=NULL;

   842         }

   843     }

   844 

   845 CMessageToneObserverAO* CMessageToneObserverAO::NewL(

   846                             CGlobalAudioSettings &aGlobalAudioSettings,

   847                             MAudioSettingsObserver& aAudioSettingsObserver,

   848                             TGlobalAudioSettings& aGlobalAudioSettingsData)

   849     {

   850     CMessageToneObserverAO* self = new (ELeave) CMessageToneObserverAO(

   851                                             aGlobalAudioSettings,

   852                                             aAudioSettingsObserver, 

   853                                             aGlobalAudioSettingsData);

   854     CleanupStack::PushL(self);

   855     self->ConstructL();

   856     CleanupStack::Pop();

   857     return self;

   858     }

   859 

   860 void CMessageToneObserverAO::ConstructL()

   861     {

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

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

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

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

   866     

   867     }

   868     

   869 void CMessageToneObserverAO::Subscribe()

   870     {

   871     if (!IsActive())

   872         {

   873         SetActive();

   874         

   875         iMessageToneNameProperty.Subscribe(iStatus);

   876         }

   877     }

   878 

   879 void CMessageToneObserverAO::RunL()

   880     {

   881     TInt status(iStatus.Int());

   882 #ifdef PRINT_MESSAGE

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

   884 #endif // PRINT_MESSAGE

   885     if ( status == KErrNone )

   886         {

   887         Subscribe();

   888         delete iGlobalAudioSettingsData.iMessageToneName;

   889         iGlobalAudioSettingsData.iMessageToneName=NULL;

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

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

   892         status = iMessageToneNameProperty.Get(ptr);

   893         if( status == KErrNone)

   894             {

   895             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASMessageToneName;

   896             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

   897             }

   898 #ifdef PRINT_MESSAGE

   899         else

   900             {

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

   902             }

   903 #endif // PRINT_MESSAGE

   904         }

   905     }

   906 

   907 void CMessageToneObserverAO::DoCancel()

   908     {

   909     iMessageToneNameProperty.Cancel();

   910     }

   911 

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

   913     {

   914     return KErrNone;

   915     }

   916 

   917 

   918 /////////////////////////////////////////////////////////////////////

   919 //  CEmailToneObserverAO                                                //

   920 //////////////////////////////////////////////////////////////////////

   921 CEmailToneObserverAO::CEmailToneObserverAO(

   922                         CGlobalAudioSettings &aGlobalAudioSettings,

   923                         MAudioSettingsObserver& aAudioSettingsObserver,

   924                         TGlobalAudioSettings& aGlobalAudioSettingsData)

   925 :CActive(EPriorityStandard),

   926  iGlobalAudioSettings(aGlobalAudioSettings),

   927  iAudioSettingsObserver(aAudioSettingsObserver),

   928  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

   929     {

   930     CActiveScheduler::Add(this);

   931     }

   932 

   933 CEmailToneObserverAO::~CEmailToneObserverAO()

   934     {

   935     Cancel();

   936     iEmailToneNameProperty.Close();

   937     

   938     if(iGlobalAudioSettingsData.iEmailToneName)

   939         {

   940         delete  iGlobalAudioSettingsData.iEmailToneName;

   941         iGlobalAudioSettingsData.iEmailToneName=NULL;

   942         }

   943    

   944     }

   945 

   946 CEmailToneObserverAO* CEmailToneObserverAO::NewL(

   947                             CGlobalAudioSettings &aGlobalAudioSettings,

   948                             MAudioSettingsObserver& aAudioSettingsObserver,

   949                             TGlobalAudioSettings& aGlobalAudioSettingsData)

   950     {

   951     CEmailToneObserverAO* self = new (ELeave) CEmailToneObserverAO(

   952                                             aGlobalAudioSettings,

   953                                             aAudioSettingsObserver, 

   954                                             aGlobalAudioSettingsData);

   955     CleanupStack::PushL(self);

   956     self->ConstructL();

   957     CleanupStack::Pop();

   958     return self;

   959     }

   960 

   961 void CEmailToneObserverAO::ConstructL()

   962     {

   963     

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

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

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

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

   968     

   969     }

   970     

   971 void CEmailToneObserverAO::Subscribe()

   972     {

   973     if (!IsActive())

   974         {

   975         SetActive();

   976         

   977         iEmailToneNameProperty.Subscribe(iStatus);

   978         }

   979     }

   980 

   981 void CEmailToneObserverAO::RunL()

   982     {

   983     TInt status(iStatus.Int());

   984 #ifdef PRINT_MESSAGE

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

   986 #endif // PRINT_MESSAGE

   987     if ( status == KErrNone )

   988         {

   989         Subscribe();

   990         delete iGlobalAudioSettingsData.iEmailToneName;

   991         iGlobalAudioSettingsData.iEmailToneName=NULL;

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

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

   994         status = iEmailToneNameProperty.Get(ptr);

   995         if( status == KErrNone)

   996             {

   997             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASEmailToneName;

   998             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

   999             }

  1000 #ifdef PRINT_MESSAGE

  1001         else

  1002             {

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

  1004             }

  1005 #endif // PRINT_MESSAGE

  1006         }

  1007     }

  1008 

  1009 void CEmailToneObserverAO::DoCancel()

  1010     {

  1011     iEmailToneNameProperty.Cancel();

  1012     }

  1013 

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

  1015     {

  1016     return KErrNone;

  1017     }

  1018 

  1019 

  1020 /////////////////////////////////////////////////////////////////////

  1021 //  CVideoCallToneObserverAO                                                //

  1022 //////////////////////////////////////////////////////////////////////

  1023 CVideoCallToneObserverAO::CVideoCallToneObserverAO(

  1024                         CGlobalAudioSettings &aGlobalAudioSettings,

  1025                         MAudioSettingsObserver& aAudioSettingsObserver,

  1026                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1027 :CActive(EPriorityStandard),

  1028  iGlobalAudioSettings(aGlobalAudioSettings),

  1029  iAudioSettingsObserver(aAudioSettingsObserver),

  1030  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1031     {

  1032     CActiveScheduler::Add(this);

  1033     }

  1034 

  1035 CVideoCallToneObserverAO::~CVideoCallToneObserverAO()

  1036     {

  1037     Cancel();

  1038     iVideoCallToneNameProperty.Close();

  1039     if( iGlobalAudioSettingsData.iVideoCallToneName)

  1040         {

  1041     delete  iGlobalAudioSettingsData.iVideoCallToneName;

  1042     iGlobalAudioSettingsData.iVideoCallToneName=NULL;

  1043         }

  1044      

  1045     

  1046     }

  1047 

  1048 CVideoCallToneObserverAO* CVideoCallToneObserverAO::NewL(

  1049                             CGlobalAudioSettings &aGlobalAudioSettings,

  1050                             MAudioSettingsObserver& aAudioSettingsObserver,

  1051                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1052     {

  1053     CVideoCallToneObserverAO* self = new (ELeave) CVideoCallToneObserverAO(

  1054                                             aGlobalAudioSettings,

  1055                                             aAudioSettingsObserver, 

  1056                                             aGlobalAudioSettingsData);

  1057     CleanupStack::PushL(self);

  1058     self->ConstructL();

  1059     CleanupStack::Pop();

  1060     return self;

  1061     }

  1062 

  1063 void CVideoCallToneObserverAO::ConstructL()

  1064     {

  1065     

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

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

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

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

  1070     

  1071     }

  1072     

  1073 void CVideoCallToneObserverAO::Subscribe()

  1074     {

  1075     if (!IsActive())

  1076         {

  1077         SetActive();

  1078         

  1079         iVideoCallToneNameProperty.Subscribe(iStatus);

  1080         }

  1081     }

  1082 

  1083 void CVideoCallToneObserverAO::RunL()

  1084     {

  1085     TInt status(iStatus.Int());

  1086 #ifdef PRINT_MESSAGE

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

  1088 #endif // PRINT_MESSAGE

  1089     if ( status == KErrNone )

  1090         {

  1091         Subscribe();

  1092         delete iGlobalAudioSettingsData.iVideoCallToneName;

  1093         iGlobalAudioSettingsData.iVideoCallToneName=NULL;

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

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

  1096         status = iVideoCallToneNameProperty.Get(ptr);

  1097         if( status == KErrNone)

  1098             {

  1099         MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASVideoCallToneName;

  1100             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1101             }

  1102 #ifdef PRINT_MESSAGE

  1103         else

  1104             {

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

  1106             }

  1107 #endif // PRINT_MESSAGE

  1108         }

  1109     }

  1110 

  1111 void CVideoCallToneObserverAO::DoCancel()

  1112     {

  1113     iVideoCallToneNameProperty.Cancel();

  1114     }

  1115 

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

  1117     {

  1118     return KErrNone;

  1119     }

  1120 

  1121 /////////////////////////////////////////////////////////////////////

  1122 //  CRingingToneObserverAO                                                //

  1123 //////////////////////////////////////////////////////////////////////

  1124 CRingingTone1ObserverAO::CRingingTone1ObserverAO(

  1125                         CGlobalAudioSettings &aGlobalAudioSettings,

  1126                         MAudioSettingsObserver& aAudioSettingsObserver,

  1127                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1128 :CActive(EPriorityStandard),

  1129  iGlobalAudioSettings(aGlobalAudioSettings),

  1130  iAudioSettingsObserver(aAudioSettingsObserver),

  1131  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1132     {

  1133     CActiveScheduler::Add(this);

  1134     }

  1135 

  1136 CRingingTone1ObserverAO::~CRingingTone1ObserverAO()

  1137     {

  1138     Cancel();

  1139     iRingingTone1NameProperty.Close();

  1140     if( iGlobalAudioSettingsData.iRingingTone1Name)

  1141         {

  1142         delete  iGlobalAudioSettingsData.iRingingTone1Name;

  1143         iGlobalAudioSettingsData.iRingingTone1Name=NULL;

  1144         }

  1145     }

  1146 

  1147 CRingingTone1ObserverAO* CRingingTone1ObserverAO::NewL(

  1148                             CGlobalAudioSettings &aGlobalAudioSettings,

  1149                             MAudioSettingsObserver& aAudioSettingsObserver,

  1150                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1151     {

  1152     CRingingTone1ObserverAO* self = new (ELeave) CRingingTone1ObserverAO(

  1153                                             aGlobalAudioSettings,

  1154                                             aAudioSettingsObserver, 

  1155                                             aGlobalAudioSettingsData);

  1156     CleanupStack::PushL(self);

  1157     self->ConstructL();

  1158     CleanupStack::Pop();

  1159     return self;

  1160     }

  1161 

  1162 void CRingingTone1ObserverAO::ConstructL()

  1163     {

  1164     

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

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

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

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

  1169     

  1170     }

  1171     

  1172 void CRingingTone1ObserverAO::Subscribe()

  1173     {

  1174     if (!IsActive())

  1175         {

  1176         SetActive();

  1177         

  1178         iRingingTone1NameProperty.Subscribe(iStatus);

  1179         }

  1180     }

  1181 

  1182 void CRingingTone1ObserverAO::RunL()

  1183     {

  1184     TInt status(iStatus.Int());

  1185 #ifdef PRINT_MESSAGE

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

  1187 #endif // PRINT_MESSAGE

  1188     if ( status == KErrNone )

  1189         {

  1190         Subscribe();

  1191         delete iGlobalAudioSettingsData.iRingingTone1Name;

  1192         iGlobalAudioSettingsData.iRingingTone1Name=NULL;

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

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

  1195         status = iRingingTone1NameProperty.Get(ptr);

  1196         if( status == KErrNone)

  1197             {

  1198             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASRingingTone1Name;

  1199             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1200             }

  1201 #ifdef PRINT_MESSAGE

  1202         else

  1203             {

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

  1205             }

  1206 #endif // PRINT_MESSAGE

  1207         }

  1208     }

  1209 

  1210 void CRingingTone1ObserverAO::DoCancel()

  1211     {

  1212     iRingingTone1NameProperty.Cancel();

  1213     }

  1214 

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

  1216     {

  1217     return KErrNone;

  1218     }

  1219 

  1220 ////////////////////////////////////////////////////////////////////

  1221 //  CRingingToneObserverAO                                                //

  1222 //////////////////////////////////////////////////////////////////////

  1223 CRingingTone2ObserverAO::CRingingTone2ObserverAO(

  1224                         CGlobalAudioSettings &aGlobalAudioSettings,

  1225                         MAudioSettingsObserver& aAudioSettingsObserver,

  1226                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1227 :CActive(EPriorityStandard),

  1228  iGlobalAudioSettings(aGlobalAudioSettings),

  1229  iAudioSettingsObserver(aAudioSettingsObserver),

  1230  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1231     {

  1232     CActiveScheduler::Add(this);

  1233     }

  1234 

  1235 CRingingTone2ObserverAO::~CRingingTone2ObserverAO()

  1236     {

  1237     Cancel();

  1238     iRingingTone2NameProperty.Close();

  1239     if(iGlobalAudioSettingsData.iRingingTone2Name)

  1240         {

  1241     delete iGlobalAudioSettingsData.iRingingTone2Name;

  1242     iGlobalAudioSettingsData.iRingingTone2Name=NULL;

  1243         }

  1244      

  1245     

  1246     }

  1247 

  1248 CRingingTone2ObserverAO* CRingingTone2ObserverAO::NewL(

  1249                             CGlobalAudioSettings &aGlobalAudioSettings,

  1250                             MAudioSettingsObserver& aAudioSettingsObserver,

  1251                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1252     {

  1253     CRingingTone2ObserverAO* self = new (ELeave) CRingingTone2ObserverAO(

  1254                                             aGlobalAudioSettings,

  1255                                             aAudioSettingsObserver, 

  1256                                             aGlobalAudioSettingsData);

  1257     CleanupStack::PushL(self);

  1258     self->ConstructL();

  1259     CleanupStack::Pop();

  1260     return self;

  1261     }

  1262 

  1263 void CRingingTone2ObserverAO::ConstructL()

  1264     {

  1265     

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

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

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

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

  1270     

  1271     }

  1272     

  1273 void CRingingTone2ObserverAO::Subscribe()

  1274     {

  1275     if (!IsActive())

  1276         {

  1277         SetActive();

  1278         

  1279         iRingingTone2NameProperty.Subscribe(iStatus);

  1280         }

  1281     }

  1282 

  1283 void CRingingTone2ObserverAO::RunL()

  1284     {

  1285     TInt status(iStatus.Int());

  1286 #ifdef PRINT_MESSAGE

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

  1288 #endif // PRINT_MESSAGE

  1289     if ( status == KErrNone )

  1290         {

  1291         Subscribe();

  1292         delete iGlobalAudioSettingsData.iRingingTone2Name;

  1293         iGlobalAudioSettingsData.iRingingTone2Name=NULL;

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

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

  1296         status = iRingingTone2NameProperty.Get(ptr);

  1297         if( status == KErrNone)

  1298             {

  1299         MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASRingingTone2Name;

  1300             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1301             }

  1302 #ifdef PRINT_MESSAGE

  1303         else

  1304             {

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

  1306             }

  1307 #endif // PRINT_MESSAGE

  1308         }

  1309     }

  1310 

  1311 void CRingingTone2ObserverAO::DoCancel()

  1312     {

  1313     iRingingTone2NameProperty.Cancel();

  1314     }

  1315 

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

  1317     {

  1318     return KErrNone;

  1319     }

  1320 

  1321 /////////////////////////////////////////////////////////////////////

  1322 //  CKeypadToneObserverAO                                                //

  1323 //////////////////////////////////////////////////////////////////////

  1324 CKeypadToneObserverAO::CKeypadToneObserverAO(

  1325                         CGlobalAudioSettings &aGlobalAudioSettings,

  1326                         MAudioSettingsObserver& aAudioSettingsObserver,

  1327                         TGlobalAudioSettings& aGlobalAudioSettingsData)

  1328 :CActive(EPriorityStandard),

  1329  iGlobalAudioSettings(aGlobalAudioSettings),

  1330  iAudioSettingsObserver(aAudioSettingsObserver),

  1331  iGlobalAudioSettingsData(aGlobalAudioSettingsData)

  1332     {

  1333     CActiveScheduler::Add(this);

  1334     }

  1335 

  1336 CKeypadToneObserverAO::~CKeypadToneObserverAO()

  1337     {

  1338     Cancel();

  1339     iKeypadToneVolumeProperty.Close();

  1340     }

  1341 

  1342 CKeypadToneObserverAO* CKeypadToneObserverAO::NewL(

  1343                             CGlobalAudioSettings &aGlobalAudioSettings,

  1344                             MAudioSettingsObserver& aAudioSettingsObserver,

  1345                             TGlobalAudioSettings& aGlobalAudioSettingsData)

  1346     {

  1347     CKeypadToneObserverAO* self = new (ELeave) CKeypadToneObserverAO(

  1348                                             aGlobalAudioSettings,

  1349                                             aAudioSettingsObserver, 

  1350                                             aGlobalAudioSettingsData);

  1351     CleanupStack::PushL(self);

  1352     self->ConstructL();

  1353     CleanupStack::Pop();

  1354     return self;

  1355     }

  1356 

  1357 void CKeypadToneObserverAO::ConstructL()

  1358     {

  1359     

  1360     

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

  1362     TInt value=KErrNone;

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

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

  1365     }

  1366     

  1367 void CKeypadToneObserverAO::Subscribe()

  1368     {

  1369     if (!IsActive())

  1370         {

  1371         SetActive();

  1372         

  1373         iKeypadToneVolumeProperty.Subscribe(iStatus);

  1374         }

  1375     }

  1376 

  1377 void CKeypadToneObserverAO::RunL()

  1378     {

  1379     TInt status(iStatus.Int());

  1380 #ifdef PRINT_MESSAGE

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

  1382 #endif // PRINT_MESSAGE

  1383     if ( status == KErrNone )

  1384         {

  1385         Subscribe();

  1386         TInt value=KErrNone;

  1387             status=iKeypadToneVolumeProperty.Get(value);

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

  1389         

  1390         

  1391         if( status == KErrNone)

  1392             {

  1393             MAudioSettingsObserver::TGASEventId id=MAudioSettingsObserver::EGASKeyPadVolume;

  1394             iAudioSettingsObserver.SettingsChanged(iGlobalAudioSettings, id);

  1395             }

  1396 #ifdef PRINT_MESSAGE

  1397         else

  1398             {

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

  1400             }

  1401 #endif // PRINT_MESSAGE

  1402         }

  1403     }

  1404 

  1405 void CKeypadToneObserverAO::DoCancel()

  1406     {

  1407     iKeypadToneVolumeProperty.Cancel();

  1408     }

  1409 

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

  1411     {

  1412     return KErrNone;

  1413     }

  1414