1 /*

     2 * Copyright (c) 2005-2006 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 the License "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:  describes system information utilities.

    15 *

    16 */

    17 

    18 

    19 #ifndef __SYSINFO_H__

    20 #define __SYSINFO_H__

    21 

    22 #include <BADESCA.H>

    23 #include <f32file.h>

    24 #include <AccPolGenericIDArray.h>

    25 #include <etelmm.h>

    26 

    27 class ISystemObserver;

    28 

    29 

    30 /**

    31 *   @ref CSysData is base class which can be extend to implement variety of 

    32 *   system data representations.

    33 *

    34 *  @lib sysinfoservice.lib

    35 *  @since S60 3.2

    36 */

    37 NONSHARABLE_CLASS(CSysData) : public CBase

    38     {

    39     public:

    40     // Enumeration of supported i/o data types.

    41     enum TDataType

    42         {

    43         EStatus,

    44         EVersion,

    45         EConnectionList,

    46         EConnectionInfo,

    47         ENetworkInfo,

    48         EDriveInfo,

    49         ELanguageList,

    50         EDriveList,

    51         EAccessoryList,

    52         EAccessoryInfo,

    53         EResolution,

    54         EStringList,

    55         EStringData,

    56         };

    57     public:

    58     /**

    59     * virtual Destructor.

    60     */

    61     virtual ~CSysData ();

    62 

    63     /**

    64     * @return type of data stored.

    65     */

    66     IMPORT_C TDataType DataType() const;

    67 

    68     protected:

    69 

    70     /**

    71     * C++ default constructor.

    72     */

    73     CSysData(TDataType aType);		

    74     private:

    75 

    76     /**

    77     * Data type

    78     */

    79     TDataType   iDataType;

    80     };

    81 

    82 /**

    83 *  @ref CStatus is an integer data used in general for representing status 

    84 *   information of some System Attributes. Typically ON,OFF state, battery 

    85 *   level and so on.

    86 *

    87 *  @lib sysinfoservice.lib

    88 *  @since S60 3.2

    89 */

    90 NONSHARABLE_CLASS(CStatus) : public CSysData

    91     {

    92     public:

    93 

    94     /**

    95     * Two-phased constructor.

    96     *

    97     * @return A new instance of this class.

    98     */    

    99     IMPORT_C static CStatus* NewL(TInt aStatus);

   100 

   101     /**

   102     * @return   status information

   103     */    

   104     IMPORT_C TInt Status() const;

   105 

   106     /**

   107     * Destructor.

   108     */

   109     ~CStatus();

   110 

   111     private:

   112 

   113     /**

   114     * C++ default constructor.

   115     */

   116     CStatus(TInt aStatus);

   117 

   118     private:

   119     /**

   120     * Status value.

   121     */

   122     TInt    iStatus;

   123     };

   124 

   125 /**

   126 *  @ref CResolution screen resolution of device specified in X,Y Pixels.

   127 *

   128 *  @lib sysinfoservice.lib

   129 *  @since S60 3.2

   130 */

   131 NONSHARABLE_CLASS(CResolution) : public CSysData

   132     {

   133     public:

   134 

   135     /**

   136     * Two-phased constructor.

   137     *

   138     * @return A new instance of this class.

   139     */    

   140     static CResolution* NewL(TInt aXPixels, TInt aYPixels);

   141 

   142     /**

   143     * @return X-Pixels.

   144     */

   145     IMPORT_C TInt XPixels() const;

   146 

   147     /**

   148     * @return Y-Pixels.

   149     */

   150     IMPORT_C TInt YPixels() const;

   151 

   152     /**

   153     * Destructor.

   154     */

   155     ~CResolution();

   156 

   157     private:

   158     /**

   159     * C++ default constructor.

   160     */

   161     CResolution (TInt aXPixels, TInt aYPixels);

   162 

   163     private:

   164     /**

   165     * X-Pixels.

   166     */

   167     TInt    iXPixels;

   168     /**

   169     * Y-Pixels.

   170     */

   171     TInt    iYPixels;

   172     };

   173 

   174 /**

   175 *  @ref CAccessoryInfo provides accessory information i.e  ACCESSORY TYPE

   176 *  @ref TAccessoryType and its connection status @ref TAccessoryState.

   177 *

   178 *  @lib sysinfoservice.lib

   179 *  @since S60 3.2

   180 */

   181 NONSHARABLE_CLASS(CAccessoryInfo):public CSysData

   182     {

   183     public:

   184 

   185     typedef	enum{

   186         /** Unknown. */

   187         EUnknown=-1,

   188         /** Headset */

   189         EHeadSet,

   190         /** Bluetooth headset */

   191         EBTHeadSet,

   192         /** Carkit */

   193         ECarKit,

   194         /** Bluetooth carkit */

   195         EBTCarKit

   196         }TAccessoryType;

   197     

   198     typedef enum{

   199         /** Accessory connected */

   200         EDisconnected,

   201         /** Accessory disconnected */

   202         EConnected

   203         }TAccessoryState;

   204 

   205     public:

   206 

   207     /**

   208     * Two-phased constructor.

   209     *

   210     * @return A new instance of this class.

   211     */    

   212     static CAccessoryInfo* NewL(const TAccPolGenericID& aGenericID, 

   213                                         TAccessoryState aAccState);

   214 

   215     /**

   216     * Destructor.

   217     */

   218     ~CAccessoryInfo();

   219     

   220     public:

   221     /**

   222     * @return ACCESSORY TYPE

   223     */

   224     IMPORT_C TInt AccessoryType() const;

   225     /**

   226     * @return Connection state.

   227     */

   228     IMPORT_C TInt ConnectionState() const;

   229 

   230     private:

   231     /**

   232     * C++ default constructor.

   233     */

   234     CAccessoryInfo(TAccessoryState aAccState);

   235     /**

   236     * Deduce accessory type from aGenericID.

   237     */

   238     void GetAccessoryProperty( const TAccPolGenericID& aGenericID );

   239 

   240     private:

   241     /**

   242     * Accessory type

   243     */

   244     TInt    iAccessoryType;

   245     /**

   246     * Connection State.

   247     */

   248     TInt    iConnectionState;

   249     };

   250 

   251 /**

   252 *  @ref CAccList provides access to read list of accessories.

   253 *

   254 *  @lib sysinfoservice.lib

   255 *  @since S60 3.2

   256 */

   257 NONSHARABLE_CLASS(CAccList): public CSysData

   258     {

   259     public:

   260     /**

   261     * Two-phased constructor.

   262     *

   263     * @return A new instance of this class.

   264     */    

   265     static CAccList* NewL();

   266 

   267     /**

   268     * @return @ref CAccessoryInfo client owns created instance.

   269     */

   270     IMPORT_C const CAccessoryInfo* operator[](TInt aIndex) const;

   271 

   272     /**

   273     * On return aAccInfo has new CAccessoryInfo instance ownership given to

   274     * client.

   275     */

   276     IMPORT_C TBool AtL(TInt aIndex,const CAccessoryInfo*& aAccInfo) const;

   277 

   278     /**

   279     * @return number of accessories in the list.

   280     */

   281     IMPORT_C TInt Count () const;

   282 

   283     /**

   284     * Destructor.

   285     */

   286     ~CAccList();

   287     private:

   288 

   289     /**

   290     * C++ default constructor.

   291     */

   292     CAccList();

   293     /**

   294     * Symbian 2nd phase constructor.

   295     */

   296     void ConstructL();

   297     

   298     private:

   299     /**

   300     * Accessory ID Array.

   301     */

   302     TAccPolGenericIDArray   iAccessories;

   303 

   304     /**

   305     * number of accessories.

   306     */

   307     TInt                    iCount;

   308     };

   309 

   310 /**

   311 *  @ref CStringData string data represented using this class.

   312 *

   313 *  @lib sysinfoservice.lib

   314 *  @since S60 3.2

   315 */

   316 NONSHARABLE_CLASS(CStringData): public CSysData

   317     {

   318     public:

   319     /**

   320     * Two-phased constructor.

   321     *

   322     * @return A new instance of this class.

   323     */    

   324     IMPORT_C static CStringData* NewL(const TDesC& aString);

   325 

   326     /**

   327     * On return aString contains string data.

   328     */

   329     IMPORT_C void StringData(TPtrC& aString) const;

   330 

   331     /**

   332     * Destructor.

   333     */

   334     ~CStringData();

   335 

   336     private:

   337     /**

   338     * C++ default constructor.

   339     */

   340     CStringData();

   341 

   342     private:

   343     /**

   344     * String data.

   345     */

   346     HBufC*      iStringData;

   347     }; 

   348 

   349 /**

   350 *  @ref CVersion Major and Minor version information.

   351 *

   352 *  @lib sysinfoservice.lib

   353 *  @since S60 3.2

   354 */

   355 NONSHARABLE_CLASS(CVersion): public CSysData

   356     {

   357     public:

   358     /**

   359     * Two-phased constructor.

   360     *

   361     * @return A new instance of this class.

   362     */    

   363     static CVersion* NewL(TInt aMajor,TInt aMinor);

   364 

   365     /**

   366     * @return Manjor Version number.

   367     */

   368     IMPORT_C TInt MajorVersion() const;

   369 

   370     /**

   371     * @return Minor Version number.

   372     */

   373     IMPORT_C TInt MinorVersion() const;

   374     /**

   375     * Destructor.

   376     */

   377     ~CVersion();

   378 

   379     private:

   380 

   381     /**

   382     * C++ default constructor.

   383     */

   384     CVersion(TInt aMajor,TInt aMinor);

   385 

   386     private:

   387     /**

   388     * Major Version.

   389     */

   390     TInt    iMajorVersion;

   391     /**

   392     * Minor Version.

   393     */

   394     TInt    iMinorVersion;

   395     }; 

   396 

   397 /**

   398 *  @ref CConnectionInfo provides access to read connection information i.e Connection type,

   399 * 	Access point ID, Network name and Access point name.

   400 *

   401 *  @lib sysinfoservice.lib

   402 *  @since S60 3.2

   403 */

   404 NONSHARABLE_CLASS(CConnectionInfo) : public CSysData

   405     {

   406     public:

   407     typedef enum{

   408         /** disconnected */

   409         EDisconnected,

   410         /** connected */

   411         EConnected

   412     }TConnectionState;

   413     

   414     /**

   415     * Two-phased constructor.

   416     *

   417     * @return A new instance of this class.

   418     */    

   419     IMPORT_C static CConnectionInfo* NewL(TUint aConnId, TUint aIAPId,

   420                                             TInt aBearerType,

   421                                             TConnectionState aConnectStatus,

   422                                             const TDesC& aIAPName,

   423                                             const TDesC& aNetworkName,

   424                                             const TDesC& aConnectionName);

   425 

   426     /**

   427     * Destructor.

   428     */

   429     ~CConnectionInfo();

   430 

   431     /**

   432     * @return A new instance of this class object.

   433     */    

   434     CConnectionInfo* CopyL();

   435 

   436     public:

   437     TUint ConnectionId() const;

   438 

   439     IMPORT_C TUint IAPId() const;

   440 

   441     IMPORT_C TInt BearerType()const;

   442 

   443     IMPORT_C TPtrC IAPName() const;

   444 

   445     IMPORT_C TPtrC NetworkName() const;

   446 

   447     IMPORT_C TPtrC ConnectionName() const;

   448 

   449     IMPORT_C TConnectionState ConnectionState() const;

   450 

   451     void SetConnectionState(CConnectionInfo::TConnectionState aState);

   452 

   453     private:

   454     /**

   455     * C++ default constructor.

   456     */

   457     CConnectionInfo ();

   458 

   459     /**

   460     * Symbian 2nd phase constructor.

   461     */

   462     void ConstructL(TUint aConnId, TUint aIAPId,

   463                         TInt aBearerType,

   464                         TConnectionState aConnectStatus,

   465                         const TDesC& aIAPName,

   466                         const TDesC& aNetworkName,

   467                         const TDesC& aConnectionName);

   468     private:

   469 

   470     TUint                   iConnectionId;

   471 

   472     TConnectionState        iConnectStatus;

   473 

   474     TUint                   iIAPId;

   475 

   476     TInt                    iBearerType;

   477 

   478     HBufC*                  iIAPName;

   479 

   480     HBufC*                  iNetworkName;

   481 

   482     HBufC*                  iConnectionName;

   483     };

   484 

   485 /**

   486 *  @ref CConnectionList this class lists connections. provides access to 

   487 *   each connection information.

   488 *

   489 *  @lib sysinfoservice.lib

   490 *  @since S60 3.2

   491 */

   492 NONSHARABLE_CLASS(CConnectionList) : public CSysData

   493     {

   494     public:

   495     /**

   496     * Two-phased constructor.

   497     *

   498     * @return A new instance of this class.

   499     */    

   500     static CConnectionList* NewL(

   501                     RPointerArray<CConnectionInfo>& aConnectionInfoArr);

   502     /**

   503     * Two-phased constructor.

   504     *

   505     * @return A new instance of this class.

   506     */    

   507     static CConnectionList* NewLC(

   508                     RPointerArray<CConnectionInfo>& aConnectionInfoArr);

   509     /**

   510     * On return aConnectionInfo contains connection information. aConnectionInfo  

   511     * ownership not given to user.

   512     */

   513     IMPORT_C TBool At(TInt aIndex,const CConnectionInfo*& aConnectionInfo) const;

   514 

   515     /**

   516     * @return ConnectionInfo at index.

   517     */

   518     IMPORT_C const CConnectionInfo* operator[](TInt aIndex) const;

   519     /**

   520     * @return number of connections.

   521     */

   522     IMPORT_C TInt Count() const;

   523 

   524     /**

   525     * Destructor.

   526     */

   527     ~CConnectionList();

   528     

   529     private:

   530     /**

   531     * C++ default constructor.

   532     */

   533     CConnectionList();

   534     /**

   535     * Symbian 2nd phase constructor.

   536     */

   537     void ConstructL(RPointerArray<CConnectionInfo>& aConnectionInfoArr);

   538     

   539     private:

   540     // Pointer Array to hold list of connections.

   541     RPointerArray<CConnectionInfo> iConnectionInfoArray;

   542     // Number of Connections.

   543     TInt                            iCount;

   544     };

   545 

   546 /**

   547 *  @ref CNetworkInfo client interface to read network details ie, Network name,

   548 *	network type, status, MCC (Mobile Country Code), MNC (Mobile Network Code),

   549 *	LAC (Location Area Code) and CellID.

   550 *

   551 *  @lib sysinfoservice.lib

   552 *  @since S60 3.2

   553 */

   554 NONSHARABLE_CLASS(CNetworkInfo): public CSysData

   555     {

   556     public:

   557 

   558     /**

   559     * Two-phased constructor.

   560     *

   561     * @return A new instance of this class.

   562     */    

   563     static CNetworkInfo* NewL(RMobilePhone::TMobilePhoneNetworkInfoV1& aNetworkInfo,

   564                                     RMobilePhone::TMobilePhoneLocationAreaV1& aArea);

   565 

   566     /**

   567     * Destructor.

   568     */

   569     ~CNetworkInfo();

   570     

   571     public:

   572     /**

   573     * @return Network name.

   574     */

   575     IMPORT_C TPtrC NetworkName() const;

   576     /**

   577     * @return Network Mode.

   578     */		

   579     IMPORT_C TInt NetworkMode()const;

   580     /**

   581     * @return Network Status.

   582     */

   583     IMPORT_C TInt NetworkStatus() const;

   584     /**

   585     * @return MCC Mobile Country Code.

   586     */

   587     IMPORT_C TPtrC CountryCode() const;

   588     /**

   589     * @return MNC Mobile Network Code.

   590     */

   591     IMPORT_C TPtrC NetworkCode() const;

   592     /**

   593     * @return LAC Location Area Code.

   594     */

   595     IMPORT_C TUint LocationAreaCode() const;

   596     /**

   597     * @return CellID

   598     */

   599     IMPORT_C TUint CellId() const;

   600     /**

   601     * @return Identifier for validating LAC & CellID

   602     */

   603     IMPORT_C TBool ValidLocationAreaCode() const;

   604 

   605     private:

   606     /**

   607     * C++ default constructor.

   608     */

   609     CNetworkInfo(RMobilePhone::TMobilePhoneNetworkInfoV1& aNetworkInfo,

   610                     RMobilePhone::TMobilePhoneLocationAreaV1& aArea);

   611     private:

   612     //Network Information

   613     RMobilePhone::TMobilePhoneNetworkInfoV1  iNetworkInfo;

   614     //Location information.

   615     RMobilePhone::TMobilePhoneLocationAreaV1 iLAC;

   616     };

   617 

   618 /**

   619 *  @ref CLanguageList language list class

   620 *

   621 *  @lib sysinfoservice.lib

   622 *  @since S60 3.2

   623 */

   624 NONSHARABLE_CLASS(CLanguageList): public CSysData

   625     {

   626     public:

   627     /**

   628     * Two-phased constructor.

   629     *

   630     * @return A new instance of this class.

   631     */    

   632     static CLanguageList* NewL();

   633     /**

   634     * @return Language Code.

   635     */

   636     IMPORT_C TInt operator[](TInt aIndex) const;

   637     /**

   638     * On return aEntry contains Language Code.

   639     */

   640     IMPORT_C TBool At(TInt aIndex, TInt& aEntry) const;

   641     /**

   642     * @return language count.

   643     */

   644     IMPORT_C TInt Count() const;

   645 

   646     /**

   647     * Destructor.

   648     */

   649     ~CLanguageList();

   650 

   651     private:

   652     /**

   653     * C++ default constructor.

   654     */

   655     CLanguageList();

   656     /**

   657     * Symbian 2nd phase constructor.

   658     */

   659     void ConstructL();

   660 

   661     private:

   662     /**

   663     * array consists of language codes.

   664     */

   665     RArray<TInt>    iLanguages;

   666     };

   667 

   668 /**

   669 *  @ref CDriveList drive list.

   670 *

   671 *  @lib sysinfoservice.lib

   672 *  @since S60 3.2

   673 */

   674 NONSHARABLE_CLASS(CDriveList): public CSysData

   675     {

   676     public:

   677     /**

   678     * Two-phased constructor.

   679     *

   680     * @return A new instance of this class.

   681     */    

   682     static CDriveList* NewL(TDriveList& aDrives);

   683     /**

   684     * @return drive number.

   685     */

   686     IMPORT_C TInt operator[](TInt aIndex) const;

   687     /**

   688     * On return aEntry contains drive number.

   689     */

   690     IMPORT_C TBool At(TInt aIndex, TInt& aEntry) const;

   691     /**

   692     * @return number of drives.

   693     */

   694     IMPORT_C TInt Count() const;

   695 

   696     /**

   697     * Destructor.

   698     */

   699     ~CDriveList();

   700 

   701     private:

   702     /**

   703     * C++ default constructor.

   704     */

   705     CDriveList();

   706     /**

   707     * Symbian 2nd phase constructor.

   708     */

   709     void ConstructL(TDriveList& aDrives);

   710 

   711     private:

   712     RArray<TInt>    iDrives;

   713     TInt            iCount;

   714     };

   715 

   716 /**

   717 *   @ref CDriveInfo details drive information ie, Drive name, Total space, 

   718 *   Free space, Media type, critical free space and battery status.

   719 *

   720 *  @lib sysinfoservice.lib

   721 *  @since S60 3.2

   722 */

   723 NONSHARABLE_CLASS(CDriveInfo): public CSysData

   724     {

   725     public:

   726     /**

   727     * Two-phased constructor.

   728     *

   729     * @return A new instance of this class.

   730     */    

   731     IMPORT_C static CDriveInfo* NewL(TInt aDriveNumber, TInt aCriticalSpace=-1);

   732 

   733     /**

   734     * Two-phased constructor.

   735     *

   736     * @return A new instance of this class.

   737     */    

   738     static CDriveInfo* NewL(TInt aDriveNumber, TVolumeInfo& aVolumeInfo);

   739 

   740     /**

   741     * Destructor.

   742     */

   743     ~CDriveInfo();

   744     public:

   745     IMPORT_C TInt DriveNumber() const;

   746     IMPORT_C TInt CriticalSpace() const;

   747     IMPORT_C TInt MediaType() const;

   748     IMPORT_C TInt64 TotalSpace() const;

   749     IMPORT_C TInt64 FreeSpace() const;

   750     IMPORT_C void DriveName(TPtrC& aDriveName) const;

   751     IMPORT_C TInt BatteryState() const;

   752 

   753     private:

   754     /**

   755     * C++ default constructor.

   756     */

   757     CDriveInfo(TInt aDrvNumber,TInt aCriticalSpace);

   758     /**

   759     * C++ default constructor.

   760     */

   761     CDriveInfo(TInt aDrvNumber,TVolumeInfo& aVolumeInfo);

   762     /**

   763     * Symbian 2nd phase constructor.

   764     */

   765     void ConstructL();

   766 

   767     private:

   768     TInt            iDrvNumber;

   769     TVolumeInfo     iVolumeInfo;

   770     TInt            iVolumeInfoValid;

   771     TInt            iCriticalSpace;

   772     };

   773 

   774 /**

   775 *  @ref CStringList list of strings

   776 *

   777 *  @lib sysinfoservice.lib

   778 *  @since S60 3.2

   779 */

   780 NONSHARABLE_CLASS(CStringList): public CSysData

   781     {

   782     public:

   783     /**

   784     * Two-phased constructor.

   785     *

   786     * @return A new instance of this class.

   787     */    

   788     static CStringList* NewL(CDesCArray*& aDesArray);

   789     /**

   790     * @return string data.

   791     */

   792     IMPORT_C TPtrC operator[](TInt aIndex) const;

   793     /**

   794     * @On return aEntry consists of string data.

   795     */

   796     IMPORT_C TBool At(TInt aIndex, TPtrC& aEntry) const;

   797     /**

   798     * @return number of strings.

   799     */		

   800     IMPORT_C TInt Count() const;

   801     /**

   802     * Destructor.

   803     */

   804     ~CStringList();

   805 

   806     private:

   807     /**

   808     * C++ default constructor.

   809     */

   810     CStringList(CDesCArray*& aDesArray);

   811     private:

   812     CDesCArray*     iDesArray;

   813     TInt            iCount;

   814     };

   815 

   816 

   817 #endif __SYSINFO_H__