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 "sts.h"

    20 #include "stssettingsmanager.h"

    21 

    22 class CSts::CPlayerNode

    23     {

    24 public:

    25     CPlayerNode(CStsPlayer* aPlayer);

    26     CPlayerNode(CStsPlayer* aPlayer, MStsPlayAlarmObserver& aObserver);

    27     ~CPlayerNode();

    28     bool HasObserver();

    29     CStsPlayer* Player();

    30     MStsPlayAlarmObserver& Observer();

    31 private:

    32     CStsPlayer* iPlayer;

    33     MStsPlayAlarmObserver* iObserver;

    34     };

    35 

    36 CSts::CPlayerNode::CPlayerNode(CStsPlayer* aPlayer) :

    37     iPlayer(aPlayer), iObserver(0)

    38     {

    39     }

    40 

    41 CSts::CPlayerNode::CPlayerNode(CStsPlayer* aPlayer,

    42         MStsPlayAlarmObserver& aObserver) :

    43     iPlayer(aPlayer), iObserver(&aObserver)

    44     {

    45     }

    46 

    47 CSts::CPlayerNode::~CPlayerNode()

    48     {

    49     delete iPlayer;

    50     }

    51 

    52 bool CSts::CPlayerNode::HasObserver()

    53     {

    54     return iObserver != 0;

    55     }

    56 

    57 CStsPlayer* CSts::CPlayerNode::Player()

    58     {

    59     return iPlayer;

    60     }

    61 

    62 MStsPlayAlarmObserver& CSts::CPlayerNode::Observer()

    63     {

    64     return *iObserver;

    65     }

    66 

    67 /*static*/CSts* CSts::Create()

    68     {

    69     CSts* self = new CSts();

    70 

    71     if (self != 0)

    72         {

    73         bool successful = self->Init();

    74 

    75         if (!successful)

    76             {

    77             delete self;

    78             self = 0;

    79             }

    80         }

    81     return self;

    82     }

    83 

    84 /*static*/void CSts::Delete(CSts* aSts)

    85     {

    86     delete aSts;

    87     }

    88 

    89 CSts::CSts() :

    90     iNextContext(1), iSettingsManager(0)

    91     {

    92     }

    93 

    94 bool CSts::Init()

    95     {

    96     bool successful = false;

    97     iSettingsManager = CStsSettingsManager::Create();

    98     if (iSettingsManager != 0)

    99         {

   100         successful = true;

   101         }

   102     return successful;

   103     }

   104 

   105 CSts::~CSts()

   106     {

   107     CleanUpPlayers();

   108     CStsSettingsManager::Delete(iSettingsManager);

   109     }

   110 

   111 void CSts::PlayTone(CSystemToneService::TToneType aTone)

   112     {

   113     CStsPlayer* player = CStsPlayer::Create(*this, *iSettingsManager,

   114             iNextContext, aTone);

   115     if (player != 0)

   116         {

   117         iPlayerMap[iNextContext] = new CPlayerNode(player);

   118         iNextContext++;

   119         if (iNextContext == 0)

   120             iNextContext++;

   121         player->Play();

   122         }

   123     else

   124         {

   125         //TODO: Add trace here

   126         }

   127     }

   128 

   129 void CSts::PlayAlarm(CSystemToneService::TAlarmType aAlarm,

   130         unsigned int& aAlarmContext, MStsPlayAlarmObserver& aObserver)

   131     {

   132     CStsPlayer* player = CStsPlayer::Create(*this, *iSettingsManager,

   133             iNextContext, aAlarm);

   134     if (player != 0)

   135         {

   136         iPlayerMap[iNextContext] = new CPlayerNode(player, aObserver);

   137         aAlarmContext = iNextContext;

   138         iNextContext++;

   139         if (iNextContext == 0)

   140             iNextContext++;

   141         player->Play();

   142         }

   143     else

   144         {

   145         //TODO: Add trace here

   146         aAlarmContext = 0;

   147         }

   148     }

   149 

   150 void CSts::PlayAlarm(CSystemToneService::TToneType aTone,

   151         unsigned int& aAlarmContext, MStsPlayAlarmObserver& aObserver)

   152     {

   153     CStsPlayer* player = CStsPlayer::Create(*this, *iSettingsManager,

   154             iNextContext, aTone);

   155     if (player != 0)

   156         {

   157         iPlayerMap[iNextContext] = new CPlayerNode(player, aObserver);

   158         aAlarmContext = iNextContext;

   159         iNextContext++;

   160         if (iNextContext == 0)

   161             iNextContext++;

   162         player->Play();

   163         }

   164     else

   165         {

   166         //TODO: Add trace here

   167         aAlarmContext = 0;

   168         }

   169     }

   170 

   171 void CSts::StopAlarm(unsigned int aAlarmContext)

   172     {

   173     CPlayerNode* node = iPlayerMap[aAlarmContext];

   174     iPlayerMap.erase(aAlarmContext);

   175     if (node)

   176         {

   177         node->Player()->Stop();

   178         delete node;

   179         }

   180     else

   181         {

   182         //TODO: Add trace here

   183         }

   184     }

   185 

   186 void CSts::CleanUpPlayers()

   187     {

   188     while (!iPlayerMap.empty())

   189         {

   190         //TODO: Add trace here

   191         StopAlarm(iPlayerMap.begin()->first);

   192         }

   193     }

   194 

   195 void CSts::PlayComplete(unsigned int aContext)

   196     {

   197     CPlayerNode* node = iPlayerMap[aContext];

   198     iPlayerMap.erase(aContext);

   199     if (node)

   200         {

   201         CStsPlayer* player = node->Player();

   202         if (node->HasObserver())

   203             {

   204             node->Observer().PlayAlarmComplete(aContext);

   205             }

   206         delete node;

   207         }

   208     else

   209         {

   210         // TODO: log unexpected error

   211         }

   212     }