mmserv/sts/stsserver/src/stsserversession.cpp
changeset 16 43d09473c595
parent 14 80975da52420
child 20 b67dd1fc57c5
equal deleted inserted replaced
14:80975da52420 16:43d09473c595
    27     {
    27     {
    28     }
    28     }
    29 
    29 
    30 CStsServerSession::~CStsServerSession()
    30 CStsServerSession::~CStsServerSession()
    31     {
    31     {
       
    32     TStsCallBack callBack;
       
    33     callBack.callBackType = EStsShutdown;
       
    34     iMsgQueue.SendBlocking(callBack);
    32     iServer.DropSession(this);
    35     iServer.DropSession(this);
       
    36     iMsgQueue.Close();
    33     }
    37     }
    34 
    38 
    35 void CStsServerSession::CreateL()
    39 void CStsServerSession::CreateL()
    36     {
    40     {
    37     iServer.AddSession(this);
    41     iServer.AddSession(this);
    39 
    43 
    40 void CStsServerSession::ServiceL(const RMessage2& aMessage)
    44 void CStsServerSession::ServiceL(const RMessage2& aMessage)
    41     {
    45     {
    42     switch (aMessage.Function())
    46     switch (aMessage.Function())
    43         {
    47         {
       
    48         case StsMsg_RegisterMsgQueue:
       
    49             DoRegisterMsgQueueL(aMessage);
       
    50             break;
    44         case StsMsg_PlayTone:
    51         case StsMsg_PlayTone:
    45             DoPlayToneL(aMessage);
    52             DoPlayToneL(aMessage);
    46             break;
    53             break;
    47         case StsMsg_StopTone:
    54         case StsMsg_PlayAlarm:
    48             DoStopToneL(aMessage);
    55             DoPlayAlarmL(aMessage);
       
    56             break;
       
    57         case StsMsg_StopAlarm:
       
    58             DoStopAlarmL(aMessage);
    49             break;
    59             break;
    50         default:
    60         default:
    51             break;
    61             break;
    52         }
    62         }
    53     }
    63     }
    55 void CStsServerSession::ServiceError(const RMessage2& aMessage, TInt aError)
    65 void CStsServerSession::ServiceError(const RMessage2& aMessage, TInt aError)
    56     {
    66     {
    57     CSession2::ServiceError(aMessage, aError);
    67     CSession2::ServiceError(aMessage, aError);
    58     }
    68     }
    59 
    69 
       
    70 void CStsServerSession::DoRegisterMsgQueueL(const RMessage2& aMessage)
       
    71     {
       
    72     TInt result = iMsgQueue.Open(aMessage, 0);
       
    73 
       
    74     aMessage.Complete(result);
       
    75     }
       
    76 
    60 void CStsServerSession::DoPlayToneL(const RMessage2& aMessage)
    77 void CStsServerSession::DoPlayToneL(const RMessage2& aMessage)
    61     {
    78     {
    62     CSystemToneService::TToneType toneType =
    79     CSystemToneService::TToneType tone =
    63             (CSystemToneService::TToneType) aMessage.Int0();
    80             (CSystemToneService::TToneType) aMessage.Int0();
       
    81     aMessage.Complete(KErrNone);
       
    82     iSts.PlayTone(tone);
       
    83     }
       
    84 
       
    85 void CStsServerSession::DoPlayAlarmL(const RMessage2& aMessage)
       
    86     {
       
    87     CSystemToneService::TAlarmType alarm =
       
    88             (CSystemToneService::TAlarmType) aMessage.Int0();
    64     unsigned int context = 0;
    89     unsigned int context = 0;
    65     iSts.PlayTone(toneType, context);
    90     iSts.PlayAlarm(alarm, context, *this);
       
    91     iObserverMap[context] = (MStsPlayAlarmObserver*) aMessage.Ptr2();
    66     TPckg<unsigned int> contextPckg(context);
    92     TPckg<unsigned int> contextPckg(context);
    67     TRAPD(err,aMessage.WriteL(1,contextPckg));
    93     TRAPD(err,aMessage.WriteL(1,contextPckg));
    68     aMessage.Complete(err);
    94     aMessage.Complete(err);
       
    95     // if the context is 0 there was a problem with the PlayAlarm,
       
    96     // so trigger the PlayAlarmComplete callback.
       
    97     if (context == 0)
       
    98         {
       
    99         PlayAlarmComplete(0);
       
   100         }
    69     }
   101     }
    70 
   102 
    71 void CStsServerSession::DoStopToneL(const RMessage2& aMessage)
   103 void CStsServerSession::DoStopAlarmL(const RMessage2& aMessage)
    72     {
   104     {
    73     unsigned int context = aMessage.Int0();
   105     unsigned int context = aMessage.Int0();
    74     aMessage.Complete(KErrNone);
   106     aMessage.Complete(KErrNone);
    75     iSts.StopTone(context);
   107     iObserverMap.erase(context);
       
   108     iSts.StopAlarm(context);
    76     }
   109     }
       
   110 
       
   111 void CStsServerSession::PlayAlarmComplete(unsigned int aAlarmContext)
       
   112     {
       
   113     //TODO: Trigger play complete callback to RSession
       
   114     TStsCallBack callBack =
       
   115         {
       
   116         EStsPlayAlarmComplete, iObserverMap[aAlarmContext], aAlarmContext
       
   117         };
       
   118     iMsgQueue.SendBlocking(callBack);
       
   119     iObserverMap.erase(aAlarmContext);
       
   120     }