1 /*

     2 * Copyright (c) 2009-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 * Client side IPC handling for Connection Method Manager server.

    16 *

    17 */

    18 

    19 

    20 #include "cmmserverdefs.h"

    21 #include "cmconnectionmethodapi.h"

    22 

    23 #include "OstTraceDefinitions.h"

    24 #ifdef OST_TRACE_COMPILER_IN_USE

    25 #include "cmconnectionmethodapiTraces.h"

    26 #endif

    27 

    28 

    29 RCmConnectionMethodApi::RCmConnectionMethodApi()

    30     {

    31     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_RCMCONNECTIONMETHODAPI_ENTRY );

    32     iSessionConnected = EFalse;

    33     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_RCMCONNECTIONMETHODAPI_EXIT );

    34     }

    35 

    36 TBool RCmConnectionMethodApi::SessionConnected() const

    37     {

    38     return iSessionConnected;

    39     }

    40 

    41 void RCmConnectionMethodApi::ConnectAndGetConnMethodWithIdL(

    42         const RSessionBase& aSession,

    43         const TUint32 aIapId,

    44         TInt& aExistingHandle )

    45     {

    46     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDGETCONNMETHODWITHIDL_ENTRY );

    47 

    48     if ( iSessionConnected )

    49         {

    50         User::Leave( KErrAlreadyExists );

    51         }

    52 

    53     aExistingHandle = 0;

    54     TPckg<TInt> pckg( aExistingHandle );

    55     TIpcArgs args( aIapId, &pckg );

    56     TInt result = CreateSubSession( aSession, ECMGetConnMethodWithId, args );

    57     if ( !aExistingHandle )

    58         {

    59         User::LeaveIfError( result );

    60         iSessionConnected = ETrue;

    61         }

    62     else

    63         {

    64         if ( result != KErrAlreadyExists )

    65             {

    66             User::Leave( result );

    67             }

    68         }

    69 

    70     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDGETCONNMETHODWITHIDL_EXIT );

    71     }

    72 

    73 void RCmConnectionMethodApi::ConnectAndGetConnMethodFromDestWithIndexL(

    74         const RSessionBase& aSession,

    75         const TInt aDestHandle,

    76         const TInt aIndex,

    77         TInt& aExistingHandle )

    78     {

    79     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDGETCONNMETHODFROMDESTWITHINDEXL_ENTRY );

    80 

    81     if ( iSessionConnected )

    82         {

    83         User::Leave( KErrAlreadyExists );

    84         }

    85 

    86     aExistingHandle = 0;

    87     TPckg<TInt> pckg( aExistingHandle );

    88     TIpcArgs args( aDestHandle, aIndex, &pckg );

    89     TInt result = CreateSubSession( aSession, ECMGetConnMethodFromDestWithIndex, args );

    90     if ( !aExistingHandle )

    91         {

    92         User::LeaveIfError( result );

    93         iSessionConnected = ETrue;

    94         }

    95     else

    96         {

    97         if ( result != KErrAlreadyExists )

    98             {

    99             User::Leave( result );

   100             }

   101         }

   102 

   103     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDGETCONNMETHODFROMDESTWITHINDEXL_EXIT );

   104     }

   105 

   106 void RCmConnectionMethodApi::ConnectAndGetConnMethodFromDestWithIdL(

   107         const RSessionBase& aSession,

   108         const TInt aDestHandle,

   109         const TInt aIapId,

   110         TInt& aExistingHandle )

   111     {

   112     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDGETCONNMETHODFROMDESTWITHIDL_ENTRY );

   113 

   114     if ( iSessionConnected )

   115         {

   116         User::Leave( KErrAlreadyExists );

   117         }

   118 

   119     aExistingHandle = 0;

   120     TPckg<TInt> pckg( aExistingHandle );

   121     TIpcArgs args( aDestHandle, aIapId, &pckg );

   122     TInt result = CreateSubSession( aSession, ECMGetConnMethodFromDestWithId, args );

   123     if ( !aExistingHandle )

   124         {

   125         User::LeaveIfError( result );

   126         iSessionConnected = ETrue;

   127         }

   128     else

   129         {

   130         if ( result != KErrAlreadyExists )

   131             {

   132             User::Leave( result );

   133             }

   134         }

   135 

   136     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDGETCONNMETHODFROMDESTWITHIDL_EXIT );

   137     }

   138 

   139 void RCmConnectionMethodApi::ConnectAndCreateConnMethodL(

   140         const RSessionBase& aSession,

   141         const TUint32 aBearerType )

   142     {

   143     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODL_ENTRY );

   144 

   145     if ( iSessionConnected )

   146         {

   147         User::Leave( KErrAlreadyExists );

   148         }

   149 

   150     TIpcArgs args( aBearerType );

   151     User::LeaveIfError( CreateSubSession( aSession, ECMCreateConnMethod, args ) );

   152     iSessionConnected = ETrue;

   153 

   154     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODL_EXIT );

   155     }

   156 

   157 void RCmConnectionMethodApi::ConnectAndCreateConnMethodWithIdL(

   158         const RSessionBase& aSession,

   159         const TUint32 aBearerType,

   160         const TUint32 aIapId )

   161     {

   162     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODWITHIDL_ENTRY );

   163 

   164     if ( iSessionConnected )

   165         {

   166         User::Leave( KErrAlreadyExists );

   167         }

   168 

   169     TIpcArgs args( aBearerType, aIapId );

   170     User::LeaveIfError( CreateSubSession( aSession, ECMCreateConnMethodWithId, args ) );

   171     iSessionConnected = ETrue;

   172 

   173     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODWITHIDL_EXIT );

   174     }

   175 

   176 TInt RCmConnectionMethodApi::ConnectAndCreateConnMethodCopy(

   177         const RSessionBase& aSession,

   178         const TInt aConnMethodHandle )

   179     {

   180     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODCOPY_ENTRY );

   181 

   182     TInt err( KErrNone );

   183     if ( iSessionConnected )

   184         {

   185         err = KErrAlreadyExists;

   186         }

   187     else

   188         {

   189         TIpcArgs args( aConnMethodHandle );

   190         err = CreateSubSession( aSession, ECMCreateCopyOfExisting, args );

   191         if ( !err )

   192             {

   193             iSessionConnected = ETrue;

   194             }

   195         }

   196 

   197     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODCOPY_EXIT );

   198     return err;

   199     }

   200 

   201 void RCmConnectionMethodApi::ConnectAndCreateConnMethodToDestL(

   202         const RSessionBase& aSession,

   203         const TInt aDestHandle,

   204         const TUint32 aBearerType )

   205     {

   206     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODFROMDESTL_ENTRY );

   207 

   208     if ( iSessionConnected )

   209         {

   210         User::Leave( KErrAlreadyExists );

   211         }

   212 

   213     TIpcArgs args( aDestHandle, aBearerType );

   214     User::LeaveIfError( CreateSubSession( aSession, ECMCreateConnMethodToDest, args ) );

   215     iSessionConnected = ETrue;

   216 

   217     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODFROMDESTL_EXIT );

   218     }

   219 

   220 void RCmConnectionMethodApi::ConnectAndCreateConnMethodToDestWithIdL(

   221         const RSessionBase& aSession,

   222         const TInt aDestHandle,

   223         const TUint32 aBearerType,

   224         const TUint32 aIapId )

   225     {

   226     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODFROMDESTWITHIDL_ENTRY );

   227 

   228     if ( iSessionConnected )

   229         {

   230         User::Leave( KErrAlreadyExists );

   231         }

   232 

   233     TIpcArgs args( aDestHandle, aBearerType, aIapId );

   234     User::LeaveIfError( CreateSubSession( aSession, ECMCreateConnMethodToDestWithId, args ) );

   235     iSessionConnected = ETrue;

   236 

   237     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CONNECTANDCREATECONNMETHODFROMDESTWITHIDL_EXIT );

   238     }

   239 

   240 void RCmConnectionMethodApi::Close()

   241     {

   242     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_CLOSE_ENTRY );

   243 

   244     if ( iSessionConnected )

   245         {

   246         CloseSubSession( ECMCloseConnMethod );

   247         iSessionConnected = EFalse;

   248         }

   249 

   250     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_CLOSE_EXIT );

   251     }

   252 

   253 TInt RCmConnectionMethodApi::GetIntAttribute(

   254         const TUint32 aAttribute,

   255         TUint32& aValue )

   256     {

   257     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_GETINTATTRIBUTE_ENTRY );

   258 

   259     TPckg<TUint32> pckg( aValue );

   260     TIpcArgs args( aAttribute, &pckg );

   261     TInt err = SendReceive( ECMGetIntAttribute, args );

   262 

   263     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_GETINTATTRIBUTE_EXIT );

   264     return err;

   265     }

   266 

   267 TInt RCmConnectionMethodApi::GetBoolAttribute(

   268         const TUint32 aAttribute,

   269         TBool& aValue )

   270     {

   271     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_GETBOOLATTRIBUTE_ENTRY );

   272 

   273     TPckg<TBool> pckg( aValue );

   274     TIpcArgs args( aAttribute, &pckg );

   275     TInt err = SendReceive( ECMGetBoolAttribute, args );

   276 

   277     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_GETBOOLATTRIBUTE_EXIT );

   278     return err;

   279     }

   280 

   281 TInt RCmConnectionMethodApi::GetStringAttribute(

   282         const TUint32 aAttribute,

   283         HBufC* aBuffer )

   284     {

   285     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_GETSTRINGATTRIBUTE_ENTRY );

   286 

   287     TPtr descriptor( aBuffer->Des() );

   288     TIpcArgs args( aAttribute, &descriptor );

   289     TInt err = SendReceive( ECMGetStringAttribute, args );

   290 

   291     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_GETSTRINGATTRIBUTE_EXIT );

   292     return err;

   293     }

   294 

   295 TInt RCmConnectionMethodApi::GetString8Attribute(

   296         const TUint32 aAttribute,

   297         HBufC8* aBuffer8 )

   298     {

   299     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_GETSTRING8ATTRIBUTE_ENTRY );

   300 

   301     TPtr8 descriptor( aBuffer8->Des() );

   302     TIpcArgs args( aAttribute, &descriptor );

   303     TInt err = SendReceive( ECMGetString8Attribute, args );

   304 

   305     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_GETSTRING8ATTRIBUTE_EXIT );

   306     return err;

   307     }

   308 

   309 TInt RCmConnectionMethodApi::SetIntAttribute(

   310         const TUint32 aAttribute,

   311         const TUint32 aValue )

   312     {

   313     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_SETINTATTRIBUTE_ENTRY );

   314 

   315     TIpcArgs args( aAttribute, aValue );

   316     TInt err = SendReceive( ECMSetIntAttribute, args );

   317 

   318     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_SETINTATTRIBUTE_EXIT );

   319     return err;

   320     }

   321 

   322 TInt RCmConnectionMethodApi::SetBoolAttribute(

   323         const TUint32 aAttribute,

   324         const TBool aValue )

   325     {

   326     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_SETBOOLATTRIBUTE_ENTRY );

   327 

   328     TIpcArgs args( aAttribute, aValue );

   329     TInt err = SendReceive( ECMSetBoolAttribute, args );

   330 

   331     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_SETBOOLATTRIBUTE_EXIT );

   332     return err;

   333     }

   334 

   335 TInt RCmConnectionMethodApi::SetStringAttribute(

   336         const TUint32 aAttribute,

   337         const TDesC16& aValue )

   338     {

   339     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_SETSTRINGATTRIBUTE_ENTRY );

   340 

   341     TIpcArgs args( aAttribute, &aValue );

   342     TInt err = SendReceive( ECMSetStringAttribute, args );

   343 

   344     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_SETSTRINGATTRIBUTE_EXIT );

   345     return err;

   346     }

   347 

   348 TInt RCmConnectionMethodApi::SetString8Attribute(

   349         const TUint32 aAttribute,

   350         const TDesC8& aValue )

   351     {

   352     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_SETSTRING8ATTRIBUTE_ENTRY );

   353 

   354     TIpcArgs args( aAttribute, &aValue );

   355     TInt err = SendReceive( ECMSetString8Attribute, args );

   356 

   357     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_SETSTRING8ATTRIBUTE_EXIT );

   358     return err;

   359     }

   360 

   361 TInt RCmConnectionMethodApi::Update()

   362     {

   363     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_UPDATE_ENTRY );

   364 

   365     TInt err = SendReceive( ECMUpdate );

   366 

   367     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_UPDATE_EXIT );

   368     return err;

   369     }

   370 

   371 TInt RCmConnectionMethodApi::Refresh()

   372     {

   373     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_REFRESH_ENTRY );

   374 

   375     TInt err = SendReceive( ECMRefresh );

   376 

   377     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_REFRESH_EXIT );

   378     return err;

   379     }

   380 

   381 TInt RCmConnectionMethodApi::Delete( TBool& aResult )

   382     {

   383     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_DELETE_ENTRY );

   384 

   385     TPckg<TBool> pckg( aResult );

   386     TIpcArgs args( &pckg );

   387     TInt err = SendReceive( ECMDelete, args );

   388 

   389     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_DELETE_EXIT );

   390     return err;

   391     }

   392 

   393 TInt RCmConnectionMethodApi::IsEqual( const TInt aHandle, TBool& aResult )

   394     {

   395     OstTraceFunctionEntry0( RCMCONNECTIONMETHODAPI_ISEQUAL_ENTRY );

   396 

   397     TPckg<TBool> pckg( aResult );

   398     TIpcArgs args( aHandle, &pckg );

   399     TInt err = SendReceive( ECMIsEqual, args );

   400 

   401     OstTraceFunctionExit0( RCMCONNECTIONMETHODAPI_ISEQUAL_EXIT );

   402     return err;

   403     }

   404 

   405 // End of file