ipcm_pub/connection_settings_api/inc/cmmanager.h
changeset 20 9c97ad6591ae
parent 0 5a93021fdf25
child 58 83ca720e2b9a
child 72 0c32cf868819
equal deleted inserted replaced
18:fcbbe021d614 20:9c97ad6591ae
     1 /*
     1 /*
     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 
     2 * Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
     3 * All rights reserved.
     3 * All rights reserved.
     4 * This component and the accompanying materials are made available
     4 * This component and the accompanying materials are made available
     5 * under the terms of "Eclipse Public License v1.0"
     5 * under the terms of "Eclipse Public License v1.0"
     6 * which accompanies this distribution, and is available
     6 * which accompanies this distribution, and is available
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     9 * Initial Contributors:
     9 * Initial Contributors:
    10 * Nokia Corporation - initial contribution.
    10 * Nokia Corporation - initial contribution.
    11 *
    11 *
    12 * Contributors:
    12 * Contributors:
    13 *
    13 *
    14 * Description:  Connection manager IF class.
    14 * Description:
       
    15 * Connection method manager IF class.
    15 *
    16 *
    16 */
    17 */
    17 
    18 
       
    19 
    18 #ifndef CMMANAGER_H
    20 #ifndef CMMANAGER_H
    19 #define CMMANAGER_H
    21 #define CMMANAGER_H
    20 
    22 
    21 // System Includes
       
    22 #include <e32std.h>
       
    23 #include <e32base.h>
    23 #include <e32base.h>
    24 #include <e32cmn.h>
       
    25 #include <cmdefconnvalues.h>
    24 #include <cmdefconnvalues.h>
    26 #include <cmgenconnsettings.h>
    25 #include <cmgenconnsettings.h>
    27 
    26 
    28 // Forward Declarations
    27 // Forward declarations
    29 class RCmConnectionMethod;
    28 class RCmConnectionMethod;
    30 class RCmDestination;
    29 class RCmDestination;
    31 class CCmManagerImpl;
       
    32 class TBearerPriority;
    30 class TBearerPriority;
    33 class CGulIcon;
    31 class RCmManagerApi;
       
    32 
    34 
    33 
    35 /**
    34 /**
    36  *  RCmManager gives access to network destinations and connection methods.
    35  *  RCmManager gives access to network destinations and connection methods.
    37  *
    36  *
    38  *  @lib cmmanager.lib
    37  *  @lib cmmanager.lib
    39  *  @since S60 v3.2
    38  *  @since S60 v3.2
    40  */
    39  */
    41 NONSHARABLE_CLASS(RCmManager)
    40 NONSHARABLE_CLASS( RCmManager )
    42       {          
    41     {
    43     //=====================================================================
       
    44     // Constructors/Destructors
       
    45     // 
       
    46     public:
    42     public:
    47     
    43         /**
    48         /**
    44         * Default constructor.
    49         * Default constructor. 
       
    50         */
    45         */
    51         inline RCmManager();
    46         inline RCmManager();
    52 
    47 
    53     //=====================================================================
       
    54     // API functions
       
    55     public:
       
    56         
       
    57         /**
    48         /**
    58         * Symbian constructor
    49         * Symbian constructor
    59         *
    50         *
    60         * @since S60 3.2
    51         * @since S60 3.2
    61         */
    52         */
    62         IMPORT_C void OpenL();    
    53         IMPORT_C void OpenL();
    63         
    54 
    64         /**
    55         /**
    65         * Symbian constructor
    56         * Symbian constructor
    66         * Pushes the object on the cleanup stack
    57         * Pushes the object on the cleanup stack
    67         *
    58         *
    68         * @since S60 3.2
    59         * @since S60 3.2
    69         */
    60         */
    70         IMPORT_C void OpenLC();    
    61         IMPORT_C void OpenLC();
    71         
    62 
    72         /**
    63         /**
    73         * Secondary destructor
    64         * Secondary destructor
    74         *
    65         *
    75         * @since S60 3.2
    66         * @since S60 3.2
    76         */
    67         */
    77         IMPORT_C void Close();
    68         IMPORT_C void Close();
    78         
    69 
    79     //=======================================================================
    70     public:
    80     // Getter API
       
    81     public:    
       
    82       
       
    83         /**
    71         /**
    84         * Used to query bearer information that doesn't belong
    72         * Used to query bearer information that doesn't belong
    85         * to a specific connection method, such as 
    73         * to a specific connection method, such as
    86         * ECmCoverage or ECmDefaultPriority etc.
    74         * ECmCoverage or ECmDefaultPriority etc.
    87         *
    75         *
    88         * @since S60 3.2
    76         * @since S60 3.2
    89         * @param aBearerType the bearer
    77         * @param aBearerType the bearer
    90         * @param aAttribute the setting value
    78         * @param aAttribute the setting value
    91         * @return the setting value
    79         * @return the setting value
    92         */
    80         */
    93         IMPORT_C TUint32 GetBearerInfoIntL( TUint32 aBearerType,
    81         IMPORT_C TUint32 GetBearerInfoIntL(
    94                                   TUint32 aAttribute ) const;
    82                 TUint32 aBearerType,
    95                                   
    83                 TUint32 aAttribute ) const;
    96         
    84 
    97         /**
    85         /**
    98         * Used to query bearer information that doesn't belong
    86         * Used to query bearer information that doesn't belong
    99         * to a specific connection method, such as 
    87         * to a specific connection method, such as
   100         * ECmCoverage or ECmDefaultPriority etc.
    88         * ECmCoverage or ECmDefaultPriority etc.
   101         *
    89         *
   102         * @since S60 3.2
    90         * @since S60 3.2
   103         * @param aBearerType the bearer
    91         * @param aBearerType the bearer
   104         * @param aAttribute the setting value
    92         * @param aAttribute the setting value
   105         * @return the setting value
    93         * @return the setting value
   106         */
    94         */
   107         IMPORT_C TBool GetBearerInfoBoolL( TUint32 aBearerType,
    95         IMPORT_C TBool GetBearerInfoBoolL(
   108                                  TUint32 aAttribute ) const;
    96                 TUint32 aBearerType,
       
    97                 TUint32 aAttribute ) const;
       
    98 
   109         /**
    99         /**
   110         * Used to query bearer information that doesn't belong
   100         * Used to query bearer information that doesn't belong
   111         * to a specific connection method, such as 
   101         * to a specific connection method, such as
   112         * ECmCoverage or ECmDefaultPriority etc.
   102         * ECmCoverage or ECmDefaultPriority etc.
   113         * HBuf ownership is passed to the caller
   103         * HBuf ownership is passed to the caller
   114         *
   104         *
   115         * @since S60 3.2
   105         * @since S60 3.2
   116         * @param aBearerType the bearer
   106         * @param aBearerType the bearer
   117         * @param aAttribute the setting value
   107         * @param aAttribute the setting value
   118         * @return the setting value
   108         * @return the setting value
   119         */        
   109         */
   120         IMPORT_C HBufC* GetBearerInfoStringL( TUint32 aBearerType,
   110         IMPORT_C HBufC* GetBearerInfoStringL(
   121                                     TUint32 aAttribute ) const;
   111                 TUint32 aBearerType,
       
   112                 TUint32 aAttribute ) const;
       
   113 
   122         /**
   114         /**
   123         * Used to query bearer information that does not belong
   115         * Used to query bearer information that does not belong
   124         * to a specific connection method, such as 
   116         * to a specific connection method, such as
   125         * ECmCoverage or ECmDefaultPriority, etc.
   117         * ECmCoverage or ECmDefaultPriority, etc.
   126         * HBuf ownership is passed to the caller
   118         * HBuf ownership is passed to the caller
   127         *
   119         *
   128         * @since S60 3.2
   120         * @since S60 3.2
   129         * @param aBearerType the bearer
   121         * @param aBearerType the bearer
   130         * @param aAttribute the setting value
   122         * @param aAttribute the setting value
   131         * @return the setting value
   123         * @return the setting value
   132         */
   124         */
   133         IMPORT_C HBufC8* GetBearerInfoString8L( TUint32 aBearerType,
   125         IMPORT_C HBufC8* GetBearerInfoString8L(
   134                                     TUint32 aAttribute ) const;
   126                 TUint32 aBearerType,
   135                     
   127                 TUint32 aAttribute ) const;
       
   128 
   136         /**
   129         /**
   137         * Used to query any non-bearer specific information about
   130         * Used to query any non-bearer specific information about
   138         * a given connection method. This can be e.g. ECmBearerType,
   131         * a given connection method. This can be e.g. ECmBearerType,
   139         * ECmName, ECmStartPage, etc.
   132         * ECmName, ECmStartPage, etc.
   140         *
   133         *
   141         * @since S60 3.2
   134         * @since S60 3.2
   142         * @param aIapId the connection method id
   135         * @param aIapId the connection method id
   143         * @param aAttribute the setting value
   136         * @param aAttribute the setting value
   144         * @return the setting value
   137         * @return the setting value
   145         */
   138         */
   146         IMPORT_C TUint32 GetConnectionMethodInfoIntL( TUint32 aIapId,
   139         IMPORT_C TUint32 GetConnectionMethodInfoIntL(
   147                                              TUint32 aAttribute ) const;
   140                 TUint32 aIapId,
   148         
   141                 TUint32 aAttribute ) const;
       
   142 
   149         /**
   143         /**
   150         * Used to query any, non-bearer specific information about
   144         * Used to query any, non-bearer specific information about
   151         * a given connection method. This can be e.g. ECmBearerType,
   145         * a given connection method. This can be e.g. ECmBearerType,
   152         * ECmName, ECmStartPage, etc.
   146         * ECmName, ECmStartPage, etc.
   153         *
   147         *
   154         * @since S60 3.2
   148         * @since S60 3.2
   155         * @param aIapId the connection method id
   149         * @param aIapId the connection method id
   156         * @param aAttribute the setting value
   150         * @param aAttribute the setting value
   157         * @return the setting value
   151         * @return the setting value
   158         */
   152         */
   159         IMPORT_C TBool GetConnectionMethodInfoBoolL( TUint32 aIapId,
   153         IMPORT_C TBool GetConnectionMethodInfoBoolL(
   160                                             TUint32 aAttribute ) const;
   154                 TUint32 aIapId,
       
   155                 TUint32 aAttribute ) const;
   161 
   156 
   162         /**
   157         /**
   163         * Used to query any non-bearer specific information about
   158         * Used to query any non-bearer specific information about
   164         * a given connection method. This can be e.g. ECmBearerType,
   159         * a given connection method. This can be e.g. ECmBearerType,
   165         * ECmName, ECmStartPage, etc.
   160         * ECmName, ECmStartPage, etc.
   168         * @since S60 3.2
   163         * @since S60 3.2
   169         * @param aIapId the connection method id
   164         * @param aIapId the connection method id
   170         * @param aAttribute the setting value
   165         * @param aAttribute the setting value
   171         * @return the setting value
   166         * @return the setting value
   172         */
   167         */
   173         IMPORT_C HBufC* GetConnectionMethodInfoStringL( TUint32 aIapId,
   168         IMPORT_C HBufC* GetConnectionMethodInfoStringL(
   174                                                TUint32 aAttribute ) const;
   169                 TUint32 aIapId,
       
   170                 TUint32 aAttribute ) const;
   175 
   171 
   176         /**
   172         /**
   177         * Used to query any non-bearer specific information about
   173         * Used to query any non-bearer specific information about
   178         * a given connection method. This can be e.g. ECmBearerType,
   174         * a given connection method. This can be e.g. ECmBearerType,
   179         * ECmName, ECmStartPage, etc.
   175         * ECmName, ECmStartPage, etc.
   182         * @since S60 3.2
   178         * @since S60 3.2
   183         * @param aIapId the connection method id
   179         * @param aIapId the connection method id
   184         * @param aAttribute the setting value
   180         * @param aAttribute the setting value
   185         * @return the setting value
   181         * @return the setting value
   186         */
   182         */
   187         IMPORT_C HBufC8* GetConnectionMethodInfoString8L( TUint32 aIapId,
   183         IMPORT_C HBufC8* GetConnectionMethodInfoString8L(
   188                                                TUint32 aAttribute ) const;
   184                 TUint32 aIapId,
   189                 
   185                 TUint32 aAttribute ) const;
       
   186 
   190         /**
   187         /**
   191         * Returns the connection method queried by its ID
   188         * Returns the connection method queried by its ID
   192         *
   189         *
   193         * @since S60 3.2
   190         * @since S60 3.2
   194         * @param aConnectionMethodId id of the connection method
   191         * @param aConnectionMethodId id of the connection method
   195         * @return RCmConnectionMethod connection method
   192         * @return RCmConnectionMethod connection method
   196         */
   193         */
   197         IMPORT_C RCmConnectionMethod ConnectionMethodL( 
   194         IMPORT_C RCmConnectionMethod ConnectionMethodL(
   198                                      TUint32 aConnectionMethodId ) const;
   195                 TUint32 aConnectionMethodId ) const;
   199                         
   196 
   200         /**
   197         /**
   201         * Returns the list of connection methods. Connection Methods are 
   198         * Returns the list of connection methods. Connection Methods are
   202         * filtered by the switch parameters e.g. aLegacyOnly.
   199         * filtered by the switch parameters e.g. aLegacyOnly.
   203         *
   200         *
   204         * @since S60 3.2
   201         * @since S60 3.2
   205         * @param aCMArray on return it is the array of IAP ids.
   202         * @param aCMArray on return it is the array of IAP ids.
   206         * @param aCheckBearerType If ETrue only connection methods with 
   203         * @param aCheckBearerType If ETrue only connection methods with
   207         *                         supported bearer type are returned
   204         *                         supported bearer type are returned
   208         * @param aLegacyOnly when set to ETrue only Legacy IAP ids will
   205         * @param aLegacyOnly when set to ETrue only Legacy IAP ids will
   209         *                         be returned
   206         *                         be returned
   210         * @param aEasyWlan when set to ETrue EasyWlan id is returned, too
   207         * @param aEasyWlan when set to ETrue EasyWlan id is returned, too
   211         */
   208         */
   212         IMPORT_C void ConnectionMethodL( RArray<TUint32>& aCMArray, 
   209         IMPORT_C void ConnectionMethodL(
   213                                          TBool aCheckBearerType = ETrue,
   210                 RArray<TUint32>& aCmArray,
   214                                          TBool aLegacyOnly = ETrue,
   211                 TBool aCheckBearerType = ETrue,
   215                                          TBool aEasyWlan = EFalse ) const;
   212                 TBool aLegacyOnly = ETrue,
   216         
   213                 TBool aEasyWlan = EFalse ) const;
       
   214 
   217         /**
   215         /**
   218         * Returns an array of all destination id's
   216         * Returns an array of all destination id's
   219         *
   217         *
   220         * @since S60 3.2
   218         * @since S60 3.2
   221         * @param aDestArray list all available destinations' id
   219         * @param aDestArray list all available destinations' id
   222         */ 
   220         */
   223         IMPORT_C void AllDestinationsL( RArray<TUint32>& aDestArray ) const;
   221         IMPORT_C void AllDestinationsL( RArray<TUint32>& aDestArray ) const;
   224 
   222 
   225         /**
   223         /**
   226         * Returns the destination to which a specified 
   224         * Returns the destination to which a specified
   227         * connection method belongs, search is by destination ID
   225         * connection method belongs, search is by destination ID
   228         *
   226         *
   229         * @since S60 3.2
   227         * @since S60 3.2
   230         * @param aDestinationId id of destination
   228         * @param aDestinationId id of destination
   231         * @return RCmDestination network destination 
   229         * @return RCmDestination network destination
   232         */
   230         */
   233         IMPORT_C RCmDestination DestinationL( TUint32 aDestinationId ) const;
   231         IMPORT_C RCmDestination DestinationL( TUint32 aDestinationId ) const;
   234        
   232 
   235         /**
   233         /**
   236         * Returns the copy of the bearer priority array. Ownership is passed.
   234         * Returns the copy of the bearer priority array. Ownership is passed.
   237         *
   235         *
   238         * @since S60 3.2
   236         * @since S60 3.2
   239         * @param aArray bearer priority array
   237         * @param aArray bearer priority array
   240         */          
   238         */
   241         IMPORT_C void BearerPriorityArrayL( 
   239         IMPORT_C void BearerPriorityArrayL(
   242                                    RArray<TBearerPriority>& aArray ) const;
   240                 RArray<TBearerPriority>& aArray ) const;
   243        
   241 
   244         /**
   242         /**
   245         * Clean up passed global bearer priority array. Delete
   243         * Clean up passed global bearer priority array. Delete
   246         * the elements and calls Reset and Close on the array.
   244         * the elements and calls Reset and Close on the array.
   247         *
   245         *
   248         * @since S60 3.2
   246         * @since S60 3.2
   249         * @param aArray array to be cleaned up
   247         * @param aArray array to be cleaned up
   250         */
   248         */
   251         IMPORT_C void CleanupGlobalPriorityArray( 
   249         IMPORT_C void CleanupGlobalPriorityArray(
   252                                    RArray<TBearerPriority>& aArray ) const;
   250                 RArray<TBearerPriority>& aArray ) const;
   253         
   251 
   254         /**
   252         /**
   255         * Returns the id of the EasyWlan connection method.
   253         * Returns the id of the EasyWlan connection method.
   256         *
   254         *
   257         * @since S60 3.2
   255         * @since S60 3.2
   258         * @return id of the EasyWLan connection method. 0 if not found.
   256         * @return id of the EasyWLan connection method. 0 if not found.
   259         */
   257         */
   260         IMPORT_C TUint32 EasyWlanIdL() const;
   258         IMPORT_C TUint32 EasyWlanIdL() const;
   261         
   259 
   262         /**
   260         /**
   263         * Returns the default connection method/SNAP.
   261         * Returns the default connection method/SNAP.
   264         *
   262         *
   265         * @since S60 3.2
   263         * @since S60 3.2
   266         */
   264         */
   267         IMPORT_C void ReadDefConnL( TCmDefConnValue& aDCSetting );
   265         IMPORT_C void ReadDefConnL( TCmDefConnValue& aDefConnSetting );
   268 
   266 
   269         /**
   267         /**
   270         * Stores the default connection method/SNAP.
   268         * Stores the default connection method/SNAP.
   271         *
   269         *
   272         * @since S60 3.2
   270         * @since S60 3.2
   273         */
   271         */
   274         IMPORT_C void WriteDefConnL( const TCmDefConnValue& aDCSetting );  
   272         IMPORT_C void WriteDefConnL( const TCmDefConnValue& aDefConnSetting );
   275 
   273 
   276 
   274 
   277         /**
   275         /**
   278         * Returns the general connection settings.
   276         * Returns the general connection settings.
   279         *
   277         *
   285         * Writes the general connection settings.
   283         * Writes the general connection settings.
   286         *
   284         *
   287         * @since S60 9.2
   285         * @since S60 9.2
   288         */
   286         */
   289         IMPORT_C void WriteGenConnSettingsL( const TCmGenConnSettings& aGenConnSettings );
   287         IMPORT_C void WriteGenConnSettingsL( const TCmGenConnSettings& aGenConnSettings );
   290         
   288 
   291         
   289 
   292         /** Open session and create tables if they don't exist*/
   290         /** Open session and create tables if they don't exist*/
   293         IMPORT_C void CreateTablesAndOpenL();    
   291         IMPORT_C void CreateTablesAndOpenL();
   294 
   292 
   295         /**
   293         /**
   296         * Creates a Destination with the passed name. 
   294         * Creates a Destination with the passed name.
   297         * @param aName the name of the new destination.
   295         * @param aName the name of the new destination.
   298         * @return RCmDestination new destination. ownership is passed to the 
   296         * @return RCmDestination new destination. ownership is passed to the
   299         * caller
   297         * caller
   300         */
   298         */
   301         IMPORT_C RCmDestination CreateDestinationL( const TDesC& aName );
   299         IMPORT_C RCmDestination CreateDestinationL( const TDesC& aName );
   302 
   300 
   303         /**
   301         /**
   304         * Creates a connection method does not belong to any destination
   302         * Creates a connection method does not belong to any destination
   305         * @param aImplementationUid - bearer type of the new connection method
   303         * @param aImplementationUid - bearer type of the new connection method
   306         * @return RCmConnectionMethod newly created connection method.
   304         * @return RCmConnectionMethod newly created connection method.
   307         */
   305         */
   308         IMPORT_C RCmConnectionMethod CreateConnectionMethodL( TUint32 aBearerType );        
   306         IMPORT_C RCmConnectionMethod CreateConnectionMethodL(
   309 
   307                 TUint32 aBearerType );
   310         /**
   308 
   311         * Copies a connection method belonging to one destination to 
   309         /**
       
   310         * Copies a connection method belonging to one destination to
   312         * another. The connection method becomes shared.
   311         * another. The connection method becomes shared.
   313         * Calls UpdateL on the destination
   312         * Calls UpdateL on the destination
   314         * @param aTargetDestination
   313         * @param aTargetDestination
   315         * @param aConnectionMethodId
   314         * @param aConnectionMethodId
   316         * @return TInt - index in the Connection Method list
   315         * @return TInt - index in the Connection Method list
   317         */
   316         */
   318         IMPORT_C TInt CopyConnectionMethodL( RCmDestination& aTargetDestination,
   317         IMPORT_C TInt CopyConnectionMethodL(
   319                                              RCmConnectionMethod& aConnectionMethod );
   318                 RCmDestination& aTargetDestination,
   320 
   319                 RCmConnectionMethod& aConnectionMethod );
   321         /**
   320 
   322         * Moves a connection method belonging to one destination to 
   321         /**
       
   322         * Moves a connection method belonging to one destination to
   323         * another. The connection method is removed from the source destination
   323         * another. The connection method is removed from the source destination
   324         * @param aSourceDestination
   324         * @param aSourceDestination
   325         * @param aTargetDestination
   325         * @param aTargetDestination
   326         * @param aConnectionMethod
   326         * @param aConnectionMethod
   327         * @return TInt - index in the Connection Method list
   327         * @return TInt - index in the Connection Method list
   328         */
   328         */
   329         IMPORT_C TInt MoveConnectionMethodL( RCmDestination& aSourceDestination,
   329         IMPORT_C TInt MoveConnectionMethodL(
   330                                              RCmDestination& aTargetDestination,
   330                 RCmDestination& aSourceDestination,
   331                                              RCmConnectionMethod& aConnectionMethod );
   331                 RCmDestination& aTargetDestination,
       
   332                 RCmConnectionMethod& aConnectionMethod );
   332 
   333 
   333         /**
   334         /**
   334         * Remove connection method from the destination
   335         * Remove connection method from the destination
   335         * @param aDestination destination the connection method is attached to
   336         * @param aDestination destination the connection method is attached to
   336         * @param aConnectionMethod connection method to be removed
   337         * @param aConnectionMethod connection method to be removed
   337         */
   338         */
   338         IMPORT_C void RemoveConnectionMethodL( RCmDestination& aDestination,
   339         IMPORT_C void RemoveConnectionMethodL(
   339                                                RCmConnectionMethod& aConnectionMethod );
   340                 RCmDestination& aDestination,
   340 
   341                 RCmConnectionMethod& aConnectionMethod );
   341         /**
   342 
   342         * Removes connection method from every destination and make it 
   343         /**
       
   344         * Removes connection method from every destination and make it
   343         * uncategorized.
   345         * uncategorized.
   344         * @param aConnectionMethod connection method to be removed
   346         * @param aConnectionMethod connection method to be removed
   345         */
   347         */
   346         IMPORT_C void RemoveAllReferencesL( RCmConnectionMethod& aConnectionMethod );
   348         IMPORT_C void RemoveAllReferencesL(
       
   349                 RCmConnectionMethod& aConnectionMethod );
   347 
   350 
   348         /**
   351         /**
   349         * Update bearer priority array
   352         * Update bearer priority array
   350         * @param aArray array with new global bearer priority
   353         * @param aArray array with new global bearer priority
   351         */          
   354         */
   352         IMPORT_C void UpdateBearerPriorityArrayL( const RArray<TBearerPriority>& aArray );
   355         IMPORT_C void UpdateBearerPriorityArrayL(
   353 
   356                 const RArray<TBearerPriority>& aArray );
   354         /**
   357 
   355         * Creates a Destination with the passed name and id. 
   358         /**
       
   359         * Creates a Destination with the passed name and id.
   356         * @param aName the name of the new destination.
   360         * @param aName the name of the new destination.
   357         * @param aDestId Predefined id of the destination.
   361         * @param aDestId Predefined id of the destination.
   358         * @return RCmDestination newly created destination or leaves with
   362         * @return RCmDestination newly created destination or leaves with
   359         * KErrAlreadyExists if there exists CM with the same Id.
   363         * KErrAlreadyExists if there exists CM with the same Id.
   360         * Ownership is passed to the caller.
   364         * Ownership is passed to the caller.
   361         */
   365         */
   362         IMPORT_C RCmDestination CreateDestinationL( const TDesC& aName,
   366         IMPORT_C RCmDestination CreateDestinationL(
   363                                                        TUint32      aDestId );
   367                 const TDesC& aName,
       
   368                 TUint32 aDestId );
   364 
   369 
   365         /**
   370         /**
   366         * Creates a connection method does not belong to any destination
   371         * Creates a connection method does not belong to any destination
   367         * @param aImplementationUid - bearer type of the new connection
   372         * @param aImplementationUid - bearer type of the new connection
   368         * method
   373         * method
   369         * @param aConnMethodId Predefined id for the connection method.
   374         * @param aConnMethodId Predefined id for the connection method.
   370         * @return RCmConnectionMethod newly created connection
   375         * @return RCmConnectionMethod newly created connection
   371         * method or leaves with KErrAlreadyExists if there exists CM
   376         * method or leaves with KErrAlreadyExists if there exists CM
   372         * with the same Id.
   377         * with the same Id.
   373         */
   378         */
   374         IMPORT_C RCmConnectionMethod CreateConnectionMethodL( TUint32 aImplementationUid,
   379         IMPORT_C RCmConnectionMethod CreateConnectionMethodL(
   375                                                               TUint32 aConnMethodId );
   380                 TUint32 aBearerType,
       
   381                 TUint32 aConnMethodId );
   376 
   382 
   377         /**
   383         /**
   378         * Query all of the supported bearer types.
   384         * Query all of the supported bearer types.
   379         * @param aArray list of all supported bearer types.
   385         * @param aArray list of all supported bearer types.
   380         */          
   386         */
   381         IMPORT_C void SupportedBearersL( RArray<TUint32>& aArray ) const;
   387         IMPORT_C void SupportedBearersL( RArray<TUint32>& aArray ) const;
   382 
   388 
   383         /**
   389         /**
   384         * Returns "Uncategorized" icon.
   390          * Gets the "Uncategorized" icon identifier(name). It can
   385         * This fucton leaves if the client does not have a valid UI context
   391          * contain path information. HBufC* ownership is passed to the caller.
   386         * @return CGulIcon* Icon of uncategorized connection methods. Ownership 
   392          * @return Returns pointer to a buffer which identifies the requested
   387         * is passed.
   393          * icon.
   388         */          
   394          */
   389         IMPORT_C CGulIcon* UncategorizedIconL() const;
   395         IMPORT_C HBufC* GetUncategorizedIconL() const;
   390         
   396 
       
   397 
   391     private:
   398     private:
   392         /**
   399         /**
   393         * This is a private copy constructor without implementation.
   400         * This is a private copy constructor without implementation.
   394         * The sole purpose of this declaration is to forbid the copying of 
   401         * The sole purpose of this declaration is to forbid the copying of
   395         * the objects of this class.
   402         * the objects of this class.
   396         */          
   403         */
   397         RCmManager(RCmManager&  );
   404         RCmManager( RCmManager& );
       
   405 
   398         /**
   406         /**
   399         * This is a private copy constructor without implementation.
   407         * This is a private copy constructor without implementation.
   400         * The sole purpose of this declaration is to forbid the copying of 
   408         * The sole purpose of this declaration is to forbid the copying of
   401         * the objects of this class.
   409         * the objects of this class.
   402         */          
   410         */
   403         RCmManager& operator=( RCmManager& );
   411         RCmManager& operator=( RCmManager& );
   404     //=========================================================================
   412 
   405     // Member data
       
   406     
       
   407     private:
   413     private:
   408     
   414         RCmManagerApi* iCmManagerApi;
   409         /**
       
   410          * the implementation class
       
   411          */
       
   412         CCmManagerImpl* iImplementation;
       
   413     };
   415     };
   414 
   416 
   415 #include "cmmanager.inl"
   417 
   416     
   418 inline RCmManager::RCmManager() : iCmManagerApi( NULL )
       
   419     {
       
   420     }
       
   421 
       
   422 
   417 #endif // CMMANAGER_H
   423 #endif // CMMANAGER_H
       
   424 
       
   425 // End of file