1 /*

     2  * Copyright (c) 2010 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  * This file provides the implementation of System Tone Service used

    16  * by the STS Server.

    17  */

    18 //  Include Files  

    19 #include "stssettingsmanager.h"

    20 #include <AudioPreference.h>

    21 #include <MProEngEngine.h>

    22 #include <MProEngNotifyHandler.h>

    23 #include <MProEngProfile.h>

    24 #include <MProEngTones.h>

    25 #include <MProEngToneSettings.h>

    26 #include <ProEngFactory.h>

    27 #include "stsplayersettings.h"

    28 _LIT(KDefaultFile,"z:\\data\\sounds\\digital\\clock.aac");

    29 

    30 // Data types

    31 /** The type of system tones that are supported by this API. */

    32 enum TSettingsType

    33     {

    34     EDefaultAlarm = 0,

    35     EDefaultAlert,

    36     EEmailAlert,

    37     EIncomingCall,

    38     EIncomingCall2,

    39     EIncomingDataCall,

    40     EMessageAlert,

    41     EWarningBeep,

    42     EENDMARKER

    43     };

    44 

    45 /*static*/CStsSettingsManager* CStsSettingsManager::Create()

    46     {

    47     CStsSettingsManager* self = new CStsSettingsManager();

    48 

    49     if (self != 0)

    50         {

    51         bool successful = self->Init();

    52 

    53         if (!successful)

    54             {

    55             delete self;

    56             self = 0;

    57             }

    58         }

    59     return self;

    60     }

    61 

    62 /*static*/void CStsSettingsManager::Delete(

    63         CStsSettingsManager* aStsSettingsManager)

    64     {

    65     delete aStsSettingsManager;

    66     }

    67 

    68 CStsSettingsManager::CStsSettingsManager() :

    69     iEngine(0), iNotifyHandler(0), iPlayerSettings(0)

    70     {

    71     }

    72 

    73 bool CStsSettingsManager::Init()

    74     {

    75     bool successful = false;

    76     TRAPD( err, iEngine = ProEngFactory::NewEngineL() );

    77     if (err == KErrNone)

    78         {

    79         TRAP( err, iNotifyHandler = ProEngFactory::NewNotifyHandlerL() );

    80         }

    81     if (err == KErrNone)

    82         {

    83         TRAP( err, iNotifyHandler->RequestProfileActivationNotificationsL(*this) );

    84         }

    85     if (err == KErrNone)

    86         {

    87         TRAP( err, iNotifyHandler->RequestActiveProfileNotificationsL(*this) );

    88         }

    89     if (err == KErrNone)

    90         {

    91         iPlayerSettings = new CStsPlayerSettings[EENDMARKER];

    92         if (iPlayerSettings != 0)

    93             {

    94             successful = LoadActiveProfileSettings();

    95             }

    96         }

    97     return successful;

    98     }

    99 

   100 CStsSettingsManager::~CStsSettingsManager()

   101     {

   102     if (iEngine != 0)

   103         {

   104         iEngine->Release();

   105         }

   106     if (iNotifyHandler != 0)

   107         {

   108         iNotifyHandler->CancelAll();

   109         delete iNotifyHandler;

   110         }

   111     delete[] iPlayerSettings;

   112     }

   113 

   114 CStsSettingsManager::MPlayerSettings& CStsSettingsManager::GetPlayerSettings(

   115         CSystemToneService::TAlarmType aAlarm)

   116     {

   117     MPlayerSettings* result;

   118     switch (aAlarm)

   119         {

   120         case CSystemToneService::EIncomingCall:

   121             {

   122             result = &iPlayerSettings[EIncomingCall];

   123             break;

   124             }

   125         case CSystemToneService::EIncomingCallLine2:

   126             {

   127             result = &iPlayerSettings[EIncomingCall2];

   128             break;

   129             }

   130         case CSystemToneService::EIncomingDataCall:

   131             {

   132             result = &iPlayerSettings[EIncomingDataCall];

   133             break;

   134             }

   135         default:

   136             {

   137             result = &iPlayerSettings[EDefaultAlarm];

   138             break;

   139             }

   140         }

   141     return *result;

   142     }

   143 

   144 CStsSettingsManager::MPlayerSettings& CStsSettingsManager::GetPlayerSettings(

   145         CSystemToneService::TToneType aTone)

   146     {

   147     MPlayerSettings* result;

   148     switch (aTone)

   149         {

   150         case CSystemToneService::EEmailAlert:

   151             {

   152             result = &iPlayerSettings[EEmailAlert];

   153             break;

   154             }

   155         case CSystemToneService::ESmsAlert:

   156         case CSystemToneService::EMmsAlert:

   157         case CSystemToneService::EChatAlert:

   158             {

   159             result = &iPlayerSettings[EMessageAlert];

   160             break;

   161             }

   162         case CSystemToneService::EWarningBeep:

   163             {

   164             result = &iPlayerSettings[EWarningBeep];

   165             break;

   166             }

   167         default:

   168             {

   169             result = &iPlayerSettings[EDefaultAlert];

   170             break;

   171             }

   172         }

   173     return *result;

   174     }

   175 

   176 void CStsSettingsManager::GetAudioPriorityPref(

   177         CSystemToneService::TAlarmType aAlarm, TUint& aPriority,

   178         TUint& aPreference)

   179     {

   180     switch (aAlarm)

   181         {

   182         case CSystemToneService::EIncomingCall:

   183         case CSystemToneService::EIncomingCallLine2:

   184             {

   185             aPriority = KAudioPriorityRingingTone;

   186             aPreference = KAudioPrefIncomingCall;

   187             break;

   188             }

   189         case CSystemToneService::EIncomingDataCall:

   190             {

   191             aPriority = KAudioPriorityRealOnePlayer;

   192             aPreference = KAudioPrefIncomingDataCall;

   193             break;

   194             }

   195         default:

   196             {

   197             aPriority = KAudioPriorityAlarm;

   198             aPreference = KAudioPrefAlarmClock;

   199             break;

   200             }

   201         }

   202     }

   203 

   204 void CStsSettingsManager::GetAudioPriorityPref(

   205         CSystemToneService::TToneType aTone, TUint& aPriority,

   206         TUint& aPreference)

   207     {

   208     switch (aTone)

   209         {

   210         case CSystemToneService::EEmailAlert:

   211         case CSystemToneService::ESmsAlert:

   212         case CSystemToneService::EMmsAlert:

   213         case CSystemToneService::EChatAlert:

   214             {

   215             aPriority = KAudioPriorityRecvMsg;

   216             aPreference = KAudioPrefNewSMS;

   217             break;

   218             }

   219         case CSystemToneService::EWarningBeep:

   220             {

   221             aPriority = KAudioPriorityWarningTone;

   222             aPreference = KAudioPrefWarning;

   223             break;

   224             }

   225         default:

   226             {

   227             aPriority = KAudioPriorityWarningTone;

   228             aPreference = KAudioPrefDefaultTone;

   229             break;

   230             }

   231         }

   232     }

   233 

   234 bool CStsSettingsManager::LoadActiveProfileSettings()

   235     {

   236     bool successful = false;

   237     MProEngProfile* profile = 0;

   238     TRAPD( err, profile = iEngine->ActiveProfileL() );

   239 

   240     if (err == KErrNone)

   241         {

   242         MProEngTones& tones = profile->ProfileTones();

   243         MProEngToneSettings& settings = profile->ToneSettings();

   244         int volume = 50;

   245         if (profile->IsSilent())

   246             {

   247             volume = 0;

   248             }

   249         int warningVolume = 0;

   250         if (settings.WarningAndGameTones())

   251             {

   252             warningVolume = 50;

   253             }

   254 

   255         iPlayerSettings[EDefaultAlarm].SetFileName(KDefaultFile);

   256         iPlayerSettings[EDefaultAlert].SetFileName(KDefaultFile);

   257         iPlayerSettings[EEmailAlert].SetFileName(tones.EmailAlertTone());

   258         iPlayerSettings[EIncomingCall].SetFileName(tones.RingingTone1());

   259         iPlayerSettings[EIncomingCall2].SetFileName(tones.RingingTone2());

   260         iPlayerSettings[EIncomingDataCall].SetFileName(

   261                 tones.VideoCallRingingTone());

   262         iPlayerSettings[EMessageAlert].SetFileName(tones.MessageAlertTone());

   263         iPlayerSettings[EWarningBeep].SetFileName(KDefaultFile);

   264 

   265         iPlayerSettings[EDefaultAlarm].SetNumberOfRepeats(5);

   266         iPlayerSettings[EDefaultAlert].SetNumberOfRepeats(0);

   267         iPlayerSettings[EEmailAlert].SetNumberOfRepeats(0);

   268         iPlayerSettings[EIncomingCall].SetNumberOfRepeats(100);

   269         iPlayerSettings[EIncomingCall2].SetNumberOfRepeats(100);

   270         iPlayerSettings[EIncomingDataCall].SetNumberOfRepeats(100);

   271         iPlayerSettings[EMessageAlert].SetNumberOfRepeats(0);

   272         iPlayerSettings[EWarningBeep].SetNumberOfRepeats(0);

   273 

   274         iPlayerSettings[EDefaultAlarm].SetRepeatDelay(1000);

   275         iPlayerSettings[EDefaultAlert].SetRepeatDelay(0);

   276         iPlayerSettings[EEmailAlert].SetRepeatDelay(0);

   277         iPlayerSettings[EIncomingCall].SetRepeatDelay(1000);

   278         iPlayerSettings[EIncomingCall2].SetRepeatDelay(1000);

   279         iPlayerSettings[EIncomingDataCall].SetRepeatDelay(1000);

   280         iPlayerSettings[EMessageAlert].SetRepeatDelay(0);

   281         iPlayerSettings[EWarningBeep].SetRepeatDelay(0);

   282 

   283         iPlayerSettings[EDefaultAlarm].SetVolumePercentage(volume);

   284         iPlayerSettings[EDefaultAlert].SetVolumePercentage(volume);

   285         iPlayerSettings[EEmailAlert].SetVolumePercentage(volume);

   286         iPlayerSettings[EIncomingCall].SetVolumePercentage(volume);

   287         iPlayerSettings[EIncomingCall2].SetVolumePercentage(volume);

   288         iPlayerSettings[EIncomingDataCall].SetVolumePercentage(volume);

   289         iPlayerSettings[EMessageAlert].SetVolumePercentage(volume);

   290         iPlayerSettings[EWarningBeep].SetVolumePercentage(warningVolume);

   291 

   292         iPlayerSettings[EDefaultAlarm].SetVolumeRamp(1000000);

   293         iPlayerSettings[EDefaultAlert].SetVolumeRamp(1000);

   294         iPlayerSettings[EEmailAlert].SetVolumeRamp(1000);

   295         iPlayerSettings[EIncomingCall].SetVolumeRamp(1000000);

   296         iPlayerSettings[EIncomingCall2].SetVolumeRamp(1000000);

   297         iPlayerSettings[EIncomingDataCall].SetVolumeRamp(1000000);

   298         iPlayerSettings[EMessageAlert].SetVolumeRamp(1000);

   299         iPlayerSettings[EWarningBeep].SetVolumeRamp(1000);

   300 

   301         profile->Release();

   302         successful = true;

   303         }

   304     return successful;

   305     }

   306 

   307 void CStsSettingsManager::HandleActiveProfileModifiedL()

   308     {

   309     bool successful = LoadActiveProfileSettings();

   310     if (!successful)

   311         {

   312         //TODO: Log error

   313         }

   314     }

   315 

   316 void CStsSettingsManager::HandleProfileActivatedL(TInt /*aProfileId*/)

   317     {

   318     bool successful = LoadActiveProfileSettings();

   319     if (!successful)

   320         {

   321         //TODO: Log error

   322         }

   323     }