backupandrestore/backupengine/src/sbeparserproxy.cpp
changeset 47 63cf70d3ecd8
parent 0 d0791faffa3f
equal deleted inserted replaced
44:a5deb6b96675 47:63cf70d3ecd8
    23 // System includes
    23 // System includes
    24 #include <charconv.h>
    24 #include <charconv.h>
    25 
    25 
    26 // User includes
    26 // User includes
    27 #include "sbeparserdefs.h"
    27 #include "sbeparserdefs.h"
    28 #include "sblog.h"
    28 #include "OstTraceDefinitions.h"
       
    29 #include "sbtrace.h"
       
    30 #ifdef OST_TRACE_COMPILER_IN_USE
       
    31 #include "sbeparserproxyTraces.h"
       
    32 #endif
    29 
    33 
    30 namespace conn
    34 namespace conn
    31 	{
    35 	{
    32 	CSBEParserProxy::CSBEParserProxy( RFs& aFsSession )
    36 	CSBEParserProxy::CSBEParserProxy( RFs& aFsSession )
    33         : iFsSession( aFsSession )
    37         : iFsSession( aFsSession )
    35 
    39 
    36 	@param aSID secure id of data owner
    40 	@param aSID secure id of data owner
    37 	@param apDataOwnerManager data owner manager to access resources
    41 	@param apDataOwnerManager data owner manager to access resources
    38 	*/
    42 	*/
    39 		{
    43 		{
       
    44 		OstTraceFunctionEntry0( CSBEPARSERPROXY_CSBEPARSERPROXY_CONS_ENTRY );
       
    45 		OstTraceFunctionExit0( CSBEPARSERPROXY_CSBEPARSERPROXY_CONS_EXIT );
    40 		}
    46 		}
    41 
    47 
    42 	CSBEParserProxy::~CSBEParserProxy()
    48 	CSBEParserProxy::~CSBEParserProxy()
    43 	/** Standard C++ destructor
    49 	/** Standard C++ destructor
    44 	*/
    50 	*/
    45 		{
    51 		{
       
    52 		OstTraceFunctionEntry0( CSBEPARSERPROXY_CSBEPARSERPROXY_DES_ENTRY );
    46 		delete iConverter;
    53 		delete iConverter;
    47 		delete iParser;
    54 		delete iParser;
       
    55 		OstTraceFunctionExit0( CSBEPARSERPROXY_CSBEPARSERPROXY_DES_EXIT );
    48 		}
    56 		}
    49 
    57 
    50 	void CSBEParserProxy::ConstructL()
    58 	void CSBEParserProxy::ConstructL()
    51 	/** Symbian 2nd stage constructor */
    59 	/** Symbian 2nd stage constructor */
    52 		{
    60 		{
       
    61 		OstTraceFunctionEntry0( CSBEPARSERPROXY_CONSTRUCTL_ENTRY );
    53 		iParser = CParser::NewL(KMimeType, *this);
    62 		iParser = CParser::NewL(KMimeType, *this);
    54 
    63 
    55 		// We only convert from UTF-8 to UTF-16
    64 		// We only convert from UTF-8 to UTF-16
    56 		iConverter = CCnvCharacterSetConverter::NewL();
    65 		iConverter = CCnvCharacterSetConverter::NewL();
    57 		if  ( iConverter->PrepareToConvertToOrFromL( KCharacterSetIdentifierUtf8, iFsSession ) == CCnvCharacterSetConverter::ENotAvailable )
    66 		if  ( iConverter->PrepareToConvertToOrFromL( KCharacterSetIdentifierUtf8, iFsSession ) == CCnvCharacterSetConverter::ENotAvailable )
    58 			{
    67 			{
       
    68 		    OstTrace0(TRACE_ERROR, CSBEPARSERPROXY_CONSTRUCTL, "Leave: KErrNotFound");
    59 			User::Leave(KErrNotFound);
    69 			User::Leave(KErrNotFound);
    60 			}
    70 			}
       
    71 		OstTraceFunctionExit0( CSBEPARSERPROXY_CONSTRUCTL_EXIT );
    61 		}
    72 		}
    62 		
    73 		
    63 	CSBEParserProxy* CSBEParserProxy::NewL( RFs& aFsSession )
    74 	CSBEParserProxy* CSBEParserProxy::NewL( RFs& aFsSession )
    64 	/** Symbian OS static constructor
    75 	/** Symbian OS static constructor
    65 
    76 
    66 	@param aSID secure id of data owner
    77 	@param aSID secure id of data owner
    67 	@param apDataOwnerManager data owner manager to access resources
    78 	@param apDataOwnerManager data owner manager to access resources
    68 	@return a CBackupRegistrationParser object
    79 	@return a CBackupRegistrationParser object
    69 	*/
    80 	*/
    70 		{
    81 		{
       
    82 		OstTraceFunctionEntry0( CSBEPARSERPROXY_NEWL_ENTRY );
    71 		CSBEParserProxy* self = new(ELeave) CSBEParserProxy( aFsSession );
    83 		CSBEParserProxy* self = new(ELeave) CSBEParserProxy( aFsSession );
    72 		CleanupStack::PushL(self);
    84 		CleanupStack::PushL(self);
    73 		self->ConstructL();
    85 		self->ConstructL();
    74 		CleanupStack::Pop(self);
    86 		CleanupStack::Pop(self);
    75 
    87 
       
    88 		OstTraceFunctionExit0( CSBEPARSERPROXY_NEWL_EXIT );
    76 		return self;
    89 		return self;
    77 		}
    90 		}
    78 
    91 
    79 	void CSBEParserProxy::ParseL( const TDesC& aFileName, MContentHandler& aObserver )
    92 	void CSBEParserProxy::ParseL( const TDesC& aFileName, MContentHandler& aObserver )
    80 	/** Parsing API */
    93 	/** Parsing API */
    81         {
    94         {
       
    95         OstTraceFunctionEntry0( CSBEPARSERPROXY_PARSEL_ENTRY );
    82         // Store transient observer (the entity that we will route callbacks to)
    96         // Store transient observer (the entity that we will route callbacks to)
    83         iTransientParsingError = KErrNone;
    97         iTransientParsingError = KErrNone;
    84         iTransientObserver = &aObserver;
    98         iTransientObserver = &aObserver;
    85 
    99 
    86         // Do XML parsing of the specified file. Callbacks will occur to client via the XML
   100         // Do XML parsing of the specified file. Callbacks will occur to client via the XML
    87         // callback API.
   101         // callback API.
    88 		Xml::ParseL( *iParser, iFsSession, aFileName );
   102 		Xml::ParseL( *iParser, iFsSession, aFileName );
    89 
   103 
    90         // Handle any errors received during callbacks
   104         // Handle any errors received during callbacks
    91 		User::LeaveIfError( iTransientParsingError );
   105 		LEAVEIFERROR( iTransientParsingError, OstTrace1(TRACE_ERROR, DUP1_CSBEPARSERPROXY_CONVERTTOUNICODEL, "Leave: %d", iTransientParsingError) );
       
   106         OstTraceFunctionExit0( CSBEPARSERPROXY_PARSEL_EXIT );
    92         }
   107         }
    93 
   108 
    94 	TInt CSBEParserProxy::ConvertToUnicodeL( TDes16& aUnicode, const TDesC8& aForeign )
   109 	TInt CSBEParserProxy::ConvertToUnicodeL( TDes16& aUnicode, const TDesC8& aForeign )
    95         {
   110         {
       
   111         OstTraceFunctionEntry0( CSBEPARSERPROXY_CONVERTTOUNICODEL_ENTRY );
    96         const TInt error = iConverter->ConvertToUnicode( aUnicode, aForeign, iConverterState );
   112         const TInt error = iConverter->ConvertToUnicode( aUnicode, aForeign, iConverterState );
    97 
   113 
    98 #ifdef SBE_LOGGING_ENABLED
       
    99         if  ( error != KErrNone )
   114         if  ( error != KErrNone )
   100             {
   115             {
   101             HBufC* copy = HBufC::NewL( aForeign.Length() * 2 );
   116             HBufC* copy = HBufC::NewL( aForeign.Length() * 2 );
   102             copy->Des().Copy( aForeign );
   117             copy->Des().Copy( aForeign );
   103 			__LOG2("CSBEParserProxy::ConvertToUnicode() - error: %d when converting: %S", error, copy );
   118             OstTraceExt2(TRACE_NORMAL, CSBEPARSERPROXY_CONVERTTOUNICODEL, "error: %d when converting: %S", error, *copy );
   104             delete copy;
   119             delete copy;
   105             }
   120             }
   106 #endif
   121 
   107 
   122         OstTraceFunctionExit0( CSBEPARSERPROXY_CONVERTTOUNICODEL_EXIT );
   108         return error;
   123         return error;
   109         }
   124         }
   110 		
   125 		
   111 	//	
   126 	//	
   112 	//  MContentHandler Implementaion //
   127 	//  MContentHandler Implementaion //
   114 
   129 
   115 	/** MContentHandler::OnStartDocumentL()
   130 	/** MContentHandler::OnStartDocumentL()
   116 	*/
   131 	*/
   117 	void CSBEParserProxy::OnStartDocumentL(const RDocumentParameters& aDocParam, TInt aErrorCode)
   132 	void CSBEParserProxy::OnStartDocumentL(const RDocumentParameters& aDocParam, TInt aErrorCode)
   118 		{
   133 		{
   119 		if (aErrorCode != KErrNone)
   134 		OstTraceFunctionEntry0( CSBEPARSERPROXY_ONSTARTDOCUMENTL_ENTRY );
   120 			{
   135 		if (aErrorCode != KErrNone)
   121 			__LOG1("CBackupRegistrationParser::OnStartDocumentL() - error = %d", aErrorCode);
   136 			{
       
   137 		    OstTrace1(TRACE_ERROR, CSBEPARSERPROXY_ONSTARTDOCUMENTL, "error = %d", aErrorCode);
   122 			User::Leave(aErrorCode);
   138 			User::Leave(aErrorCode);
   123 			}
   139 			}
   124 
   140 
   125         iTransientObserver->OnStartDocumentL( aDocParam, aErrorCode );
   141         iTransientObserver->OnStartDocumentL( aDocParam, aErrorCode );
       
   142 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONSTARTDOCUMENTL_EXIT );
   126 		}
   143 		}
   127 		
   144 		
   128 	/** MContentHandler::OnEndDocumentL()
   145 	/** MContentHandler::OnEndDocumentL()
   129 	*/
   146 	*/
   130 	void CSBEParserProxy::OnEndDocumentL(TInt aErrorCode)
   147 	void CSBEParserProxy::OnEndDocumentL(TInt aErrorCode)
   131 		{
   148 		{
       
   149 		OstTraceFunctionEntry0( CSBEPARSERPROXY_ONENDDOCUMENTL_ENTRY );
   132 		if (aErrorCode != KErrNone)
   150 		if (aErrorCode != KErrNone)
   133 			{
   151 			{
   134 			// just to satifsy UREL compiler
   152 			// just to satifsy UREL compiler
   135 			(void) aErrorCode;
   153 			(void) aErrorCode;
   136 			__LOG1("CBackupRegistrationParser::OnEndDocumentL() - error = %d", aErrorCode);
   154 			OstTrace1(TRACE_NORMAL, CSBEPARSERPROXY_ONENDDOCUMENTL, "error = %d", aErrorCode);
   137 			}
   155 			}
   138 
   156 
   139         iTransientObserver->OnEndDocumentL( aErrorCode );
   157         iTransientObserver->OnEndDocumentL( aErrorCode );
       
   158 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONENDDOCUMENTL_EXIT );
   140 		}
   159 		}
   141 		
   160 		
   142 	/** MContentHandler::OnStartElementL()
   161 	/** MContentHandler::OnStartElementL()
   143 
   162 
   144 	@leave KErrUnknown an unknown element
   163 	@leave KErrUnknown an unknown element
   145 	*/		
   164 	*/		
   146 	void CSBEParserProxy::OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode)
   165 	void CSBEParserProxy::OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode)
   147 		{
   166 		{
   148 		if (aErrorCode != KErrNone)
   167 		OstTraceFunctionEntry0( CSBEPARSERPROXY_ONSTARTELEMENTL_ENTRY );
   149 			{
   168 		if (aErrorCode != KErrNone)
   150 			__LOG1("CBackupRegistrationParser::OnStartElementL() - error = %d", aErrorCode);
   169 			{
   151 			User::LeaveIfError(aErrorCode);
   170 			LEAVEIFERROR(aErrorCode, OstTrace1(TRACE_ERROR, CSBEPARSERPROXY_ONSTARTELEMENTL, "error = %d", aErrorCode));
   152 			}
   171 			}
   153 
   172 
   154         iTransientObserver->OnStartElementL( aElement, aAttributes, aErrorCode );
   173         iTransientObserver->OnStartElementL( aElement, aAttributes, aErrorCode );
       
   174 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONSTARTELEMENTL_EXIT );
   155 		}
   175 		}
   156 
   176 
   157 	/** MContentHandler::OnEndElementL()
   177 	/** MContentHandler::OnEndElementL()
   158 	*/
   178 	*/
   159 	void CSBEParserProxy::OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
   179 	void CSBEParserProxy::OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
   160 		{
   180 		{
   161 		if (aErrorCode != KErrNone)
   181 		OstTraceFunctionEntry0( CSBEPARSERPROXY_ONENDELEMENTL_ENTRY );
   162 			{
   182 		if (aErrorCode != KErrNone)
   163 			__LOG1("CBackupRegistrationParser::OnEndElementL() - error = %d", aErrorCode);
   183 			{
       
   184 		    OstTrace1(TRACE_ERROR, CSBEPARSERPROXY_ONENDELEMENTL, "error = %d", aErrorCode);
   164 			User::Leave(aErrorCode);
   185 			User::Leave(aErrorCode);
   165 			}
   186 			}
   166 
   187 
   167         iTransientObserver->OnEndElementL( aElement, aErrorCode );
   188         iTransientObserver->OnEndElementL( aElement, aErrorCode );
       
   189 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONENDELEMENTL_EXIT );
   168 		}
   190 		}
   169 
   191 
   170 	/** MContentHandler::OnContentL()
   192 	/** MContentHandler::OnContentL()
   171 	*/
   193 	*/
   172 	void CSBEParserProxy::OnContentL(const TDesC8& aBytes, TInt aErrorCode)
   194 	void CSBEParserProxy::OnContentL(const TDesC8& aBytes, TInt aErrorCode)
   173 		{
   195 		{
       
   196         OstTraceFunctionEntry0( CSBEPARSERPROXY_ONCONTENTL_ENTRY );
   174         iTransientObserver->OnContentL( aBytes, aErrorCode );
   197         iTransientObserver->OnContentL( aBytes, aErrorCode );
       
   198 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONCONTENTL_EXIT );
   175 		}
   199 		}
   176 
   200 
   177 	/** MContentHandler::OnStartPrefixMappingL()
   201 	/** MContentHandler::OnStartPrefixMappingL()
   178 	*/
   202 	*/
   179 	void CSBEParserProxy::OnStartPrefixMappingL(const RString& aPrefix, const RString& aUri, TInt aErrorCode)
   203 	void CSBEParserProxy::OnStartPrefixMappingL(const RString& aPrefix, const RString& aUri, TInt aErrorCode)
   180 		{
   204 		{
       
   205         OstTraceFunctionEntry0( CSBEPARSERPROXY_ONSTARTPREFIXMAPPINGL_ENTRY );
   181         iTransientObserver->OnStartPrefixMappingL( aPrefix, aUri, aErrorCode );
   206         iTransientObserver->OnStartPrefixMappingL( aPrefix, aUri, aErrorCode );
       
   207 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONSTARTPREFIXMAPPINGL_EXIT );
   182 		}
   208 		}
   183 
   209 
   184 	/** MContentHandler::OnEndPrefixMappingL()
   210 	/** MContentHandler::OnEndPrefixMappingL()
   185 	*/
   211 	*/
   186 	void CSBEParserProxy::OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode)
   212 	void CSBEParserProxy::OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode)
   187 		{
   213 		{
       
   214         OstTraceFunctionEntry0( CSBEPARSERPROXY_ONENDPREFIXMAPPINGL_ENTRY );
   188         iTransientObserver->OnEndPrefixMappingL( aPrefix, aErrorCode );
   215         iTransientObserver->OnEndPrefixMappingL( aPrefix, aErrorCode );
       
   216 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONENDPREFIXMAPPINGL_EXIT );
   189 		}
   217 		}
   190 
   218 
   191 	/** MContentHandler::OnIgnorableWhiteSpaceL()
   219 	/** MContentHandler::OnIgnorableWhiteSpaceL()
   192 	*/
   220 	*/
   193 	void CSBEParserProxy::OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode)
   221 	void CSBEParserProxy::OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode)
   194 		{
   222 		{
       
   223         OstTraceFunctionEntry0( CSBEPARSERPROXY_ONIGNORABLEWHITESPACEL_ENTRY );
   195         iTransientObserver->OnIgnorableWhiteSpaceL( aBytes, aErrorCode );
   224         iTransientObserver->OnIgnorableWhiteSpaceL( aBytes, aErrorCode );
       
   225 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONIGNORABLEWHITESPACEL_EXIT );
   196 		}
   226 		}
   197 
   227 
   198 	/** MContentHandler::OnSkippedEntityL()
   228 	/** MContentHandler::OnSkippedEntityL()
   199 	*/
   229 	*/
   200 	void CSBEParserProxy::OnSkippedEntityL(const RString& aName, TInt aErrorCode)
   230 	void CSBEParserProxy::OnSkippedEntityL(const RString& aName, TInt aErrorCode)
   201 		{
   231 		{
       
   232         OstTraceFunctionEntry0( CSBEPARSERPROXY_ONSKIPPEDENTITYL_ENTRY );
   202         iTransientObserver->OnSkippedEntityL( aName, aErrorCode );
   233         iTransientObserver->OnSkippedEntityL( aName, aErrorCode );
       
   234 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONSKIPPEDENTITYL_EXIT );
   203 		}
   235 		}
   204 
   236 
   205 	/** MContentHandler::OnProcessingInstructionL()
   237 	/** MContentHandler::OnProcessingInstructionL()
   206 	*/
   238 	*/
   207 	void CSBEParserProxy::OnProcessingInstructionL(const TDesC8& aTarget, const TDesC8& aData, TInt aErrorCode)
   239 	void CSBEParserProxy::OnProcessingInstructionL(const TDesC8& aTarget, const TDesC8& aData, TInt aErrorCode)
   208 		{
   240 		{
       
   241         OstTraceFunctionEntry0( CSBEPARSERPROXY_ONPROCESSINGINSTRUCTIONL_ENTRY );
   209         iTransientObserver->OnProcessingInstructionL( aTarget, aData, aErrorCode );
   242         iTransientObserver->OnProcessingInstructionL( aTarget, aData, aErrorCode );
       
   243 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONPROCESSINGINSTRUCTIONL_EXIT );
   210 		}
   244 		}
   211 
   245 
   212 	/** MContentHandler::OnError()
   246 	/** MContentHandler::OnError()
   213 
   247 
   214 	@leave aErrorCode
   248 	@leave aErrorCode
   215 	*/
   249 	*/
   216 	void CSBEParserProxy::OnError(TInt aErrorCode)
   250 	void CSBEParserProxy::OnError(TInt aErrorCode)
   217 		{
   251 		{
   218 		__LOG1("CBackupRegistrationParser::OnError() - error = %d", aErrorCode);
   252 		OstTraceFunctionEntry0( CSBEPARSERPROXY_ONERROR_ENTRY );
       
   253 		OstTrace1(TRACE_NORMAL, CSBEPARSERPROXY_ONERROR, "error = %d", aErrorCode);
   219 		iTransientParsingError = aErrorCode;
   254 		iTransientParsingError = aErrorCode;
   220         iTransientObserver->OnError( aErrorCode );
   255         iTransientObserver->OnError( aErrorCode );
       
   256 		OstTraceFunctionExit0( CSBEPARSERPROXY_ONERROR_EXIT );
   221 		}
   257 		}
   222 
   258 
   223 	/** MContentHandler::OnEndPrefixMappingL()
   259 	/** MContentHandler::OnEndPrefixMappingL()
   224 	*/
   260 	*/
   225 	TAny* CSBEParserProxy::GetExtendedInterface(const TInt32 aUid)
   261 	TAny* CSBEParserProxy::GetExtendedInterface(const TInt32 aUid)