1 /*

     2 * Copyright (c) 2008 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:  AT command URC handler

    15 *

    16 */

    17 

    18 

    19 #include <atext.h>

    20 #include "DunAtCmdHandler.h"

    21 #include "DunAtUrcHandler.h"

    22 #include "DunDownstream.h"

    23 #include "DunDebug.h"

    24 

    25 // ---------------------------------------------------------------------------

    26 // Two-phased constructor.

    27 // ---------------------------------------------------------------------------

    28 //

    29 CDunAtUrcHandler* CDunAtUrcHandler::NewL(

    30     RATExt* aAtCmdExt,

    31     MDunStreamManipulator* aStreamCallback )

    32     {

    33     CDunAtUrcHandler* self = NewLC( aAtCmdExt, aStreamCallback );

    34     CleanupStack::Pop( self );

    35     return self;

    36     }

    37 

    38 // ---------------------------------------------------------------------------

    39 // Two-phased constructor.

    40 // ---------------------------------------------------------------------------

    41 //

    42 CDunAtUrcHandler* CDunAtUrcHandler::NewLC(

    43     RATExt* aAtCmdExt,

    44     MDunStreamManipulator* aStreamCallback )

    45     {

    46     CDunAtUrcHandler* self = new (ELeave) CDunAtUrcHandler( aAtCmdExt,

    47                                                             aStreamCallback );

    48     CleanupStack::PushL( self );

    49     self->ConstructL();

    50     return self;

    51     }

    52 

    53 // ---------------------------------------------------------------------------

    54 // Destructor.

    55 // ---------------------------------------------------------------------------

    56 //

    57 CDunAtUrcHandler::~CDunAtUrcHandler()

    58     {

    59     FTRACE(FPrint( _L("CDunAtUrcHandler::~CDunAtUrcHandler()") ));

    60     ResetData();

    61     FTRACE(FPrint( _L("CDunAtUrcHandler::~CDunAtUrcHandler() complete") ));

    62     }

    63 

    64 // ---------------------------------------------------------------------------

    65 // Resets data to initial values

    66 // ---------------------------------------------------------------------------

    67 //

    68 void CDunAtUrcHandler::ResetData()

    69     {

    70     FTRACE(FPrint( _L("CDunAtUrcHandler::ResetData()") ));

    71     // APIs affecting this:

    72     // IssueRequest()

    73     Stop();

    74     // Don't close iAtCmdExt here (it is done in CDunAtCmdHandler)!

    75     // Internal

    76     Initialize();

    77     FTRACE(FPrint( _L("CDunAtUrcHandler::ResetData() complete") ));

    78     }

    79 

    80 // ---------------------------------------------------------------------------

    81 // Starts waiting for an incoming URC message

    82 // ---------------------------------------------------------------------------

    83 //

    84 TInt CDunAtUrcHandler::IssueRequest()

    85     {

    86     FTRACE(FPrint( _L("CDunAtUrcHandler::IssueRequest()") ));

    87     if ( iUrcHandleState != EDunStateIdle )

    88         {

    89         FTRACE(FPrint( _L("CDunAtUrcHandler::IssueRequest() (not ready) complete") ));

    90         return KErrNotReady;

    91         }

    92     iStatus = KRequestPending;

    93     iAtCmdExt->ReceiveUnsolicitedResult( iStatus, iRecvBuffer, iOwnerUidPckg );

    94     SetActive();

    95     iUrcHandleState = EDunStateAtUrcHandling;

    96     // Next mark ownership

    97     if ( !iStarted )

    98         {

    99         TInt retTemp = iAtCmdExt->MarkUrcHandlingOwnership( iOwnerUid );

   100         if ( retTemp != KErrNone )

   101             {

   102             FTRACE(FPrint( _L("CDunAtUrcHandler::IssueRequest() (not owned) complete") ));

   103             return KErrGeneral;

   104             }

   105         }

   106     iStarted = ETrue;

   107     FTRACE(FPrint( _L("CDunAtUrcHandler::IssueRequest() complete") ));

   108     return KErrNone;

   109     }

   110 

   111 // ---------------------------------------------------------------------------

   112 // Stops waiting for an incoming URC message

   113 // ---------------------------------------------------------------------------

   114 //

   115 TInt CDunAtUrcHandler::Stop()

   116     {

   117     FTRACE(FPrint( _L("CDunAtUrcHandler::Stop()") ));

   118     if ( iUrcHandleState != EDunStateAtUrcHandling )

   119         {

   120         FTRACE(FPrint( _L("CDunAtUrcHandler::Stop() (not ready) complete" )));

   121         return KErrNotReady;

   122         }

   123     iAtCmdExt->CancelReceiveUnsolicitedResult( iOwnerUid );

   124     Cancel();

   125     iUrcHandleState = EDunStateIdle;

   126     FTRACE(FPrint( _L("CDunAtUrcHandler::Stop() complete") ));

   127     // Note: Don't mark iStarted to EFalse here as it is used to get the UID

   128     return KErrNone;

   129     }

   130 

   131 // ---------------------------------------------------------------------------

   132 // UID of the owning plugin

   133 // ---------------------------------------------------------------------------

   134 //

   135 TUid CDunAtUrcHandler::OwnerUid()

   136     {

   137     return iOwnerUid;

   138     }

   139 

   140 // ---------------------------------------------------------------------------

   141 // CDunAtUrcHandler::CDunAtUrcHandler

   142 // ---------------------------------------------------------------------------

   143 //

   144 CDunAtUrcHandler::CDunAtUrcHandler( RATExt* aAtCmdExt,

   145                                     MDunStreamManipulator* aStreamCallback ) :

   146     CActive( EPriorityHigh ),

   147     iAtCmdExt( aAtCmdExt ),

   148     iStreamCallback( aStreamCallback ),

   149     iOwnerUidPckg( iOwnerUid )

   150     {

   151     Initialize();

   152     }

   153 

   154 // ---------------------------------------------------------------------------

   155 // CDunAtUrcHandler::ConstructL

   156 // ---------------------------------------------------------------------------

   157 //

   158 void CDunAtUrcHandler::ConstructL()

   159     {

   160     FTRACE(FPrint( _L("CDunAtUrcHandler::ConstructL()") ));

   161     if ( !iAtCmdExt || !iStreamCallback  )

   162         {

   163         User::Leave( KErrGeneral );

   164         }

   165     CActiveScheduler::Add( this );

   166     FTRACE(FPrint( _L("CDunAtUrcHandler::ConstructL() complete") ));

   167     }

   168 

   169 // ---------------------------------------------------------------------------

   170 // Initializes this class

   171 // ---------------------------------------------------------------------------

   172 //

   173 void CDunAtUrcHandler::Initialize()

   174     {

   175     // Don't initialize iStreamCallback here (it is set through NewL)

   176     iUrcHandleState = EDunStateIdle;

   177     iOwnerUid = TUid::Null();

   178     iStarted = EFalse;

   179     }

   180 

   181 // ---------------------------------------------------------------------------

   182 // From class CActive.

   183 // Gets called when URC command received

   184 // ---------------------------------------------------------------------------

   185 //

   186 void CDunAtUrcHandler::RunL()

   187     {

   188     FTRACE(FPrint( _L("CDunAtUrcHandler::RunL()") ));

   189     iUrcHandleState = EDunStateIdle;

   190     TInt retTemp = iStatus.Int();

   191     if ( retTemp != KErrNone )

   192         {

   193         FTRACE(FPrint( _L("CDunAtUrcHandler::RunL() (ERROR) complete (%d)"), retTemp));

   194         return;

   195         }

   196     if ( iRecvBuffer.Length() == 0 )

   197         {

   198         FTRACE(FPrint( _L("CDunAtUrcHandler::RunL() (empty buffer) complete") ));

   199         return;

   200         }

   201 

   202     // Send received URC message

   203 

   204     iStreamCallback->NotifyDataPushRequest( &iRecvBuffer, this );

   205 

   206     FTRACE(FPrint( _L("CDunAtUrcHandler::RunL() complete") ));

   207     }

   208 

   209 // ---------------------------------------------------------------------------

   210 // From class CActive.

   211 // Gets called on cancel

   212 // ---------------------------------------------------------------------------

   213 //

   214 void CDunAtUrcHandler::DoCancel()

   215     {

   216     }

   217 

   218 // ---------------------------------------------------------------------------

   219 // From class MDunCompletionReporter.

   220 // Gets called when data push is complete

   221 // ---------------------------------------------------------------------------

   222 //

   223 void CDunAtUrcHandler::NotifyDataPushComplete( TBool /*aAllPushed*/ )

   224     {

   225     FTRACE(FPrint( _L("CDunAtUrcHandler::NotifyDataPushComplete()") ));

   226     IssueRequest();

   227     FTRACE(FPrint( _L("CDunAtUrcHandler::NotifyDataPushComplete() complete") ));

   228     }