filemanager/bkupengine/src/MMCScBkupLogger.cpp
branchRCL_3
changeset 38 491b3ed49290
parent 36 95243422089a
child 39 65326cf895ed
equal deleted inserted replaced
36:95243422089a 38:491b3ed49290
     1 /*
       
     2 * Copyright (c) 2005 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: MMCScBkupLogger implementation
       
    15 *
       
    16 *
       
    17 */
       
    18 
       
    19 #include "MMCScBkupLogger.h"
       
    20 
       
    21 // System includes
       
    22 #include <coemain.h>
       
    23 #include <e32svr.h>
       
    24 #include <flogger.h>
       
    25 
       
    26 #if defined(__MMCSCBKUPLOGGING_ENABLED__)
       
    27 
       
    28 // Constants
       
    29 const TInt KMMCScBkupLoggingMaxLogTextLength = 1024;
       
    30 const TInt KMMCScBkupLoggingMaxLogSize = 10240;
       
    31 
       
    32 // ========================= MEMBER FUNCTIONS ================================
       
    33 
       
    34 // ---------------------------------------------------------------------------
       
    35 // MMCScBkupLogger::LogRaw()
       
    36 // 
       
    37 // 
       
    38 // ---------------------------------------------------------------------------
       
    39 void MMCScBkupLogger::LogRaw( const TDesC& aData )
       
    40     {
       
    41 #if defined(__MMCSCBKUPLOGGING_MODE_FILE__)
       
    42 
       
    43     _LIT( KMMCScBkupLoggingDir,      "FMBkup" );
       
    44     _LIT( KMMCScBkupLoggingFileName, "FMBkup.txt" );
       
    45     
       
    46     /////////////
       
    47     // FLOGGER
       
    48     /////////////
       
    49     RFileLogger::Write( KMMCScBkupLoggingDir, KMMCScBkupLoggingFileName, EFileLoggingModeAppend, aData );
       
    50 
       
    51 #elif defined(__MMCSCBKUPLOGGING_MODE_RDEBUG__)
       
    52 
       
    53     /////////////
       
    54     // RDEBUG
       
    55     /////////////
       
    56     _LIT( KLogComponentName, "[MMC] ");
       
    57     HBufC* printBuf = HBufC::New( aData.Length() + KLogComponentName().Length() );
       
    58     if  ( printBuf )
       
    59         {
       
    60         TPtr pBuf( printBuf->Des() );
       
    61         pBuf.Append( KLogComponentName );
       
    62         pBuf.Append( aData );
       
    63         RDebug::Print( *printBuf );
       
    64         delete printBuf;
       
    65         }
       
    66     else
       
    67         {
       
    68         RDebug::Print( aData );
       
    69         }
       
    70 
       
    71 #endif
       
    72     }
       
    73 
       
    74 
       
    75 // ---------------------------------------------------------------------------
       
    76 // MMCScBkupLogger::Log()
       
    77 // 
       
    78 // 
       
    79 // ---------------------------------------------------------------------------
       
    80 void MMCScBkupLogger::Log( TRefByValue<const TDesC> aFmt, ... )
       
    81     {
       
    82 	VA_LIST list;
       
    83 	VA_START( list, aFmt );
       
    84 	
       
    85     HBufC* buf = HBufC::New( KMMCScBkupLoggingMaxLogTextLength );
       
    86     if  ( buf )
       
    87         {
       
    88         TPtr pBuf( buf->Des() );
       
    89         pBuf.FormatList(aFmt, list);
       
    90         LogRaw( *buf );
       
    91         delete buf;
       
    92         }
       
    93     }
       
    94 
       
    95 
       
    96 // ---------------------------------------------------------------------------
       
    97 // MMCScBkupLogger::DataType()
       
    98 // 
       
    99 // 
       
   100 // ---------------------------------------------------------------------------
       
   101 const TDesC& MMCScBkupLogger::DataType( TMMCScBkupOwnerDataType aType )
       
   102     {
       
   103     switch( aType )
       
   104         {
       
   105     case EMMCScBkupOwnerDataTypeDataOwner:
       
   106         {
       
   107         _LIT(KRet, "EMMCScBkupOwnerDataTypeDataOwner");
       
   108         return KRet;
       
   109         }
       
   110     case EMMCScBkupOwnerDataTypeJavaData:
       
   111         {
       
   112         _LIT(KRet, "EMMCScBkupOwnerDataTypeJavaData");
       
   113         return KRet;
       
   114         }
       
   115     case EMMCScBkupOwnerDataTypePublicData:
       
   116         {
       
   117         _LIT(KRet, "EMMCScBkupOwnerDataTypePublicData");
       
   118         return KRet;
       
   119         }
       
   120     case EMMCScBkupOwnerDataTypeSystemData:
       
   121         {
       
   122         _LIT(KRet, "EMMCScBkupOwnerDataTypeSystemData");
       
   123         return KRet;
       
   124         }
       
   125     case EMMCScBkupOwnerDataTypeActiveData:
       
   126         {
       
   127         _LIT(KRet, "EMMCScBkupOwnerDataTypeActiveData");
       
   128         return KRet;
       
   129         }
       
   130     case EMMCScBkupOwnerDataTypePassiveData:
       
   131         {
       
   132         _LIT(KRet, "EMMCScBkupOwnerDataTypePassiveData");
       
   133         return KRet;
       
   134         }
       
   135     case EMMCScBkupOwnerDataTypeAny:
       
   136         {
       
   137         _LIT(KRet, "EMMCScBkupOwnerDataTypeAny");
       
   138         return KRet;
       
   139         }
       
   140     default:
       
   141         break;
       
   142         }
       
   143 
       
   144     _LIT(KRet, "UNKNOWN!");
       
   145     return KRet;
       
   146     }
       
   147 
       
   148 
       
   149 // ---------------------------------------------------------------------------
       
   150 // MMCScBkupLogger::FriendlyNameForSID()
       
   151 // 
       
   152 // 
       
   153 // ---------------------------------------------------------------------------
       
   154 const TDesC& MMCScBkupLogger::FriendlyNameForSID( TSecureId aSID )
       
   155     {
       
   156     switch( aSID.iId )
       
   157         {
       
   158     case 0x10202be9:
       
   159         {
       
   160         _LIT(KRet, "[CentRep]");
       
   161         return KRet;
       
   162         }
       
   163     case 0x10008d38:
       
   164         {
       
   165         _LIT(KRet, "[FavouritesSrv]");
       
   166         return KRet;
       
   167         }
       
   168     case 0x101f51f2:
       
   169         {
       
   170         _LIT(KRet, "[RightsServer]");
       
   171         return KRet;
       
   172         }
       
   173     case 0x101f7993:
       
   174         {
       
   175         _LIT(KRet, "[VpnManager]");
       
   176         return KRet;
       
   177         }
       
   178     case 0x101fd288:
       
   179         {
       
   180         _LIT(KRet, "[EventMediator]");
       
   181         return KRet;
       
   182         }
       
   183     default:
       
   184         break;
       
   185         }
       
   186 
       
   187     _LIT(KRet, "");
       
   188     return KRet;
       
   189     }
       
   190 
       
   191 
       
   192 // ---------------------------------------------------------------------------
       
   193 // MMCScBkupLogger::LogFile()
       
   194 // 
       
   195 // 
       
   196 // ---------------------------------------------------------------------------
       
   197 void MMCScBkupLogger::LogFile( TRefByValue<const TDesC> aFmt, ... )
       
   198     {
       
   199 	VA_LIST list;
       
   200 	VA_START( list, aFmt );
       
   201 
       
   202     HBufC* buf = HBufC::New( KMMCScBkupLoggingMaxLogTextLength );
       
   203     if  ( buf )
       
   204         {
       
   205         TPtr pBuf( buf->Des() );
       
   206         pBuf.FormatList(aFmt, list);
       
   207 #ifdef _DEBUG
       
   208         LogRaw( *buf );
       
   209 #endif
       
   210         RFile64 file;
       
   211         RFs& fsSession(CCoeEnv::Static()->FsSession());
       
   212         TEntry entry;
       
   213         TInt error;
       
   214         
       
   215         if  ( fsSession.Entry( KMMCScBkupLoggingFullPathAndName, entry ) == KErrNone )
       
   216             {
       
   217             error = file.Open( fsSession, KMMCScBkupLoggingFullPathAndName, EFileWrite | EFileShareExclusive );
       
   218             }
       
   219         else
       
   220             {
       
   221             entry.iSize = 0;
       
   222             error = file.Create( fsSession, KMMCScBkupLoggingFullPathAndName, EFileWrite | EFileShareExclusive );
       
   223             }
       
   224         
       
   225         if(error == KErrNone)
       
   226             {
       
   227             TInt64 size = 0;
       
   228             
       
   229             error = file.Size( size );
       
   230             if(error == KErrNone && size < KMMCScBkupLoggingMaxLogSize)
       
   231                 {
       
   232                 HBufC8* buf8 = HBufC8::New( KMMCScBkupLoggingMaxLogTextLength );
       
   233                 if(buf8)
       
   234                     {
       
   235                     const TText8 KLineFeed( '\n' );
       
   236                     TPtr8 data( buf8->Des() );
       
   237                     
       
   238                     data.Copy(buf->Des());
       
   239                     data.Append(KLineFeed);
       
   240                     file.Write(static_cast<TInt64>(entry.iSize), data);
       
   241                     delete buf8;
       
   242                     }
       
   243                 }
       
   244             }
       
   245         file.Close();
       
   246         delete buf;
       
   247         }
       
   248     }
       
   249 
       
   250 #endif
       
   251