sysstatemgmt/systemstatereferenceplugins/custcmd/src/ssmuiproviderdlldefault.cpp
branchRCL_3
changeset 22 8cb079868133
parent 21 ccb4f6b3db21
equal deleted inserted replaced
21:ccb4f6b3db21 22:8cb079868133
    20 
    20 
    21 #include "ssmuiproviderdll.h"
    21 #include "ssmuiproviderdll.h"
    22 #include "ssmpanic.h"
    22 #include "ssmpanic.h"
    23 #include <e32property.h>
    23 #include <e32property.h>
    24 #include "ssmdebug.h"
    24 #include "ssmdebug.h"
    25 #include <f32file.h>
    25 
    26 #include <ctsydomainpskeys.h>
    26 const TUid KPSStartupUid = {0x2000E65E};
    27 #include <mmtsy_names.h>
       
    28 #include <pathinfo.h>
       
    29 #include <securitynotification.h>
       
    30 #include <ssm/ssmstate.h>
       
    31 #include <startupdomainpskeys.h>
       
    32 #include "ssmmapperutilitystatic.h"
       
    33 #include "ssmmapperutilityinternalpskeys.h"
       
    34 #include "ssmsubstateext.hrh"
       
    35 #include "ssmswp.hrh"
       
    36 #include "trace.h"
       
    37 
       
    38 const TUid KPSStartupDefaultUid = {0x2000E65E};
       
    39 const TUid KSecurityPinNotifierUid = {0x2000E667};
    27 const TUid KSecurityPinNotifierUid = {0x2000E667};
    40 const TUid KScreenOutputChannel = {0x10009D48};
    28 const TUid KScreenOutputChannel = {0x10009D48};
    41 const TUid KEmergencyCallPropertyCategory = {0x2001032C};
    29 const TUid KEmergencyCallPropertyCategory = {0x2001032C};
    42 
    30 
    43 const TUint KEmergencyCallPropertyKey = 0x0101;
    31 const TUint KEmergencyCallPropertyKey = 0x0101;
    50 const TUid KValidateRTCPropertyCategory = {0x2000D75B};
    38 const TUid KValidateRTCPropertyCategory = {0x2000D75B};
    51 const TUint KValidateRTCPropertyKey = 0x2001D2AB;
    39 const TUint KValidateRTCPropertyKey = 0x2001D2AB;
    52 //Number of clusterSize to be reserve for phone memory space 
    40 //Number of clusterSize to be reserve for phone memory space 
    53 const TInt KNumberOfCluster = 2;
    41 const TInt KNumberOfCluster = 2;
    54 
    42 
    55 //For test code
    43 _LIT(KTsyModuleName, "mm.tsy");
    56 /** Channel used to communicate with Security Notifier. */
    44 _LIT(KTsyPhoneName, "GsmPhone1");
    57 static const TUid KSecurityNotifierChannel = { 0x1000598F };
       
    58 
       
    59 // Type definitions for a buffer containing a drive id (drive letter + :).
       
    60 const TInt KDriveIdLength = 2;
       
    61 typedef TBuf<KDriveIdLength> TDriveId;
       
    62 
       
    63 const TUint32 KMiscPluginPropertyKey = 0x2000E658;
       
    64 const TUid KPropertyCategory={0x2000D75B};              // tcustomcmd_server SID = KSsmServerName SID (changed in tcustomcmd_server.mmp file)
       
    65 
       
    66 
    45 
    67 CSsmUiSpecific::CSsmUiSpecific()
    46 CSsmUiSpecific::CSsmUiSpecific()
    68 : iReferenceCount(1), iReservedPhoneMemory(0)
    47 : iReferenceCount(1), iReservedPhoneMemory(0)
    69 	{
    48 	{
    70 	}
    49 	}
    74 	iReservedPhoneMemoryFs.Close();
    53 	iReservedPhoneMemoryFs.Close();
    75 	}
    54 	}
    76 
    55 
    77 EXPORT_C TUid CSsmUiSpecific::StartupPSUid()
    56 EXPORT_C TUid CSsmUiSpecific::StartupPSUid()
    78 	{
    57 	{
    79 	if (!IsTestPsKeyDefined())
    58 	return KPSStartupUid;
    80         {
       
    81         DEBUGPRINT1A("StartupPSUid :: Calling S60 plugins functions ");
       
    82         return KPSUidStartup;        
       
    83         }
       
    84     else
       
    85         {
       
    86         DEBUGPRINT1A("StartupPSUid :: Calling Symbian(dummy) plugins functions ");
       
    87         return KPSStartupDefaultUid;
       
    88         }	
       
    89 	}
    59 	}
    90 
    60 
    91 EXPORT_C TUid CSsmUiSpecific::SecurityPinNotifierUid()
    61 EXPORT_C TUid CSsmUiSpecific::SecurityPinNotifierUid()
    92 	{
    62 	{
    93 	if (!IsTestPsKeyDefined())
    63 	return KSecurityPinNotifierUid;
    94         {
       
    95         DEBUGPRINT1A("SecurityPinNotifierUid :: Calling S60 plugins functions ");
       
    96         return KSecurityNotifierUid;  
       
    97         }
       
    98     else
       
    99         {
       
   100         DEBUGPRINT1A("SecurityPinNotifierUid :: Calling Symbian(dummy) plugins functions ");
       
   101         return KSecurityPinNotifierUid;
       
   102         }   
       
   103 
       
   104 	}
    64 	}
   105 
    65 
   106 EXPORT_C TUint CSsmUiSpecific::EmergencyCallPropertyKey()
    66 EXPORT_C TUint CSsmUiSpecific::EmergencyCallPropertyKey()
   107 	{
    67 	{
   108 	if (!IsTestPsKeyDefined())
    68 	return KEmergencyCallPropertyKey;
   109         {
       
   110         DEBUGPRINT1A("EmergencyCallPropertyKey :: Calling S60 plugins functions ");
       
   111         return KCTsyCallState;       
       
   112         }
       
   113     else
       
   114         {
       
   115         DEBUGPRINT1A("EmergencyCallPropertyKey :: Calling Symbian(dummy) plugins functions ");
       
   116         return KEmergencyCallPropertyKey;
       
   117         }   
       
   118 
       
   119 	}
    69 	}
   120 
    70 
   121 EXPORT_C TUid CSsmUiSpecific::EmergencyCallPropertyCategory()
    71 EXPORT_C TUid CSsmUiSpecific::EmergencyCallPropertyCategory()
   122 	{
    72 	{
   123 	if (!IsTestPsKeyDefined())
    73 	return KEmergencyCallPropertyCategory;
   124         {
       
   125         DEBUGPRINT1A("EmergencyCallPropertyCategory :: Calling S60 plugins functions ");
       
   126         return KPSUidCtsyCallInformation;       
       
   127         }
       
   128     else
       
   129         {
       
   130         DEBUGPRINT1A("EmergencyCallPropertyCategory :: Calling Symbian(dummy) plugins functions ");
       
   131         return KEmergencyCallPropertyCategory;
       
   132         }   
       
   133 
       
   134 	}
    74 	}
   135 
    75 
   136 EXPORT_C TBool CSsmUiSpecific::IsSimSupported()
    76 EXPORT_C TBool CSsmUiSpecific::IsSimSupported()
   137 	{
    77 	{
   138 	if (!IsTestPsKeyDefined())
    78 	return ETrue;
   139         {
       
   140         DEBUGPRINT1A("IsSimSupported :: Calling S60 plugins functions ");
       
   141         return SsmMapperUtility::FeatureStatus( TUid::Uid( KFeatureIdSimCard ) );       
       
   142         }
       
   143     else
       
   144         {
       
   145         DEBUGPRINT1A("IsSimSupported :: Calling Symbian(dummy) plugins functions ");
       
   146         return ETrue;
       
   147         }   
       
   148 
       
   149 	}
    79 	}
   150 
    80 
   151 EXPORT_C void CSsmUiSpecific::SetSecurityStatus(const TStrtSecurityStatus& aSecurityStatus)
    81 EXPORT_C void CSsmUiSpecific::SetSecurityStatus(const TStrtSecurityStatus& aSecurityStatus)
   152 	{   
    82 	{
   153 	iStrtSecurityStatus = aSecurityStatus;
    83 	iStrtSecurityStatus = aSecurityStatus;
   154 	}
    84 	}
   155 
    85 
   156 EXPORT_C TStrtSecurityStatus CSsmUiSpecific::SecurityStatus() const
    86 EXPORT_C TStrtSecurityStatus CSsmUiSpecific::SecurityStatus() const
   157 	{   
    87 	{
   158 	return iStrtSecurityStatus;
    88 	return iStrtSecurityStatus;
   159 	}
    89 	}
   160 
    90 
   161 EXPORT_C CSsmUiSpecific* CSsmUiSpecific::InstanceL()
    91 EXPORT_C CSsmUiSpecific* CSsmUiSpecific::InstanceL()
   162 	{
    92 	{
   195         }
   125         }
   196 	}
   126 	}
   197 
   127 
   198 EXPORT_C TUid CSsmUiSpecific::ScreenOutputChannelUid()
   128 EXPORT_C TUid CSsmUiSpecific::ScreenOutputChannelUid()
   199 	{
   129 	{
   200 	if (!IsTestPsKeyDefined())
   130 	return KScreenOutputChannel;
   201         {
       
   202         DEBUGPRINT1A("ScreenOutputChannelUid :: Calling S60 plugins functions ");
       
   203         return KSecurityNotifierChannel;       
       
   204         }
       
   205     else
       
   206         {
       
   207         DEBUGPRINT1A("ScreenOutputChannelUid :: Calling Symbian(dummy) plugins functions ");
       
   208         return KScreenOutputChannel;
       
   209         }   
       
   210 
       
   211 	}
   131 	}
   212 
   132 
   213 EXPORT_C TUint CSsmUiSpecific::SimStatusPropertyKey()
   133 EXPORT_C TUint CSsmUiSpecific::SimStatusPropertyKey()
   214 	{
   134 	{
   215 	if (!IsTestPsKeyDefined())
   135 	return KSimStatusPropertyKey;
   216         {
       
   217         DEBUGPRINT1A("SimStatusPropertyKey :: Calling S60 plugins functions ");
       
   218         return KPSSimStatus;        
       
   219         }
       
   220     else
       
   221         {
       
   222         DEBUGPRINT1A("SimStatusPropertyKey :: Calling Symbian(dummy) plugins functions ");
       
   223         return KSimStatusPropertyKey;
       
   224         }   
       
   225 	}
   136 	}
   226 
   137 
   227 EXPORT_C TBool CSsmUiSpecific::IsSimStateChangeAllowed()
   138 EXPORT_C TBool CSsmUiSpecific::IsSimStateChangeAllowed()
   228 	{
   139 	{
   229 	if (!IsTestPsKeyDefined())
   140 	return ETrue;
   230         {
       
   231         DEBUGPRINT1A("IsSimStateChangeAllowed :: Calling S60 plugins functions ");
       
   232         TSsmState state;
       
   233         TInt err = SsmMapperUtility::GetCurrentState( state );
       
   234         ERROR( err, "Failed to get current state" );
       
   235         return ( err == KErrNone &&
       
   236                  ( state.MainState() == ESsmStartup && state.SubState() == ESsmStateSecurityCheck ) ||
       
   237                  ( state.MainState() == ESsmStartup && state.SubState() == ESsmStateNonCritical ) ||
       
   238                    state.MainState() == ESsmNormal );        
       
   239         }
       
   240     else
       
   241         {
       
   242         DEBUGPRINT1A("IsSimStateChangeAllowed :: Calling Symbian(dummy) plugins functions ");
       
   243         return ETrue;
       
   244         }   
       
   245 
       
   246 	}
   141 	}
   247 
   142 
   248 EXPORT_C TBool CSsmUiSpecific::IsAmaStarterSupported()
   143 EXPORT_C TBool CSsmUiSpecific::IsAmaStarterSupported()
   249 	{
   144 	{
   250 	if (!IsTestPsKeyDefined())
   145 	return ETrue;
   251         {
       
   252         DEBUGPRINT1A("IsAmaStarterSupported :: Calling S60 plugins functions ");
       
   253         return SsmMapperUtility::FeatureStatus( TUid::Uid( KFeatureIdExtendedStartup ) );       
       
   254         }
       
   255     else
       
   256         {
       
   257         DEBUGPRINT1A("IsAmaStarterSupported :: Calling Symbian(dummy) plugins functions ");
       
   258         return ETrue;
       
   259         }   
       
   260 
       
   261 	}
   146 	}
   262 
   147 
   263 EXPORT_C HBufC* CSsmUiSpecific::GetTsyModuleNameL()
   148 EXPORT_C HBufC* CSsmUiSpecific::GetTsyModuleNameL()
   264 	{
   149 	{
   265     DEBUGPRINT1A("GetTsyModuleNameL :: Calling S60 plugins functions ");
   150 	HBufC* tstModuleName = KTsyModuleName().AllocL();
   266     /*****************************************************
   151 	return tstModuleName;
   267     *   Series 60 Customer / TSY
       
   268     *   Needs customer TSY implementation
       
   269     *****************************************************/
       
   270 
       
   271     HBufC* name = KMmTsyModuleName().AllocL();
       
   272     INFO_1( "TSY name: %S", name );
       
   273     return name;      
       
   274 	}
   152 	}
   275 
   153 
   276 EXPORT_C TUid CSsmUiSpecific::StarterPSUid()
   154 EXPORT_C TUid CSsmUiSpecific::StarterPSUid()
   277 	{
   155 	{
   278 	if (!IsTestPsKeyDefined())
   156 	return KSecurityStatusPropertyCategory;
   279         {
       
   280         DEBUGPRINT1A("StarterPSUid :: Calling S60 plugins functions ");
       
   281         return KPSStarterUid;        
       
   282         }
       
   283     else
       
   284         {
       
   285         DEBUGPRINT1A("StartupPSUid :: Calling Symbian(dummy) plugins functions ");
       
   286         return KSecurityStatusPropertyCategory;
       
   287         }   
       
   288 	}
   157 	}
   289 
   158 
   290 EXPORT_C HBufC* CSsmUiSpecific::PhoneTsyNameL()
   159 EXPORT_C HBufC* CSsmUiSpecific::PhoneTsyNameL()
   291 	{
   160 	{
   292     DEBUGPRINT1A("PhoneTsyNameL :: Calling S60 plugins functions ");
   161 	HBufC* tsyPhoneName = KTsyPhoneName().AllocL();
   293     /*****************************************************
   162 	return tsyPhoneName;
   294     *   Series 60 Customer / TSY
       
   295     *   Needs customer TSY implementation
       
   296     *****************************************************/
       
   297 
       
   298     HBufC* name = KMmTsyPhoneName().AllocL();
       
   299     INFO_1( "Phone name: %S", name );
       
   300     return name;     
       
   301 	}
   163 	}
   302 
   164 
   303 EXPORT_C TBool CSsmUiSpecific::IsSimPresent()
   165 EXPORT_C TBool CSsmUiSpecific::IsSimPresent()
   304 	{
   166 	{
   305 	if (!IsTestPsKeyDefined())
   167 	return ETrue;
   306         {
       
   307         DEBUGPRINT1A("IsSimPresent :: Calling S60 plugins functions ");
       
   308         TInt value( 0 );
       
   309         TInt err = RProperty::Get( SsmMapperUtility::PsUid( KPSUidStartup ), KPSSimStatus, value );
       
   310         ERROR( err, "Failed to get value of KPSUidStartup::KPSSimStatus" );
       
   311         return ( err == KErrNone &&
       
   312                  ( value == ESimUsable ||
       
   313                    value == ESimReadable ||
       
   314                    value == ESimNotReady ) );       
       
   315         }
       
   316     else
       
   317         {
       
   318         DEBUGPRINT1A("IsSimPresent :: Calling Symbian(dummy) plugins functions ");
       
   319         return ETrue;
       
   320         }   
       
   321 	}
   168 	}
   322 
   169 
   323 EXPORT_C TBool CSsmUiSpecific::IsSimlessOfflineSupported()
   170 EXPORT_C TBool CSsmUiSpecific::IsSimlessOfflineSupported()
   324 	{
   171 	{
   325 	if (!IsTestPsKeyDefined())
   172 	return ETrue;
   326         {
       
   327         DEBUGPRINT1A("IsSimlessOfflineSupported :: Calling S60 plugins functions ");
       
   328         return SsmMapperUtility::FeatureStatus(
       
   329             TUid::Uid( KFeatureIdFfSimlessOfflineSupport ) );      
       
   330         }
       
   331     else
       
   332         {
       
   333         DEBUGPRINT1A("IsSimlessOfflineSupported :: Calling Symbian(dummy) plugins functions ");
       
   334         return ETrue;
       
   335         }   
       
   336 	}
   173 	}
   337 
   174 
   338 EXPORT_C TBool CSsmUiSpecific::IsNormalBoot()
   175 EXPORT_C TBool CSsmUiSpecific::IsNormalBoot()
   339 	{
   176 	{
   340 	if (!IsTestPsKeyDefined())
   177 	return ETrue;
   341         {
       
   342         DEBUGPRINT1A("IsNormalBoot :: Calling S60 plugins functions ");
       
   343         TInt value( 0 );
       
   344         TInt errorCode = RProperty::Get( SsmMapperUtility::PsUid( KPSUidStartup ), KPSStartupReason, value );
       
   345         ERROR( errorCode, "Failed to get value of KPSUidStartup::KPSStartupReason" );
       
   346 
       
   347         TBool ret = ( errorCode == KErrNone && value == ENormalStartup );
       
   348         INFO_1( "Is normal boot = %d", ret );
       
   349         return ret;     
       
   350         }
       
   351     else
       
   352         {
       
   353         DEBUGPRINT1A("IsNormalBoot :: Calling Symbian(dummy) plugins functions ");
       
   354         return ETrue;
       
   355         }   
       
   356 	}
   178 	}
   357 
   179 
   358 EXPORT_C TBool CSsmUiSpecific::IsSimChangedReset()
   180 EXPORT_C TBool CSsmUiSpecific::IsSimChangedReset()
   359 	{
   181 	{
   360 	if (!IsTestPsKeyDefined())
   182 	return ETrue;
   361         {
       
   362         DEBUGPRINT1A("IsSimChangedReset :: Calling S60 plugins functions ");
       
   363         TUid startupPsUid( SsmMapperUtility::PsUid( KPSUidStartup ) );
       
   364         TInt value( 0 );
       
   365         TInt errorCode = RProperty::Get( startupPsUid, KPSStartupReason, value );
       
   366         ERROR( errorCode, "Failed to get value of KPSUidStartup::KPSStartupReason" );
       
   367 
       
   368         TBool ret( EFalse );
       
   369         if ( errorCode == KErrNone && value == ESIMStatusChangeReset )
       
   370             {
       
   371             errorCode = RProperty::Get( startupPsUid, KPSSimChanged, value );
       
   372             ret = ( errorCode == KErrNone && value == ESimChanged );
       
   373             }
       
   374 
       
   375         INFO_1( "Is SIM changed reset = %d", ret );
       
   376         return ret;       
       
   377         }
       
   378     else
       
   379         {
       
   380         DEBUGPRINT1A("IsSimChangedReset :: Calling Symbian(dummy) plugins functions ");
       
   381         return ETrue;
       
   382         }   
       
   383 	}
   183 	}
   384 
   184 
   385 EXPORT_C TUint CSsmUiSpecific::RFStatusPropertyKey()
   185 EXPORT_C TUint CSsmUiSpecific::RFStatusPropertyKey()
   386 	{
   186 	{
   387 	if (!IsTestPsKeyDefined())
   187 	return KRFStatusPropertyKey;
   388         {
       
   389         DEBUGPRINT1A("RFStatusPropertyKey :: Calling S60 plugins functions ");
       
   390         return SWP_UID_SSM_RF_STATUS;        
       
   391         }
       
   392     else
       
   393         {
       
   394         DEBUGPRINT1A("RFStatusPropertyKey :: Calling Symbian(dummy) plugins functions ");
       
   395         return KRFStatusPropertyKey;
       
   396         }   
       
   397 	}
   188 	}
   398 
   189 
   399 EXPORT_C TUid CSsmUiSpecific::RFStatusPropertyCategory()
   190 EXPORT_C TUid CSsmUiSpecific::RFStatusPropertyCategory()
   400 	{
   191 	{
   401 	if (!IsTestPsKeyDefined())
   192 	return KRFStatusPropertyCategory;
   402         {
   193 	}
   403         DEBUGPRINT1A("RFStatusPropertyCategory :: Calling S60 plugins functions ");
       
   404         return TUid::Uid( SWP_UID_SSM_RF_STATUS );       
       
   405         }
       
   406     else
       
   407         {
       
   408         DEBUGPRINT1A("RFStatusPropertyCategory :: Calling Symbian(dummy) plugins functions ");
       
   409         return KRFStatusPropertyCategory;
       
   410         }   
       
   411 	}
       
   412 
       
   413 EXPORT_C TUint CSsmUiSpecific::ValidateRTCPropertyKey()
   194 EXPORT_C TUint CSsmUiSpecific::ValidateRTCPropertyKey()
   414     {
   195     {
   415     if (!IsTestPsKeyDefined())
   196     return KValidateRTCPropertyKey;
   416         {
       
   417         DEBUGPRINT1A("ValidateRTCPropertyKey :: Calling S60 plugins functions ");
       
   418         return KRTCPropertyKey;       
       
   419         }
       
   420     else
       
   421         {
       
   422         DEBUGPRINT1A("ValidateRTCPropertyKey :: Calling Symbian(dummy) plugins functions ");
       
   423         return KValidateRTCPropertyKey;
       
   424         }   
       
   425 
       
   426     }
   197     }
   427 
   198 
   428 EXPORT_C TUid CSsmUiSpecific::ValidateRTCPropertyCategory()
   199 EXPORT_C TUid CSsmUiSpecific::ValidateRTCPropertyCategory()
   429     {
   200     {
   430     if (!IsTestPsKeyDefined())
   201     return KValidateRTCPropertyCategory;
   431         {
       
   432         DEBUGPRINT1A("ValidateRTCPropertyCategory :: Calling S60 plugins functions ");
       
   433         return KPSStarterUid;        
       
   434         }
       
   435     else
       
   436         {
       
   437         DEBUGPRINT1A("ValidateRTCPropertyCategory :: Calling Symbian(dummy) plugins functions ");
       
   438         return KValidateRTCPropertyCategory;
       
   439         }   
       
   440     }
   202     }
   441 
   203 
   442 EXPORT_C TInt CSsmUiSpecific::PhoneMemoryRootDriveId()
   204 EXPORT_C TInt CSsmUiSpecific::PhoneMemoryRootDriveId()
   443 	{
   205 	{
   444 	if (!IsTestPsKeyDefined())
   206 	return EDriveC;
   445         {
       
   446         DEBUGPRINT1A("PhoneMemoryRootDriveId :: Calling S60 plugins functions ");
       
   447         TInt driveId = EDriveC;
       
   448         TDriveId driveIdBuf = PathInfo::PhoneMemoryRootPath().Left( KDriveIdLength );
       
   449         if ( driveIdBuf.Length() > 0 )
       
   450             {
       
   451             TInt err = RFs::CharToDrive( driveIdBuf[0], driveId ) ;
       
   452             INFO_1( "PhoneMemoryRootDriveId - CharToDrive returns: %d", err );            
       
   453             }
       
   454 
       
   455         INFO_1( "Phone memory root path ID: %d", driveId );
       
   456         return driveId;      
       
   457         }
       
   458     else
       
   459         {
       
   460         DEBUGPRINT1A("PhoneMemoryRootDriveId :: Calling Symbian(dummy) plugins functions ");
       
   461         return EDriveC;
       
   462         }   
       
   463 	}
   207 	}
   464 
   208 
   465 /**
   209 /**
   466 Leaving construction inside ConstructL
   210 Leaving construction inside ConstructL
   467 */
   211 */
   468 void CSsmUiSpecific::ConstructL()
   212 void CSsmUiSpecific::ConstructL()
   469 	{
   213 	{
   470 	User::LeaveIfError( iReservedPhoneMemoryFs.Connect() );
   214 	User::LeaveIfError( iReservedPhoneMemoryFs.Connect() );
   471 	}
   215 	}
   472 
       
   473 /**
       
   474     Helper function to check for P&S Key
       
   475 */
       
   476 TBool CSsmUiSpecific::IsTestPsKeyDefined()
       
   477     {
       
   478     TBool testPsKeyDefined = EFalse;
       
   479     TInt result = RProperty::Get(KPropertyCategory, KMiscPluginPropertyKey, testPsKeyDefined);
       
   480     DEBUGPRINT3(_L("KMiscPluginPropertyKey %d Error %d"), testPsKeyDefined, result);
       
   481     if ((KErrNone != result) && (KErrNotFound != result))
       
   482         {
       
   483         User::Leave(result);
       
   484         }
       
   485     return testPsKeyDefined;
       
   486     }
       
   487 
   216 
   488 /**
   217 /**
   489 Reserve two ClusterSize in Phone Memory Space on H/W
   218 Reserve two ClusterSize in Phone Memory Space on H/W
   490 and 512 bytes for __WINS__
   219 and 512 bytes for __WINS__
   491 @return KErrNone if successful or systemwide error
   220 @return KErrNone if successful or systemwide error