1 /*

     2 * Copyright (c) 2006-2009 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:  Monitors signal changes on network side and reports changes

    15 *

    16 */

    17 

    18 

    19 #ifdef PRJ_USE_NETWORK_STUBS

    20 #include <c32comm_stub.h>

    21 #else

    22 #include <d32comm.h>

    23 #endif

    24 #include "DunTransporter.h"

    25 #include "DunSignalNotify.h"

    26 #include "DunDebug.h"

    27 

    28 const TUint KDunSixLowestBitsMask = 0x3F;  // Symbian magic

    29 

    30 // ======== MEMBER FUNCTIONS ========

    31 

    32 // ---------------------------------------------------------------------------

    33 // Two-phased constructor.

    34 // ---------------------------------------------------------------------------

    35 //

    36 CDunSignalNotify* CDunSignalNotify::NewL( MDunTransporterUtilityAux* aUtility )

    37     {

    38     CDunSignalNotify* self = new (ELeave) CDunSignalNotify( aUtility );

    39     CleanupStack::PushL( self );

    40     self->ConstructL();

    41     CleanupStack::Pop( self );

    42     return self;

    43     }

    44 

    45 // ---------------------------------------------------------------------------

    46 // Destructor

    47 // ---------------------------------------------------------------------------

    48 //

    49 CDunSignalNotify::~CDunSignalNotify()

    50     {

    51     FTRACE(FPrint( _L("CDunSignalNotify::~CDunSignalNotify()") ));

    52     ResetData();

    53     FTRACE(FPrint( _L("CDunSignalNotify::~CDunSignalNotify() complete") ));

    54     }

    55 

    56 // ---------------------------------------------------------------------------

    57 // Resets data to initial values

    58 // ---------------------------------------------------------------------------

    59 //

    60 void CDunSignalNotify::ResetData()

    61     {

    62     FTRACE(FPrint( _L("CDunSignalNotify::ResetData()") ));

    63     // APIs affecting this:

    64     // IssueRequest()

    65     Stop();

    66     // AddCallback()

    67     iCallbacks.Close();

    68     // AddEndpointReadyCallback()

    69     iERCallbacks.Close();

    70     // Internal

    71     Initialize();

    72     FTRACE(FPrint( _L("CDunSignalNotify::ResetData() complete") ));

    73     }

    74 

    75 // ---------------------------------------------------------------------------

    76 // Adds callback for line status change controlling

    77 // The callback will be called when line status change is detected in

    78 // endpoint

    79 // ---------------------------------------------------------------------------

    80 //

    81 TInt CDunSignalNotify::AddCallback( MDunConnMon* aCallback )

    82     {

    83     FTRACE(FPrint( _L("CDunSignalNotify::AddCallback()" ) ));

    84     if ( !aCallback )

    85         {

    86         FTRACE(FPrint( _L("CDunSignalNotify::AddCallback() (ERROR) complete" ) ));

    87         return KErrGeneral;

    88         }

    89     TInt retTemp = iCallbacks.Find( aCallback );

    90     if ( retTemp != KErrNotFound )

    91         {

    92         FTRACE(FPrint( _L("CDunSignalNotify::AddCallback() (already exists) complete" ) ));

    93         return KErrAlreadyExists;

    94         }

    95     retTemp = iCallbacks.Append( aCallback );

    96     if ( retTemp != KErrNone )

    97         {

    98         FTRACE(FPrint( _L("CDunSignalNotify::AddCallback() (append failed!) complete" ) ));

    99         return retTemp;

   100         }

   101     FTRACE(FPrint( _L("CDunSignalNotify::AddCallback() complete" ) ));

   102     return KErrNone;

   103     }

   104 

   105 // ---------------------------------------------------------------------------

   106 // Adds callback for endpoint readiness

   107 // The callback will be called when the endpoint is ready or not ready

   108 // ---------------------------------------------------------------------------

   109 //

   110 TInt CDunSignalNotify::AddEndpointReadyCallback(

   111     MDunEndpointReady* aERCallback )

   112     {

   113     FTRACE(FPrint( _L("CDunSignalNotify::AddEndpointReadyCallback()" ) ));

   114     if ( !aERCallback )

   115         {

   116         FTRACE(FPrint( _L("CDunSignalNotify::AddEndpointReadyCallback() (aERCallback) not initialized!" ) ));

   117         return KErrGeneral;

   118         }

   119     TInt retTemp = iERCallbacks.Find( aERCallback );

   120     if ( retTemp != KErrNotFound )

   121         {

   122         FTRACE(FPrint( _L("CDunSignalNotify::AddEndpointReadyCallback() (already exists) complete" ) ));

   123         return KErrAlreadyExists;

   124         }

   125     retTemp = iERCallbacks.Append( aERCallback );

   126     if ( retTemp != KErrNone )

   127         {

   128         FTRACE(FPrint( _L("CDunSignalNotify::AddEndpointReadyCallback() (append failed!) complete" ) ));

   129         return retTemp;

   130         }

   131     ReportEndpointReady( ETrue );  // report immediately as this is a hack

   132     FTRACE(FPrint( _L("CDunSignalNotify::AddEndpointReadyCallback() complete" ) ));

   133     return KErrNone;

   134     }

   135 

   136 // ---------------------------------------------------------------------------

   137 // Sets media to use for this endpoint monitor

   138 // ---------------------------------------------------------------------------

   139 //

   140 TInt CDunSignalNotify::SetMedia( RComm* aComm )

   141     {

   142     FTRACE(FPrint( _L("CDunSignalNotify::SetMedia()" )));

   143     if ( !aComm )

   144         {

   145         FTRACE(FPrint( _L("CDunSignalNotify::SetMedia() (aComm) not initialized!" )));

   146         return KErrGeneral;

   147         }

   148     // As it's not possible to listen for RFCOMM signal changes the RTS and DTR

   149     // signals should be anyway set high to Dataport

   150     aComm->SetSignals( KSignalRTS|KSignalDTR, 0 );

   151     // Next check if signal change notification from Dataport supported

   152     TCommCaps2 caps;

   153     aComm->Caps( caps );

   154     if ( !(caps().iNotificationCaps & KNotifySignalsChangeSupported) )

   155         {

   156         FTRACE(FPrint( _L("CDunSignalNotify::SetMedia() (RComm) (not supported) complete" )));

   157         return KErrNotSupported;

   158         }

   159     iListenSignals = KSignalDTEInputs;

   160     iNetwork = aComm;

   161     FTRACE(FPrint( _L("CDunSignalNotify::SetMedia() (RComm) complete" )));

   162     return KErrNone;

   163     }

   164 

   165 // ---------------------------------------------------------------------------

   166 // Issues request to start monitoring the endpoint for line status change

   167 // ---------------------------------------------------------------------------

   168 //

   169 TInt CDunSignalNotify::IssueRequest()

   170     {

   171     FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest()" )));

   172     if ( iSignalNotifyState != EDunStateIdle )

   173         {

   174         FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() (not ready) complete" )));

   175         return KErrNotReady;

   176         }

   177     if ( !iNetwork )

   178         {

   179         FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() (iNetwork) not initialized!" ) ));

   180         return KErrGeneral;

   181         }

   182     TUint currentSignals = iNetwork->Signals( iListenSignals );

   183     TUint oldSignalsLow = iSignals & KDunSixLowestBitsMask;

   184     TUint newSignalsLow = currentSignals & KDunSixLowestBitsMask;

   185     TUint oldSignalsHigh = oldSignalsLow * KSignalChanged;

   186     TUint newSignalsHigh = newSignalsLow * KSignalChanged;

   187     FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() oldSignalsLow=0x%08X" ), oldSignalsLow ));

   188     FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() newSignalsLow=0x%08X" ), newSignalsLow ));

   189     FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() oldSignalsHigh=0x%08X" ), oldSignalsHigh ));

   190     FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() newSignalsHigh=0x%08X" ), newSignalsHigh ));

   191     if ( newSignalsLow != oldSignalsLow )

   192         {

   193         FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() signals already set..." ) ));

   194         iSignals = newSignalsLow | (oldSignalsHigh ^ newSignalsHigh);

   195         ManageSignalChange();

   196         }

   197     else

   198         {

   199         FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() start waiting for change..." ) ));

   200         iStatus = KRequestPending;

   201         iNetwork->NotifySignalChange( iStatus, iSignals, iListenSignals );

   202         SetActive();

   203         iSignalNotifyState = EDunStateSignalNotify;

   204         }

   205     FTRACE(FPrint( _L("CDunSignalNotify::IssueRequest() complete" )));

   206     return KErrNone;

   207     }

   208 

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

   210 // Stops monitoring the endpoint for line status change

   211 // ---------------------------------------------------------------------------

   212 //

   213 TInt CDunSignalNotify::Stop()

   214     {

   215     FTRACE(FPrint( _L("CDunSignalNotify::Stop()" )));

   216     if ( iSignalNotifyState != EDunStateSignalNotify )

   217         {

   218         FTRACE(FPrint( _L("CDunSignalNotify::Stop() (not ready) complete" )));

   219         return KErrNotReady;

   220         }

   221     if ( !iNetwork )

   222         {

   223         FTRACE(FPrint( _L("CDunSignalNotify::Stop() (iNetwork) not initialized!" )));

   224         return KErrGeneral;

   225         }

   226     iNetwork->NotifySignalChangeCancel();

   227     Cancel();

   228     iSignalNotifyState = EDunStateIdle;

   229     FTRACE(FPrint( _L("CDunSignalNotify::Stop() complete" )));

   230     return KErrNone;

   231     }

   232 

   233 // ---------------------------------------------------------------------------

   234 // CDunSignalNotify::CDunSignalNotify

   235 // ---------------------------------------------------------------------------

   236 //

   237 CDunSignalNotify::CDunSignalNotify( MDunTransporterUtilityAux* aUtility ) :

   238     CActive( EPriorityHigh ),

   239     iUtility( aUtility )

   240     {

   241     Initialize();

   242     }

   243 

   244 // ---------------------------------------------------------------------------

   245 // CDunSignalNotify::ConstructL

   246 // ---------------------------------------------------------------------------

   247 //

   248 void CDunSignalNotify::ConstructL()

   249     {

   250     FTRACE(FPrint( _L("CDunSignalNotify::ConstructL()" ) ));

   251     if ( !iUtility )

   252         {

   253         User::Leave( KErrGeneral );

   254         }

   255     CActiveScheduler::Add( this );

   256     FTRACE(FPrint( _L("CDunSignalNotify::ConstructL() complete" ) ));

   257     }

   258 

   259 // ---------------------------------------------------------------------------

   260 // Initializes this class

   261 // ---------------------------------------------------------------------------

   262 //

   263 void CDunSignalNotify::Initialize()

   264     {

   265     FTRACE(FPrint( _L("CDunSignalNotify::Initialize()" ) ));

   266     // Don't initialize iUtility here (it is set through NewL)

   267     iSignalNotifyState = EDunStateIdle;

   268     iListenSignals = 0;

   269     iSignals = 0;

   270     iNetwork = NULL;

   271     FTRACE(FPrint( _L("CDunSignalNotify::Initialize() complete" ) ));

   272     }

   273 

   274 // ---------------------------------------------------------------------------

   275 // Manages signal changes

   276 // ---------------------------------------------------------------------------

   277 //

   278 void CDunSignalNotify::ManageSignalChange()

   279     {

   280     FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange()" ) ));

   281     // The following signals are input signals from network side:

   282     // KSignalDTEInputs = KSignalCTS | KSignalDSR | KSignalDCD | KSignalRNG

   283     if ( iSignals & KCTSChanged )

   284         {

   285         FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() checking CTS..." ) ));

   286         if ( iSignals & KSignalCTS )  // CTS changed to high

   287             {

   288             ReportSignalChange( KSignalCTS, 0 );

   289             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() CTS changed high" ) ));

   290             }

   291         else  // CTS changed to low

   292             {

   293             ReportSignalChange( 0, KSignalCTS );

   294             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() CTS changed low" ) ));

   295             }

   296         }

   297     if ( iSignals & KDSRChanged )

   298         {

   299         FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() checking DSR..." ) ));

   300         if ( iSignals & KSignalDSR )  // DSR changed to high

   301             {

   302             ReportSignalChange( KSignalDSR, 0 );

   303             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() DSR changed high" ) ));

   304             }

   305         else  // DSR changed to low

   306             {

   307             ReportSignalChange( 0, KSignalDSR );

   308             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() DSR changed low" ) ));

   309             }

   310         }

   311     if ( iSignals & KDCDChanged )

   312         {

   313         FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() checking DCD..." ) ));

   314         if ( iSignals & KSignalDCD )  // DCD changed to high

   315             {

   316             ReportSignalChange( KSignalDCD, 0 );

   317             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() DCD changed high" ) ));

   318             }

   319         else  // DCD changed to low

   320             {

   321             ReportSignalChange( 0, KSignalDCD );

   322             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() DCD changed low" ) ));

   323             }

   324         }

   325     if ( iSignals & KRNGChanged )

   326         {

   327         FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() checking RNG..." ) ));

   328         if ( iSignals & KSignalRNG )  // RNG changed to high

   329             {

   330             ReportSignalChange( KSignalRNG, 0 );

   331             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() RNG changed high" ) ));

   332             }

   333         else  // RNG changed to low

   334             {

   335             ReportSignalChange( 0, KSignalRNG );

   336             FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() RNG changed low" ) ));

   337             }

   338         }

   339     IssueRequest();

   340     FTRACE(FPrint( _L("CDunSignalNotify::ManageSignalChange() complete" ) ));

   341     }

   342 

   343 // ---------------------------------------------------------------------------

   344 // Reports signal change

   345 // ---------------------------------------------------------------------------

   346 //

   347 void CDunSignalNotify::ReportSignalChange( TUint aSetMask, TUint aClearMask )

   348     {

   349     FTRACE(FPrint( _L("CDunSignalNotify::ReportSignalChange()" ) ));

   350 

   351     TUint signalType = aClearMask;

   352     TUint signalHigh = EFalse;

   353     if ( aSetMask != 0 )

   354         {

   355         signalType = aSetMask;

   356         signalHigh = ETrue;

   357         }

   358     TInt i;

   359     TInt count = iCallbacks.Count();

   360     TDunConnectionReason connReason;

   361     TConnId localId = iUtility->GetLocalId( iNetwork );

   362     connReason.iReasonType = EDunReasonTypeSignal;

   363     connReason.iContext = EDunMediaContextNetwork;

   364     connReason.iSignalType = signalType;

   365     connReason.iSignalHigh = signalHigh;

   366     connReason.iDirection = EDunDirectionUndefined;

   367     connReason.iErrorCode = KErrNone;

   368     for ( i=0; i<count; i++ )

   369         {

   370         TRAP_IGNORE(

   371             iCallbacks[i]->NotifyProgressChangeL( localId, connReason ) );

   372         }

   373 

   374     FTRACE(FPrint( _L("CDunSignalNotify::ReportSignalChange() complete" ) ));

   375     }

   376 

   377 // ---------------------------------------------------------------------------

   378 // Reports endpoint ready or not ready

   379 // ---------------------------------------------------------------------------

   380 //

   381 void CDunSignalNotify::ReportEndpointReady( TBool aReady )

   382     {

   383     FTRACE(FPrint( _L("CDunSignalNotify::ReportEndpointReady()" ) ));

   384     TInt count = iERCallbacks.Count();

   385     for ( TInt i=0; i<count; i++ )

   386         {

   387         if ( aReady )

   388             {

   389             iERCallbacks[i]->NotifyEndpointReady();

   390             }

   391         else  // not ready

   392             {

   393             iERCallbacks[i]->NotifyEndpointNotReady();

   394             }

   395         }

   396     FTRACE(FPrint( _L("CDunSignalNotify::ReportEndpointReady() complete" ) ));

   397     }

   398 

   399 // ---------------------------------------------------------------------------

   400 // From class CActive.

   401 // Gets called when line status changes

   402 // ---------------------------------------------------------------------------

   403 //

   404 void CDunSignalNotify::RunL()

   405     {

   406     FTRACE(FPrint( _L("CDunSignalNotify::RunL()" ) ));

   407     iSignalNotifyState = EDunStateIdle;

   408     TInt retTemp = iStatus.Int();

   409     if ( retTemp != KErrNone )

   410         {

   411         TInt i;

   412         TInt count = iCallbacks.Count();

   413         TDunConnectionReason connReason;

   414         TConnId localId = iUtility->GetLocalId( iNetwork );

   415         connReason.iReasonType = EDunReasonTypeRunL;

   416         connReason.iContext = EDunMediaContextNetwork;

   417         connReason.iSignalType = 0;

   418         connReason.iSignalHigh = EFalse;

   419         connReason.iDirection = EDunDirectionUndefined;

   420         connReason.iErrorCode = retTemp;

   421         for ( i=0; i<count; i++ )

   422             {

   423             TRAP_IGNORE(

   424                 iCallbacks[i]->NotifyProgressChangeL( localId, connReason ) );

   425             }

   426         return;

   427         }

   428     FTRACE(FPrint( _L("CDunSignalNotify::RunL() managing signal 0x%08X" ), iSignals ));

   429     ManageSignalChange();

   430     FTRACE(FPrint( _L("CDunSignalNotify::RunL() complete" ) ));

   431     }

   432 

   433 // ---------------------------------------------------------------------------

   434 // From class CActive.

   435 // Gets called on cancel

   436 // ---------------------------------------------------------------------------

   437 //

   438 void CDunSignalNotify::DoCancel()

   439     {

   440     }