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 

    19 #include "sts.h"

    20 

    21 class CSts::CPlayerNode

    22     {

    23 public:

    24     CPlayerNode(CStsPlayer* aPlayer);

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

    26     ~CPlayerNode();

    27     bool HasObserver();

    28     CStsPlayer* Player();

    29     MStsPlayAlarmObserver& Observer();

    30 private:

    31     CStsPlayer* iPlayer;

    32     MStsPlayAlarmObserver* iObserver;

    33     };

    34 

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

    36     iPlayer(aPlayer), iObserver(0)

    37     {

    38     }

    39 

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

    41         MStsPlayAlarmObserver& aObserver) :

    42     iPlayer(aPlayer), iObserver(&aObserver)

    43     {

    44     }

    45 

    46 CSts::CPlayerNode::~CPlayerNode()

    47     {

    48     delete iPlayer;

    49     }

    50 

    51 bool CSts::CPlayerNode::HasObserver()

    52     {

    53     return iObserver != 0;

    54     }

    55 

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

    57     {

    58     return iPlayer;

    59     }

    60 

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

    62     {

    63     return *iObserver;

    64     }

    65 

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

    67     {

    68     CSts* self = new CSts();

    69     if (self != 0)

    70         {

    71         bool successful = self->Init();

    72         if (!successful)

    73             {

    74             delete self;

    75             self = 0;

    76             }

    77         }

    78     return self;

    79     }

    80 

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

    82     {

    83     delete aSts;

    84     }

    85 

    86 CSts::CSts() :

    87     iNextContext(1)

    88     {

    89     }

    90 

    91 bool CSts::Init()

    92     {

    93     return true;

    94     }

    95 

    96 CSts::~CSts()

    97     {

    98     CleanUpPlayers();

    99     }

   100 

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

   102     {

   103     CStsPlayer* player = CStsPlayer::CreateTonePlayer(*this, aTone,

   104             iNextContext);

   105     if (player != 0)

   106         {

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

   108         iNextContext++;

   109         if (iNextContext == 0)

   110             iNextContext++;

   111         player->Play();

   112         }

   113     else

   114         {

   115         //TODO: Add trace here

   116         }

   117     }

   118 

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

   120         unsigned int& aAlarmContext, MStsPlayAlarmObserver& aObserver)

   121     {

   122     CStsPlayer* player = CStsPlayer::CreateAlarmPlayer(*this, aAlarm,

   123             iNextContext);

   124     if (player != 0)

   125         {

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

   127         aAlarmContext = iNextContext;

   128         iNextContext++;

   129         if (iNextContext == 0)

   130             iNextContext++;

   131         player->Play();

   132         }

   133     else

   134         {

   135         //TODO: Add trace here

   136         aAlarmContext = 0;

   137         }

   138     }

   139 

   140 void CSts::StopAlarm(unsigned int aAlarmContext)

   141     {

   142     CPlayerNode* node = iPlayerMap[aAlarmContext];

   143     iPlayerMap.erase(aAlarmContext);

   144     if (node)

   145         {

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

   147         delete node;

   148         }

   149     else

   150         {

   151         //TODO: Add trace here

   152         }

   153     }

   154 

   155 void CSts::CleanUpPlayers()

   156     {

   157         while (!iPlayerMap.empty())

   158             {

   159             //TODO: Add trace here

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

   161             }

   162     }

   163 

   164 void CSts::PlayComplete(unsigned int aContext)

   165     {

   166     CPlayerNode* node = iPlayerMap[aContext];

   167     iPlayerMap.erase(aContext);

   168     if (node)

   169         {

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

   171         if (node->HasObserver())

   172             {

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

   174             }

   175         delete node;

   176         }

   177     else

   178         {

   179         // TODO: log unexpected error

   180         }

   181     }