Mercurial Mercurial > oss > FCL > sf > incubator > modemadaptation / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
adaptationlayer/modematadaptation/modematcontroller_exe/src/cmodematsrv.cpp
changeset 8 6295dc2169f3
parent 5 8ccc39f9d787
child 9 8486d82aef45
equal deleted inserted replaced
7:fa67e03b87df 8:6295dc2169f3 
    25 #include "modemattrace.h"
 
    25 #include "modemattrace.h"
 
    26 #include "catmessage.h"
 
    26 #include "catmessage.h"
 
    27 
    27 
    28 
    28 
    29 CModemAtSrv::CModemAtSrv( TInt aPriority ) :
 
    29 CModemAtSrv::CModemAtSrv( TInt aPriority ) :
 
    30     CPolicyServer( aPriority, KSrvPolicy ), iHandler(NULL)
 
    30     CPolicyServer( aPriority, KSrvPolicy ),
 
       
    31     iHandler(NULL),
 
       
    32     iDteId( 0 )  // iDteId defaults to 0 and it is updated by PNS_PIPE_CREATE_RESP
 
    31     {
 
    33     {
 
    32     }
 
    34     }
 
    33 
    35 
    34 CModemAtSrv::~CModemAtSrv()
 
    36 CModemAtSrv::~CModemAtSrv()
 
    35     {
 
    37     {
 
    47     self->StartL( KATExtSrvName );
 
    49     self->StartL( KATExtSrvName );
 
    48     RThread().SetPriority( EPriorityNormal );
 
    50     RThread().SetPriority( EPriorityNormal );
 
    49     return self;
 
    51     return self;
 
    50     }
 
    52     }
 
    51 
    53 
    52 void CModemAtSrv::RemovePipe( const TUint8 aDteId )
 
    54 void CModemAtSrv::RemovePipe()
 
    53     {
 
    55     {
 
    54     C_TRACE((_L("CModemAtSrv::RemovePipe()") ));
 
    56     C_TRACE((_L("CModemAtSrv::RemovePipe()") ));
 
    55     iHandler->RemovePipe( aDteId );
 
    57     iHandler->RemovePipe( iDteId );
 
    56     }
 
    58     }
 
    57 
    59 
    58 void CModemAtSrv::ClientClosed( CModemAtSession* aSession )
 
    60 void CModemAtSrv::ClientClosed( CModemAtSession* aSession )
 
    59     {
 
    61     {
 
    60     C_TRACE (( _L("CModemAtSrv::ClientClosed()") ));
 
    62     C_TRACE (( _L("CModemAtSrv::ClientClosed()") ));
 
    61     TInt index = iSessions.Find( aSession );
 
    63     TInt index = iSessions.Find( aSession );
 
    62     if( index >= 0 )
 
    64     if( index >= 0 )
 
    63         {
 
    65         {
 
    64         //remove session from routing table, if dteId exists
 
       
    65         if(iSessions[index]->GetDteId() != KInitialDteId )
 
       
    66             {
 
       
    67             iRouteTable[ iSessions[index]->GetPluginType() ][ iSessions[index]->GetDteId() ] = NULL;
 
       
    68             }
 
       
    69         
    66         
    70         if( iSessions.Count() == 1 )
 
    67         if( iSessions.Count() == 1 )
 
    71             {
 
    68             {
 
    72             C_TRACE((_L("Disconnecting ISI message handler ") ));
 
    69             C_TRACE((_L("Disconnecting ISI message handler ") ));
 
    73             iHandler->Disconnect( iSessions[ index ]->GetDteId() );
 
    70             iHandler->Disconnect( iDteId );
 
    74             }
 
    71             }
 
    75     
    72 
    76         C_TRACE((_L("Removing session (plugin type %d dteid: %d)"), iSessions[index]->GetPluginType(), iSessions[index]->GetDteId() ));
 
    73         C_TRACE((_L("Removing session (plugin type %d)"), iSessions[index]->GetPluginType() ));
 
    77         iSessions.Remove( index );
 
    74         iSessions.Remove( index );
 
    78         
    75 
    79         C_TRACE((_T("<<CModemAtSrv::ClientClosed()") ));
 
    76         C_TRACE((_T("<<CModemAtSrv::ClientClosed()") ));
 
    80         }
 
    77         }
 
    81     }
 
    78     }
 
    82  
    79  
    83 CSession2* CModemAtSrv::NewSessionL( const TVersion& aVersion,
 
    80 CSession2* CModemAtSrv::NewSessionL( const TVersion& aVersion,
 
    94 
    91 
    95 void CModemAtSrv::ConstructL()
 
    92 void CModemAtSrv::ConstructL()
 
    96     {
 
    93     {
 
    97     C_TRACE (( _T("CModemAtSrv::ConstructL()") ));
 
    94     C_TRACE (( _T("CModemAtSrv::ConstructL()") ));
 
    98     iHandler = CModemAtHandler::NewL( *this );
 
    95     iHandler = CModemAtHandler::NewL( *this );
 
    99     
       
   100      //setup routing table
 
       
   101     for( TInt i = 0 ; i < KPluginCount ; i++)
 
       
   102         {
 
       
   103         for(TInt o = 0; o < KMaxDteIdCount; o++)
 
       
   104             {
 
       
   105             iRouteTable[ i ][ o ] = NULL;
 
       
   106             }
 
       
   107         }
 
       
   108     } 
    96     } 
   109 
    97 
   110 void CModemAtSrv::HandleSignalInd( const TInt aDteId )
 
    98 void CModemAtSrv::HandleSignalInd( const TUint8 aDteId )
 
   111     {
 
    99     {
 
   112     C_TRACE ((_T("CModemAtSrv::HandleSignalInd aDteId = %d sessions = %d"), aDteId, iSessions.Count() ));
 
   100     C_TRACE ((_T("CModemAtSrv::HandleSignalInd aDteId = %d sessions = %d"), aDteId, iSessions.Count() ));
 
   113     for( TInt i = 0; i < iSessions.Count(); i++ )
 
   101     for( TInt i = 0; i < iSessions.Count(); i++ )
 
   114         {
 
   102         {
 
   115         if( iSessions[i]->GetDteId() == aDteId  && iSessions[i]->IsSignalIndReqActive() )
 
   103         if( iDteId == aDteId  && iSessions[i]->IsSignalIndReqActive() )
 
   116             {
 
   104             {
 
   117             C_TRACE (( _T("CModemAtSrv::HandleSignalInd() session found") ));
 
   105             C_TRACE (( _T("CModemAtSrv::HandleSignalInd() session found") ));
 
   118             iSessions[i]->SignalIndReceived();
 
   106             iSessions[i]->SignalIndReceived();
 
   119             }
 
   107             }
 
   120         }
 
   108         }
 
   121     }
 
   109     }
 
   122 
   110 
   123 void CModemAtSrv::HandleUnsolicitedData( const TInt aDteId, const TDesC8& aData )
 
   111 void CModemAtSrv::HandleUnsolicitedData( const TUint8 aDteId, const TDesC8& aData )
 
   124     {
 
   112     {
 
   125     C_TRACE ((_T("CModemAtSrv::HandleUnsolicitedData aDteId = %d sessions = %d"), aDteId, iSessions.Count() ));
 
   113     C_TRACE ((_T("CModemAtSrv::HandleUnsolicitedData aDteId = %d sessions = %d"), aDteId, iSessions.Count() ));
 
   126     for( TInt i = 0; i < iSessions.Count(); i++ )
 
   114     for( TInt i = 0; i < iSessions.Count(); i++ )
 
   127         {
 
   115         {
 
   128         if( (iSessions[i]->GetDteId() == aDteId || aDteId == KUnsolicitedDataDteId )&&
 
   116         if( ( iDteId == aDteId || aDteId == KUnsolicitedDataDteId )&&
 
   129             iSessions[i]->IsUnsolicitedDataReqActive() &&
 
   117             iSessions[i]->IsUnsolicitedDataReqActive() &&
 
   130             iSessions[i]->GetPluginType() == EATExtPlugin )
 
   118             iSessions[i]->GetPluginType() == EATExtPlugin )
 
   131             {
 
   119             {
 
   132             C_TRACE (( _T("CModemAtSrv::HandleUnsolicitedData() session found") ));
 
   120             C_TRACE (( _T("CModemAtSrv::HandleUnsolicitedData() session found") ));
 
   133             iSessions[i]->UnsolicitedData( aData );
 
   121             iSessions[i]->UnsolicitedData( aData );
 
   134             }
 
   122             }
 
   135         }
 
   123         }
 
   136     }
 
   124     }
 
   137 
   125 
   138 void CModemAtSrv::HandleCommandModeChange( TInt aDteId, TCommandMode aMode )
 
   126 void CModemAtSrv::HandleCommandModeChange( TCommandMode aMode )
 
   139     {
 
   127     {
 
   140     C_TRACE ((_T("CModemAtSrv::HandleCommandModeChange aDteId = %d sessions = %d mode = %d"), aDteId, iSessions.Count(), (TInt) aMode ));
 
   128     C_TRACE ((_T("CModemAtSrv::HandleCommandModeChange sessions = %d mode = %d"), iSessions.Count(), (TInt) aMode ));
 
   141     for( TInt i = 0; i < iSessions.Count(); i++ )
 
   129     for( TInt i = 0; i < iSessions.Count(); i++ )
 
   142         {
 
   130         {
 
   143         if( iSessions[i]->GetDteId() == aDteId &&
 
   131         if( iSessions[i]->IsCommandModeReqActive() &&
 
   144             iSessions[i]->IsCommandModeReqActive() &&
 
       
   145             iSessions[i]->GetPluginType() == ECommonPlugin )
 
   132             iSessions[i]->GetPluginType() == ECommonPlugin )
 
   146             {
 
   133             {
 
   147             C_TRACE (( _T("CModemAtSrv::HandleCommandModeChange() session found") ));
 
   134             C_TRACE (( _T("CModemAtSrv::HandleCommandModeChange() session found") ));
 
   148             iSessions[i]->CommandModeChanged( aMode );
 
   135             iSessions[i]->CommandModeChanged( aMode );
 
   149             }
 
   136             }
 
   150         }
 
   137         }
 
   151     }
 
   138     }
 
   152 
   139 
   153 void CModemAtSrv::BroadcastModemConnected(const TUint aDteId, TInt aErr )
 
   140 void CModemAtSrv::HandleIntermediateDataInd( const TUint8 aDteId,
 
   154     {
 
       
   155     C_TRACE ((_T("CModemAtSrv::BroadcastModemConnected aDteId = %d err = %d sessions = %d"), aDteId, aErr, iSessions.Count() ));
 
       
   156     for( TInt i = 0; i < iSessions.Count(); i++ )
 
       
   157         {
 
       
   158         if( iSessions[i]->GetDteId() == aDteId  && iSessions[i]->IsConnectReqActive() )
 
       
   159             {
 
       
   160             C_TRACE (( _T("CModemAtSrv::BroadcastModemConnected() session found") ));
 
       
   161             iSessions[i]->ModemConnected( aErr );
 
       
   162             }
 
       
   163         }
 
       
   164     }
 
       
   165 
       
   166 void CModemAtSrv::HandleIntermediateDataInd( const TInt aDteId,
 
       
   167     const TATPluginInterface aPluginType,
 
   141     const TATPluginInterface aPluginType,
 
   168     const TDesC8& aResponse,
 
   142     const TDesC8& aResponse,
 
   169     const TUint8 aCommand )
 
   143     const TUint8 aCommand )
 
   170     {
 
   144     {
 
   171     C_TRACE ((_T("CModemAtSrv::HandleIntermediateDataInd aDteId = %d sessions = %d "), aDteId, iSessions.Count() ));
 
   145     C_TRACE ((_T("CModemAtSrv::HandleIntermediateDataInd aDteId = %d sessions = %d "), aDteId, iSessions.Count() ));
 
   180         {
 
   154         {
 
   181         C_TRACE ((_T("CModemAtSrv::HandleIntermediateDataInd INTERMEDIATE DATA received but no request active") ));
 
   155         C_TRACE ((_T("CModemAtSrv::HandleIntermediateDataInd INTERMEDIATE DATA received but no request active") ));
 
   182         }
 
   156         }
 
   183     }
 
   157     }
 
   184 
   158 
   185 void CModemAtSrv::HandleATResponse( const TInt aDteId, const TDesC8& aResponse, const TUint8 aCommand )
 
   159 void CModemAtSrv::HandleATResponse( const TUint8 aDteId, const TDesC8& aResponse, const TUint8 aCommand )
 
   186     {
 
   160     {
 
   187     C_TRACE ((_T(">>CModemAtSrv::HandleATResponse aDteId = %d sessions = %d "), aDteId, iSessions.Count() ));
 
   161     C_TRACE ((_T(">>CModemAtSrv::HandleATResponse aDteId = %d sessions = %d "), aDteId, iSessions.Count() ));
 
   188     C_TRACE ((_T("CModemAtSrv::HandleATResponse command = %d"), aCommand ));
 
   162     C_TRACE ((_T("CModemAtSrv::HandleATResponse command = %d"), aCommand ));
 
   189     
   163     
   190     if ( iAtMessageArray.Count() > 0 )
 
   164     if ( iAtMessageArray.Count() > 0 )
 
   202         HandleUnsolicitedData( aDteId, aResponse);
 
   176         HandleUnsolicitedData( aDteId, aResponse);
 
   203         }
 
   177         }
 
   204     C_TRACE ((_T("<<CModemAtSrv::HandleATResponse()") ));
 
   178     C_TRACE ((_T("<<CModemAtSrv::HandleATResponse()") ));
 
   205     }
 
   179     }
 
   206 
   180 
   207 TInt CModemAtSrv::ConnectToModem(CModemAtSession* aSession) 
   181 TInt CModemAtSrv::ConnectToModem( CModemAtSession* aSession, TATPluginInterface aPluginType ) 
   208     {
 
   182     {
 
   209     C_TRACE ((_T(">>CModemAtSrv::ConnectToModem 0x%x"), aSession));
 
   183     C_TRACE ((_T(">>CModemAtSrv::ConnectToModem 0x%x"), aSession));
 
   210     TInt type = aSession->GetPluginType();
 
   184 
   211    
   185     C_TRACE(( _L("session count: %d, type: %d"), iSessions.Count(), (TInt) aPluginType ));
 
   212     C_TRACE(( _L("session count: %d, type: %d"), iSessions.Count(), type ));
 
   186 
   213     //find already defined dteid
 
   187     if( aPluginType == ECommonPlugin )
 
   214     for(TInt i = 0; i < iSessions.Count(); i++) 
   188         {
 
   215         {
 
   189         C_TRACE ((_T("Common plug-in connecting")));
 
   216         TInt dteid = iSessions[i]->GetDteId();
 
   190         C_TRACE ((_T("<<CModemAtSrv::ConnectToModem iDteId: %d, session: 0x%x"), iDteId, aSession));
 
   217         TDesC8& name = iSessions[i]->GetName();
 
   191         return iHandler->Connect( iDteId );
 
   218         C_TRACE((_L("i: %d, dteid: %d"), i, dteid));
 
   192         }
 
   219         
   193     else
 
   220         //Is there plugin with samename
 
   194         {
 
   221         if( name.Compare(aSession->GetName())== 0 && dteid != KInitialDteId )
 
   195         C_TRACE ((_T("Atext plug-in connecting")));
 
   222             {
 
   196 
   223             if( type == iSessions[i]->GetPluginType())
 
   197         aSession->ModemConnected( KErrNone );
 
   224                 {
 
   198         C_TRACE ((_T("<<CModemAtSrv::ConnectToModem 0x%x"), aSession));
 
   225                 TRACE_ASSERT_ALWAYS;
 
   199         return KErrNone;
 
   226                 aSession->SetDteId( dteid );
 
   200         }
 
   227                 C_TRACE ((_T("<<CModemAtSrv::ConnectToModem KErrAlreadyExists 0x%x"), aSession));
 
   201 
   228                 return KErrAlreadyExists;
 
   202     }
 
   229                 }
 
   203 
   230             //add current session to route table
 
   204 void CModemAtSrv::AddToSendFifo( const TATPluginInterface aPluginType, CAtMessage* aMessage )
 
   231             C_TRACE((_L("AddSessionToRouteTable type: %d, dteid: %d"), type, aSession->GetDteId()));
 
   205     {
 
   232             iRouteTable[aSession->GetPluginType()][dteid] = aSession;
 
   206     C_TRACE (( _T("CModemAtSrv::AddToSendFifo( aPluginType: %d, aMessage: 0x%x)"), (TInt)aPluginType, aMessage));
 
   233             C_TRACE((_L("Interface exists=> %d"),dteid));
 
       
   234 
       
   235             aSession->SetDteId( dteid );
 
       
   236             C_TRACE ((_T("<<CModemAtSrv::ConnectToModem KErrNone 0x%x"), aSession));
 
       
   237             return KErrNone;
 
       
   238             }
 
       
   239         }
 
       
   240 
       
   241     //no AT-plugin& Common plugin, find first free dteid
 
       
   242     TInt dteId = 0;
 
       
   243     while(iRouteTable[0][dteId] || iRouteTable[1][dteId])
 
       
   244         {
 
       
   245         dteId++;
 
       
   246       }     
       
   247     ASSERT_PANIC_ALWAYS( dteId < KMaxDteIdCount );
 
       
   248     iRouteTable[type][dteId] = aSession;
 
       
   249     C_TRACE((_L("Added new dteid: %d"),dteId));
 
       
   250 
       
   251     aSession->SetDteId(dteId);
 
       
   252     C_TRACE ((_T("<<CModemAtSrv::ConnectToModem session: 0x%x"), aSession));
 
       
   253     return iHandler->Connect( dteId );
 
       
   254     }
 
       
   255 
       
   256 void CModemAtSrv::AddToSendFifo( const TUint8 aDteId,
 
       
   257     const TATPluginInterface aPluginType,
 
       
   258     CAtMessage* aMessage )
 
       
   259     {
 
       
   260     C_TRACE (( _T("CModemAtSrv::AddToSendFifo( dteId = %d,0x%x)"), aDteId, aMessage  ));
 
       
   261 
   207 
   262     iAtMessageArray.Append( aMessage ); // only one AT command at the time in modem
 
   208     iAtMessageArray.Append( aMessage ); // only one AT command at the time in modem
 
   263 
   209 
   264     if( iAtMessageArray.Count() == 1 ) //if empty Fifo send immediately
 
   210     if( iAtMessageArray.Count() == 1 ) //if empty Fifo send immediately
 
   265         {
 
   211         {
 
   266         C_TRACE((_L("Sending message immediately")));
 
   212         C_TRACE((_L("Sending message immediately")));
 
   267         iHandler->SendATCommand( aDteId, 
   213         iHandler->SendATCommand( iDteId, 
   268            aPluginType,
 
   214            aPluginType,
 
   269            aMessage->GetMessageType(),
 
   215            aMessage->GetMessageType(),
 
   270            aMessage->GetBuffer() );
 
   216            aMessage->GetBuffer() );
 
   271         }
 
   217         }
 
   272     }
 
   218     }
 
   303         {
 
   249         {
 
   304         C_TRACE((_L("Messages in buffer... Sending message")));
 
   250         C_TRACE((_L("Messages in buffer... Sending message")));
 
   305         ptr.Set( iAtMessageArray[0]->GetBuffer() );
 
   251         ptr.Set( iAtMessageArray[0]->GetBuffer() );
 
   306         
   252         
   307         C_TRACE (( _T("iHandler->SendATCommand()") ));
 
   253         C_TRACE (( _T("iHandler->SendATCommand()") ));
 
   308         iHandler->SendATCommand( iAtMessageArray[0]->GetSession()->GetDteId(), 
   254         iHandler->SendATCommand( iDteId, 
   309            iAtMessageArray[0]->GetSession()->GetPluginType(),
 
   255            iAtMessageArray[0]->GetSession()->GetPluginType(),
 
   310            iAtMessageArray[0]->GetMessageType(),
 
   256            iAtMessageArray[0]->GetMessageType(),
 
   311            ptr );
 
   257            ptr );
 
   312         }
 
   258         }
 
   313     }
 
   259     }
 
   344     {
 
   290     {
 
   345     C_TRACE(( _T("CModemAtSrv::SessionCount() %d"), iSessions.Count() ));
 
   291     C_TRACE(( _T("CModemAtSrv::SessionCount() %d"), iSessions.Count() ));
 
   346     return iSessions.Count();
 
   292     return iSessions.Count();
 
   347     }
 
   293     }
 
   348 
   294 
       
   295 void CModemAtSrv::SetDteIdAndConnect( const TUint8 aDteId, const TInt aConnectionError ) 
       
   296     {
 
       
   297     C_TRACE(( _T("CModemAtSrv::SetDteIdAndConnect( %d )"), aDteId ));
 
       
   298     iDteId = aDteId;
 
       
   299 
       
   300     C_TRACE ((_T("sessions = %d"), iSessions.Count() ));
 
       
   301     for( TInt i = 0; i < iSessions.Count(); i++ )
 
       
   302         {
 
       
   303         if( iSessions[i]->IsConnectReqActive() )
 
       
   304             {
 
       
   305             C_TRACE (( _T("set sessions to connected") ));
 
       
   306             iSessions[i]->ModemConnected( aConnectionError );
 
       
   307             }
 
       
   308         }
 
       
   309     }
 
       
   310
FCL/sf/incubator/modemadaptation