--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/upnpframework/upnputilities/src/upnpcommonutils.cpp Thu Dec 17 08:52:00 2009 +0200
@@ -0,0 +1,1124 @@
+/*
+* Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Upnp framework's common utility functions
+*
+*/
+
+
+// INCLUDE FILES
+// System
+#include <e32std.h>
+#include <upnpstring.h>
+#include <apmrec.h>
+#include <apgcli.h>
+#include <WlanCdbCols.h> // WLAN_SERVICE
+#include <caf/content.h> // CAF (WM-DRM check)
+#include <caf/agent.h> // CAF (WM-DRM check)
+#include <commdb.h>
+#include <in_sock.h>
+#include <pathinfo.h>
+
+// upnp stack api
+#include <upnpcontainerlist.h>
+#include <upnpcontainer.h>
+#include <upnpitem.h>
+#include <upnpdevice.h>
+
+// upnpframework / avcontroller helper api
+#include <upnpconstantdefs.h>
+
+// utilities internal
+#include "upnpfileutilitytypes.h"
+#include "upnpcommonutils.h"
+
+_LIT( KComponentLogfile, "upnputilities.txt");
+#include "upnplog.h"
+
+// CONSTANTS
+_LIT8( KMimeAudio, "audio" );
+_LIT8( KMimeVideo, "video" );
+_LIT8( KMimeImage, "image" );
+_LIT8( KMimePlaylist, "audio/mpegurl" );
+
+_LIT16( KXHtml16, ".XHTML" );
+_LIT16( KHtml16, ".HTML" );
+_LIT16( KXml16, ".XML" );
+_LIT16( KTxt16, ".TXT" );
+_LIT16( KJpeg16, ".JPEG" );
+_LIT16( KJpg16, ".JPG" );
+_LIT16( KGif16, ".GIF" );
+_LIT16( KPng16, ".PNG" );
+_LIT16( KMpeg16, ".MPEG" );
+_LIT16( KMpg16, ".MPG" );
+_LIT16( KMpeg416, ".MPEG4" );
+_LIT16( KAvi16, ".AVI" );
+_LIT16( KMp316, ".MP3" );
+_LIT16( KAac16, ".AAC" );
+_LIT16( KWma16, ".WMA" );
+_LIT8( KXHtml, "application/vnd.pwg-xhtml-print" );
+_LIT8( KHtml, "text/html" );
+_LIT8( KXml, "text/xml" );
+_LIT8( KTxt, "text/plain" );
+_LIT8( KJpg, "image/jpeg" );
+_LIT8( KGif, "image/gif" );
+_LIT8( KPng, "image/png" );
+_LIT8( KMpeg, "video/mpeg" );
+_LIT8( KMpeg4, "video/mpeg4" );
+_LIT8( KMp3, "audio/mpeg" );
+_LIT8( KAac, "audio/aac" );
+_LIT8( KWma, "audio/x-ms-wma" );
+_LIT8( KAvi, "video/x-msvideo" );
+
+
+_LIT( KLineFeed, "\r\n");
+_LIT8( KHttpDes, "http://" );
+_LIT( KTemp, "upnpfwtemp");
+
+_LIT8( KUnderScore, "_" );
+_LIT8( KStar, "*" );
+_LIT8( KColon, ":");
+_LIT8( KKorp, "<" );
+_LIT8( KProk, ">" );
+_LIT8( KQuotation, "\"" );
+_LIT8( KDoubleBackSlash, "\\" );
+_LIT8( KSlash, "/" );
+_LIT8( KQuestionMark, "?" );
+_LIT8( KPipe, "|" );
+_LIT8( KTab, "\t" );
+_LIT8( KSpace, " " );
+
+const TInt KPlaceHolderLength = 28;
+const TInt KBufferLength = 256;
+const TInt KBufferLengthSmall = 10;
+const TInt KCodeSemicolon = 58;
+const TInt KMask = 0xFF;
+const TInt KCodeDot = 46;
+
+
+_LIT( KUpnpDateString,"%F%Y-%M-%D");
+const TInt KMaxDateStringLength = 30;
+
+
+
+_LIT8( KAudioSupport, "audio/" );
+_LIT8( KImageSupport, "image/" );
+_LIT8( KVideoSupport, "video/" );
+
+_LIT8( KImageJpeg, "=JPEG_" );
+_LIT8( KImagePng, "=PNG_" );
+
+_LIT8( KAudioAc3, "=AC3" );
+_LIT8( KAudioAmr, "=AMR_" );
+_LIT8( KAudioAtra, "=ATRAC3plus" );
+_LIT8( KAudioLpcm, "=LPCM" );
+_LIT8( KAudioMp3, "=MP3" );
+_LIT8( KAudioAac, "=AAC_" );
+_LIT8( KAudioHeaac, "=HEAAC_" );
+_LIT8( KAudioBsac, "=BSAC_" );
+_LIT8( KAudioWmab, "=WMABASE" );
+_LIT8( KAudioWmaf, "=WMAFULL" );
+
+_LIT8( KAudioWmap, "=WMAPRO" );
+_LIT8( KVideoMpeg, "=MPEG" );
+_LIT8( KVideoAvc, "=AVC_" );
+_LIT8( KVideoWmvm, "=WMVMED_" );
+_LIT8( KVideoVmvh, "=WMVHIGH_" );
+_LIT8( KVideoWmvh, "=WMVHM_" );
+_LIT8( KVideoWmvspll, "=WMVSPLL_" );
+_LIT8( KVideoWmvspml, "=WMVSPML_" );
+// ============================ LOCAL FUNCTIONS =============================
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::MemoryCardStateL
+//---------------------------------------------------------------------------
+//
+EXPORT_C TBool UPnPCommonUtils::MemoryCardStateL()
+ {
+ TDriveInfo driveInfo;
+
+ TBool status = EFalse;
+ RFs fileServer;
+ User::LeaveIfError( fileServer.Connect() );
+ CleanupClosePushL( fileServer );
+ TInt error = fileServer.Drive( driveInfo, EDriveE );
+ CleanupStack::PopAndDestroy( &fileServer );
+
+ //check if memory card is present
+ if ( error == KErrNone && driveInfo.iType == EMediaHardDisk )
+ {
+ status = ETrue;
+ }
+
+ return status;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::ResolveMimeTypeL
+// Resolves the MIME type of a file. Leaves in error cases.
+// --------------------------------------------------------------------------
+EXPORT_C HBufC8* UPnPCommonUtils::ResolveMimeTypeL( const TDesC& aFileName )
+ {
+ HBufC8* mimetype = NULL;
+
+ mimetype = GetMimeTypeByExtensionL( aFileName );
+
+ // If the mime type was not recognized by the extension, try the
+ // platform mime type recognizer
+ if( !mimetype )
+ {
+ // finding server
+ RApaLsSession sess;
+ TInt error = sess.Connect();
+
+ // We have FS, File and RApaLs open
+ if ( error == KErrNone )
+ {
+ CleanupClosePushL( sess );
+
+ TUid id = TUid::Uid( 0 );
+ TDataType type;
+
+ error = sess.AppForDocument( aFileName, id, type );
+
+ if( error == KErrNone )
+ {
+ mimetype = HBufC8::NewL( type.Des8().Length() +
+ KLineFeed().Length() );
+ mimetype->Des().Append( type.Des8() );
+ mimetype->Des().Append( KLineFeed() );
+ }
+
+ // Clean up
+ CleanupStack::PopAndDestroy( &sess );
+ }
+ }
+
+ return mimetype;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::GetMimeTypeByExtensionL
+// Resolves the type of a file. Leaves in error cases.
+// --------------------------------------------------------------------------
+EXPORT_C HBufC8* UPnPCommonUtils::GetMimeTypeByExtensionL(
+ const TDesC& aFileName )
+ {
+ HBufC8* mimetype = NULL;
+ HBufC* tempFilename = aFileName.AllocL();
+ CleanupStack::PushL( tempFilename );
+
+ // Convert letters to upper case
+ tempFilename->Des().UpperCase();
+
+ TParse parse;
+ parse.Set( tempFilename->Des(), NULL, NULL );
+ TBufC<KMaxName> ext( parse.Ext() );
+
+ CleanupStack::PopAndDestroy( tempFilename );
+ tempFilename = NULL;
+
+ // FindC and length calculation is used,
+ // because compareC does not work for undefined reason
+
+ if ( ext.FindC( KHtml16 ) == 0 &&
+ ext.Length() == KHtml16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KHtml().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KHtml() );
+ }
+ else if ( ext.FindC( KXml16 ) == 0 &&
+ ext.Length() == KXml16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KXml().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KXml() );
+ }
+ else if ( ext.FindC( KTxt16 ) == 0 &&
+ ext.Length() == KTxt16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KTxt().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KTxt() );
+ }
+ else if ( ( ext.FindC( KJpg16 ) == 0 &&
+ ext.Length() == KJpg16().Length() ) ||
+ ( ext.FindC( KJpeg16 ) == 0 &&
+ ext.Length() == KJpeg16().Length() ) )
+ {
+ mimetype = HBufC8::NewLC( KJpg().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KJpg() );
+ }
+ else if ( ext.FindC( KGif16 ) == 0 &&
+ ext.Length() == KGif16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KGif().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KGif() );
+ }
+ else if ( ext.FindC( KPng16 ) == 0 &&
+ ext.Length() == KPng16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KPng().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KPng() );
+ }
+ else if ( ( ext.FindC( KMpg16 ) == 0 &&
+ ext.Length() == KMpg16().Length() ) ||
+ ( ext.FindC( KMpeg16 ) == 0 &&
+ ext.Length() == KMpeg16().Length() ) )
+ {
+ mimetype = HBufC8::NewLC( KMpeg().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KMpeg() );
+ }
+ else if ( ( ext.FindC( KMpeg416 ) == 0 &&
+ ext.Length() == KMpeg416().Length() ) )
+ {
+ mimetype = HBufC8::NewLC( KMpeg4().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KMpeg4() );
+ }
+ else if ( ext.FindC( KAvi16 ) == 0 &&
+ ext.Length() == KAvi16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KAvi().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KAvi() );
+ }
+ else if ( ext.FindC( KMp316 ) == 0 &&
+ ext.Length() == KMp316().Length() )
+ {
+ mimetype = HBufC8::NewLC( KMp3().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KMp3() );
+ }
+ else if ( ext.FindC( KXHtml16 ) == 0 &&
+ ext.Length() == KXHtml16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KXHtml().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KXHtml() );
+ }
+ else if ( ext.FindC( KAac16 ) == 0 &&
+ ext.Length() == KAac16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KAac().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KAac() );
+ }
+ else if ( ext.FindC( KWma16 ) == 0 &&
+ ext.Length() == KWma16().Length() )
+ {
+ mimetype = HBufC8::NewLC( KWma().Length() );
+ mimetype->Des().Zero();
+ mimetype->Des().Append( KWma() );
+ }
+ else
+ {
+ // Mime type not recognized. Return NULL.
+ }
+
+ if( mimetype )
+ {
+ CleanupStack::Pop( mimetype );
+ }
+
+ return mimetype;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::ResolveFileTypeL
+// Resolves the MIME type of a file. Leaves in error cases.
+// --------------------------------------------------------------------------
+EXPORT_C TUPnPItemType UPnPCommonUtils::ResolveFileTypeL(
+ const TDesC& aFileName )
+ {
+ TUPnPItemType returnValue = ETypeOther;
+
+ if( aFileName != KNullDesC )
+ {
+
+ HBufC8* mimetype = NULL;
+ mimetype = ResolveMimeTypeL( aFileName );
+ if( mimetype )
+ {
+ CleanupStack::PushL( mimetype );
+
+ if( mimetype->Des().Find( KMimeImage() ) >= 0 )
+ {
+ returnValue = ETypeImage;
+ }
+ else if( mimetype->Des().Find( KMimePlaylist() ) >= 0 )
+ {
+ returnValue = ETypePlaylist;
+ }
+ else if( mimetype->Des().Find( KMimeAudio() ) >= 0 )
+ {
+ returnValue = ETypeAudio;
+ }
+ else if( mimetype->Des().Find( KMimeVideo() ) >= 0 )
+ {
+ returnValue = ETypeVideo;
+ }
+ else
+ {
+ returnValue = ETypeOther;
+ }
+
+ // Clean up
+ CleanupStack::PopAndDestroy( mimetype );
+ mimetype = NULL;
+ }
+ else
+ {
+ returnValue = ETypeOther;
+ }
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ return returnValue;
+ }
+
+//---------------------------------------------------------------------------
+// UPnPCommonUtils::ReplacePlaceHolderInURIL
+// Replaces IP address and port number placeholders of the RES element's URI
+// string of the given item.
+//---------------------------------------------------------------------------
+//
+EXPORT_C void UPnPCommonUtils::ReplacePlaceHolderInURIL(
+ CUpnpItem& aItem,
+ const TInetAddr& aAddress )
+ {
+ __LOG( "UPnPCommonUtils::ReplacePlaceHolderInURIL" );
+
+ const RUPnPElementsArray& elms = aItem.GetElements();
+
+ TInt count = elms.Count();
+ TInt i = 0;
+ for( ; i < count; i++)
+ {
+ if( elms[ i ]->Name() == KElementRes )
+ {
+ TPtrC8 ptrC( elms[ i ]->Value() );
+
+ HBufC8* addrBuf = HBufC8::NewLC( KBufferLength );
+ addrBuf->Des().Append( KHttpDes );
+ TBuf8<KBufferLengthSmall> buf;
+ TChar separator( KCodeSemicolon );
+ TChar dot( KCodeDot );
+ TUint32 addr = aAddress.Address();
+ buf.Num( addr >> 24 ); // First part of the ip address
+ addrBuf->Des().Append( buf );
+ addrBuf->Des().Append( dot );
+ buf.Num( ( addr >> 16 ) & KMask ); // Second part of ip address
+ addrBuf->Des().Append( buf );
+ addrBuf->Des().Append( dot );
+ buf.Num( ( addr >> 8 ) & KMask ); // Third part of the ip address
+ addrBuf->Des().Append( buf );
+ addrBuf->Des().Append( dot );
+ buf.Num( addr & KMask ); // last part of the ip address
+ addrBuf->Des().Append( buf );
+ addrBuf->Des().Append( separator );
+
+ buf.Num( aAddress.Port() ); // port number
+ addrBuf->Des().Append( buf );
+
+ // Append rest of the uri
+ addrBuf->Des().Append( ptrC.Mid( KPlaceHolderLength ) );
+
+ __LOG8( *addrBuf );
+
+ elms[ i ]->SetValueL( *addrBuf );
+
+ CleanupStack::PopAndDestroy( addrBuf );
+ i = count;
+ }
+ }
+ }
+
+//---------------------------------------------------------------------------
+// UPnPCommonUtils::ReplaceIllegalFilenameCharactersL
+// Replaces the illegal filename characters from the given filename string
+// and returns a new fixed filename string. 8bit version.
+//---------------------------------------------------------------------------
+//
+EXPORT_C HBufC8* UPnPCommonUtils::ReplaceIllegalFilenameCharactersL(
+ const TDesC8& aFileName )
+ {
+ // Note that this implementation is a bit slow since it goes through the
+ // descriptor many times. Only one iteration would be optimal solution.
+ HBufC8* buf = HBufC8::NewLC( aFileName.Length() );
+ TPtr8 ptr = buf->Des();
+ ptr.Copy( aFileName );
+
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KProk(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KKorp(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KQuotation(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KDoubleBackSlash(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KSlash(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KStar(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KPipe(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KColon(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KQuestionMark(),
+ KUnderScore() );
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KTab(),
+ KUnderScore() );
+ CleanupStack::Pop(); // Can't pop by name, name invalid now
+ return buf;
+ }
+
+//---------------------------------------------------------------------------
+// UPnPCommonUtils::ReplaceIllegalFilenameCharactersL
+// Replaces the illegal filename characters from the given filename string
+// and returns a new fixed filename string. 16bit version.
+//---------------------------------------------------------------------------
+//
+EXPORT_C HBufC* UPnPCommonUtils::ReplaceIllegalFilenameCharactersL(
+ const TDesC& aFilename )
+ {
+ HBufC8* convertedParam = NULL;
+ convertedParam = UpnpString::FromUnicodeL( aFilename );
+ CleanupStack::PushL( convertedParam );
+
+ HBufC8* replacedFilename8 = NULL;
+ replacedFilename8 = ReplaceIllegalFilenameCharactersL( *convertedParam );
+ CleanupStack::PushL( replacedFilename8 );
+
+ HBufC* replacedFilename16 = NULL;
+ replacedFilename16 = UpnpString::ToUnicodeL( *replacedFilename8 );
+
+ // Clean up
+ CleanupStack::PopAndDestroy( replacedFilename8 );
+ CleanupStack::PopAndDestroy( convertedParam );
+
+ return replacedFilename16;
+ }
+
+//---------------------------------------------------------------------------
+// UPnPCommonUtils::IsPlaylistContainerL
+// Checks if the given CUpnpObject is a playlist container.
+//---------------------------------------------------------------------------
+//
+EXPORT_C TBool UPnPCommonUtils::IsPlaylistContainerL(
+ const CUpnpObject& aContainer )
+ {
+ TBool returnValue = EFalse;
+ if( aContainer.ObjectType() != EUPnPContainer ||
+ aContainer.ObjectClass() == KNullDesC8 )
+ {
+ User::Leave( KErrArgument );
+ }
+ else
+ {
+ if( aContainer.ObjectClass().CompareF( KClassPlaylist() ) == 0 )
+ {
+ returnValue = ETrue;
+ }
+ }
+ return returnValue;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::FindContainerByTitle
+// Finds container from CUpnpContainerList by title field
+// --------------------------------------------------------------------------
+//
+EXPORT_C CUpnpContainer* UPnPCommonUtils::FindContainerByTitle(
+ const CUpnpContainerList& aList, const TDesC8& aTitle )
+ {
+ TBool notFound( ETrue );
+ TInt index( 0 );
+ CUpnpContainer* tmp( NULL );
+
+ while ( index < aList.ObjectCount() && notFound )
+ {
+ tmp = static_cast< CUpnpContainer* >
+ ( aList[ index ] );
+ if ( tmp->Title().Compare( aTitle ) == 0 )
+ {
+ notFound = EFalse;
+ }
+ else
+ {
+ tmp = NULL;
+ }
+ index++;
+ }
+ return tmp;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::IntToDesC8LC
+// Returns IntValue for aObject
+// --------------------------------------------------------------------------
+//
+EXPORT_C HBufC8* UPnPCommonUtils::IntToDesC8LC(
+ const TInt& aObject )
+ {
+ HBufC8* buf = HBufC8::NewLC(12);
+ TPtr8 ptrBuf = buf->Des();
+
+ ptrBuf.Num(aObject);
+
+ return buf;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::DesC8ToInt
+// Returns IntValue for aObject
+// --------------------------------------------------------------------------
+//
+EXPORT_C TInt UPnPCommonUtils::DesC8ToInt(
+ const TDesC8& aObject )
+ {
+ TLex8 lex( aObject );
+
+ TInt lValue( KErrArgument );
+
+ lex.Val( lValue );
+ return lValue;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::TTimeToUPnPDateL
+// see upnpcommonutils.h
+// --------------------------------------------------------------------------
+EXPORT_C HBufC* UPnPCommonUtils::TTimeToUPnPDateL( TTime aTime )
+ {
+ TBuf<KMaxDateStringLength> date;
+ aTime.FormatL( date, KUpnpDateString );
+
+ return date.AllocL();
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::RenameFileL
+// see upnpcommonutils.h
+// --------------------------------------------------------------------------
+EXPORT_C HBufC* UPnPCommonUtils::RenameFileL( const TDesC& aFilePath )
+ {
+
+ //get the file extension include '.',e.g .jpg
+ TInt dot = aFilePath.LocateReverse( KCodeDot );
+ HBufC* extension = NULL;
+ if( dot > 0 ) //if there is extension
+ {
+ extension = aFilePath.Right( aFilePath.Length() - dot ).AllocL();
+ CleanupStack::PushL( extension );
+ }
+ else //if there is no extension
+ {
+ dot = aFilePath.Length();
+ }
+ // get the file path without extension: http://1.2.3//test
+ HBufC* leftString = aFilePath.Left( dot ).AllocL();
+ CleanupStack::PushL( leftString );
+
+ //rename it: http:://1.2.3//test_upnptemp.jpg
+ HBufC* name_upnpfwtemp = NULL;
+ if( extension )
+ {
+ name_upnpfwtemp = HBufC::NewL( leftString->Length() +
+ KTemp().Length() +
+ extension->Length() );
+ }
+ else
+ {
+ name_upnpfwtemp = HBufC::NewL( leftString->Length() +
+ KTemp().Length() );
+ }
+
+ name_upnpfwtemp->Des().Append( *leftString );
+ name_upnpfwtemp->Des().Append( KTemp() );
+
+ if( extension )
+ {
+ name_upnpfwtemp->Des().Append( *extension );
+ }
+
+
+ CleanupStack::PopAndDestroy( leftString );
+
+ if( extension )
+ {
+ CleanupStack::PopAndDestroy( extension );
+ }
+
+
+ CleanupStack::PushL( name_upnpfwtemp );
+
+ // try to rename the file
+ RFs fsSession;
+ User::LeaveIfError( fsSession.Connect() ); // connect session
+ CleanupClosePushL( fsSession );
+
+ TInt error = fsSession.Rename( aFilePath, *name_upnpfwtemp );
+
+ CleanupStack::PopAndDestroy( &fsSession );
+ CleanupStack::Pop( name_upnpfwtemp );
+
+ if( KErrNone == error )
+ {
+ return name_upnpfwtemp; //transfer ownership
+ }
+ else
+ {
+ delete name_upnpfwtemp;
+ return NULL;
+ }
+
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::DeleteTempFilesL
+// see upnpcommonutils.h
+// --------------------------------------------------------------------------
+EXPORT_C void UPnPCommonUtils::DeleteTempFilesL()
+ {
+ __LOG("UPnPCommonUtils::\
+DeleteTempFilesL begin");
+
+ RFs fs;
+ User::LeaveIfError( fs.Connect() ); // connect session
+ CleanupClosePushL( fs );
+
+ CFileMan* fileMan = CFileMan::NewL( fs );
+ CleanupStack::PushL( fileMan );
+ _LIT( KAnyChar, "*");
+ _LIT( KAnyExtension, "*.*");
+ _LIT( KUpnpUploadTempDirectory, "Download\\Media\\temp\\" );
+
+ // clean phone memory
+ HBufC* path = HBufC::NewLC( KMaxFileName );
+ TPtrC mcDrive( PathInfo::MemoryCardRootPath() );
+ path->Des().Append( mcDrive );
+ path->Des().Append( KUpnpUploadDirectory );
+ path->Des().Append( KAnyChar );
+ path->Des().Append( KTemp );
+ path->Des().Append( KAnyExtension );
+ fileMan->Delete( *path );
+
+ path->Des().Zero();
+ path->Des().Append( mcDrive );
+ path->Des().Append( KUpnpUploadTempDirectory );
+ path->Des().Append( KAnyExtension );
+ fileMan->Delete( *path );
+ CleanupStack::PopAndDestroy( path );
+
+ // clean memory card
+ path = HBufC::NewLC( KMaxFileName );
+ TPtrC phoneDrive( PathInfo::PhoneMemoryRootPath() );
+ path->Des().Append( phoneDrive );
+ path->Des().Append( KUpnpUploadDirectory );
+ path->Des().Append( KAnyChar );
+ path->Des().Append( KTemp );
+ path->Des().Append( KAnyExtension );
+ fileMan->Delete( *path );
+
+ path->Des().Zero();
+ path->Des().Append( phoneDrive );
+ path->Des().Append( KUpnpUploadTempDirectory );
+ path->Des().Append( KAnyExtension );
+ fileMan->Delete( *path );
+ CleanupStack::PopAndDestroy( path );
+
+ CleanupStack::PopAndDestroy( fileMan );
+ CleanupStack::PopAndDestroy( &fs );
+
+ __LOG("UPnPCommonUtils::\
+DeleteTempFilesL end");
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::IsImageSupported
+// see upnpcommonutils.h
+// --------------------------------------------------------------------------
+ EXPORT_C TBool UPnPCommonUtils::IsImageSupported( const TDesC8& aProtocolInfo )
+ {
+ // simple check
+ if( aProtocolInfo.Find( KImageSupport ) >= 0 )
+ {
+ return ETrue;
+ }
+
+
+ // check mime types
+ if( aProtocolInfo.FindC( KImageJpeg ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KImagePng ) > 0 )
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::IsAudioSupported
+// see upnpcommonutils.h
+// --------------------------------------------------------------------------
+EXPORT_C TBool UPnPCommonUtils::IsAudioSupported( const TDesC8& aProtocolInfo )
+ {
+ // simple check
+ if( aProtocolInfo.Find( KAudioSupport ) >= 0 )
+ {
+ return ETrue;
+ }
+
+
+ // check mime types
+ if( aProtocolInfo.FindC( KAudioAc3 ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioAmr ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioAtra ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioLpcm ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioMp3 ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioAac ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioHeaac ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioBsac ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioWmab ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioWmaf ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KAudioWmap ) > 0 )
+ {
+ return ETrue;
+ }
+
+
+ return EFalse;
+ }
+
+
+
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::IsVideoSupported
+// see upnpcommonutils.h
+// --------------------------------------------------------------------------
+EXPORT_C TBool UPnPCommonUtils::IsVideoSupported( const TDesC8& aProtocolInfo )
+ {
+ // simple check
+ if( aProtocolInfo.Find( KVideoSupport ) >= 0 )
+ {
+ return ETrue;
+ }
+
+
+ // check mime types
+ if( aProtocolInfo.FindC( KVideoMpeg ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KVideoAvc ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KVideoWmvm ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KVideoVmvh ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KVideoWmvh ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KVideoWmvspll ) > 0 )
+ {
+ return ETrue;
+ }
+
+ if( aProtocolInfo.FindC( KVideoWmvspml ) > 0 )
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+// --------------------------------------------------------------------------
+// UPnPCommonUtils::FileExtensionByMimeTypeL
+// See upnpfileutility.h
+//---------------------------------------------------------------------------
+//
+EXPORT_C HBufC* UPnPCommonUtils::FileExtensionByMimeTypeL(
+ const TDesC8& aMimeType )
+ {
+ HBufC* fileExt = NULL;
+
+ // XHTML
+ if( aMimeType.CompareC( KXHtmlMime ) == 0 )
+ {
+ fileExt = KXHtmlExt().AllocL();
+ }
+ // HTML
+ else if( aMimeType.CompareC( KHtmlMime ) == 0 )
+ {
+ fileExt = KHtmlExt().AllocL();
+ }
+ // XML
+ else if( aMimeType.CompareC( KXmlMime1 ) == 0 ||
+ aMimeType.CompareC( KXmlMime2 ) == 0 ||
+ aMimeType.CompareC( KXmlMime3 ) == 0 )
+ {
+ fileExt = KXmlExt().AllocL();
+ }
+ // TXT
+ else if( aMimeType.CompareC( KTxtMime ) == 0 ||
+ aMimeType.CompareC( KTxtMime2 ) == 0 ||
+ aMimeType.CompareC( KTxtMime3 ) == 0 ||
+ aMimeType.CompareC( KTxtMime4 ) == 0 ||
+ aMimeType.CompareC( KTxtMime5 ) == 0 ||
+ aMimeType.CompareC( KTxtMime6 ) == 0 )
+ {
+ fileExt = KTxtExt().AllocL();
+ }
+ // JPEG
+ else if( aMimeType.CompareC( KJpegMime ) == 0 )
+ {
+ fileExt = KJpegExt().AllocL();
+ }
+ // JPG
+ else if( aMimeType.CompareC( KJpegMime2 ) == 0 ||
+ aMimeType.CompareC( KJpegMime3 ) == 0 ||
+ aMimeType.CompareC( KJpegMime4 ) == 0 ||
+ aMimeType.CompareC( KJpegMime5 ) == 0 )
+ {
+ fileExt = KJpgExt().AllocL();
+ }
+ // GIF
+ else if( aMimeType.CompareC( KGifMime ) == 0 ||
+ aMimeType.CompareC( KGifMime2 ) == 0 ||
+ aMimeType.CompareC( KGifMime3 ) == 0 )
+ {
+ fileExt = KGifExt().AllocL();
+ }
+ // PNG
+ else if( aMimeType.CompareC( KPngMime ) == 0 ||
+ aMimeType.CompareC( KPngMime2 ) == 0 ||
+ aMimeType.CompareC( KPngMime3 ) == 0 )
+ {
+ fileExt = KPngExt().AllocL();
+ }
+ // MPG
+ else if( aMimeType.CompareC( KMpgMime1 ) == 0 ||
+ aMimeType.CompareC( KMpgMime2 ) == 0 ||
+ aMimeType.CompareC( KMpgMime3 ) == 0 ||
+ aMimeType.CompareC( KMpgMime4 ) == 0 ||
+ aMimeType.CompareC( KMpgMime5 ) == 0 ||
+ aMimeType.CompareC( KMpgMime6 ) == 0 ||
+ aMimeType.CompareC( KMpgMime7 ) == 0 ||
+ aMimeType.CompareC( KMpgMime10 ) == 0 )
+ {
+ fileExt = KMpgExt1().AllocL();
+ }
+ // MPEG4
+ else if( aMimeType.CompareC( KMpeg4Mime ) == 0 )
+ {
+ fileExt = KMpeg4Ext().AllocL();
+ }
+ // MP4
+ else if( aMimeType.CompareC( KMp4Mime ) == 0 ||
+ aMimeType.CompareC( KMp4Mime2 ) == 0 ||
+ aMimeType.CompareC( KMp4Mime3 ) == 0 )
+ {
+ fileExt = KMp4Ext().AllocL();
+ }
+ // AVI
+ else if( aMimeType.CompareC( KAviMime1 ) == 0 ||
+ aMimeType.CompareC( KAviMime2 ) == 0 ||
+ aMimeType.CompareC( KAviMime3 ) == 0 ||
+ aMimeType.CompareC( KAviMime4 ) == 0 ||
+ aMimeType.CompareC( KAviMime5 ) == 0 ||
+ aMimeType.CompareC( KAviMime6 ) == 0 ||
+ aMimeType.CompareC( KAviMime7 ) == 0 ||
+ aMimeType.CompareC( KAviMime8 ) == 0 ||
+ aMimeType.CompareC( KAviMime9 ) == 0 )
+ {
+ fileExt = KAviExt().AllocL();
+ }
+ // MP3
+ else if( aMimeType.CompareC( KMp3Mime1 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime2 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime3 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime4 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime5 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime6 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime7 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime8 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime9 ) == 0 ||
+ aMimeType.CompareC( KMp3Mime10 ) == 0 )
+ {
+ fileExt = KMp3Ext().AllocL();
+ }
+ // AAC
+ else if( aMimeType.CompareC( KAacMime ) == 0 ||
+ aMimeType.CompareC( KAacMime2 ) == 0 ||
+ aMimeType.CompareC( KAacMime3 ) == 0 ||
+ aMimeType.CompareC( KAacMime4 ) == 0 )
+ {
+ fileExt = KAacExt().AllocL();
+ }
+ //M4a
+ else if( aMimeType.CompareC( KM4aMime ) == 0 )
+ {
+ fileExt = KM4aExt().AllocL();
+ }
+ // WMA
+ else if( aMimeType.CompareC( KWmaMime ) == 0 ||
+ aMimeType.CompareC( KWmaMime2 ) == 0 )
+ {
+ fileExt = KWmaExt().AllocL();
+ }
+ // BMP
+ else if( aMimeType.CompareC( KBmpMime ) == 0 ||
+ aMimeType.CompareC( KBmpMime2 ) == 0 ||
+ aMimeType.CompareC( KBmpMime3 ) == 0 ||
+ aMimeType.CompareC( KBmpMime4 ) == 0 ||
+ aMimeType.CompareC( KBmpMime5 ) == 0 ||
+ aMimeType.CompareC( KBmpMime6 ) == 0 ||
+ aMimeType.CompareC( KBmpMime7 ) == 0 ||
+ aMimeType.CompareC( KBmpMime8 ) == 0 ||
+ aMimeType.CompareC( KBmpMime9 ) == 0 )
+ {
+ fileExt = KBmpExt().AllocL();
+ }
+ // 3GP
+ else if( aMimeType.CompareC( KAudio3gpp ) == 0 ||
+ aMimeType.CompareC( KVideo3gpp ) == 0 )
+ {
+ fileExt = K3gpExt().AllocL();
+ }
+ // AMR
+ else if( aMimeType.CompareC( KAudioAMR ) == 0 )
+ {
+ fileExt = KAmrExt().AllocL();
+ }
+ // WAV
+ else if( aMimeType.CompareC( KAudioWav ) == 0 ||
+ aMimeType.CompareC( KAudioXWav ) == 0 ||
+ aMimeType.FindC( KAudioL16 ) != KErrNotFound )
+ {
+ fileExt = KWavExt().AllocL();
+ }
+ // Real audio
+ else if ( aMimeType.CompareC( KRAMime8 ) == 0 )
+ {
+ fileExt = KRAExt().AllocL();
+ }
+ // TTS
+ else if( aMimeType.CompareC( KVideoTts ) == 0 )
+ {
+ fileExt = KTtsExt().AllocL();
+ }
+ // WMV
+ else if( aMimeType.CompareC( KWmvMime ) == 0 )
+ {
+ fileExt = KWmvExt().AllocL();
+ }
+ return fileExt;
+ }
+
+//---------------------------------------------------------------------------
+// UPnPCommonUtils::FixListboxItemTextL
+// Removes the tab character of the given text
+// and returns a new fixed text string. 8bit version.
+//---------------------------------------------------------------------------
+//
+EXPORT_C HBufC8* UPnPCommonUtils::FixListboxItemTextL( const TDesC8& aText )
+ {
+ HBufC8* fixedText = HBufC8::NewLC( aText.Length() );
+ TPtr8 ptr = fixedText->Des();
+ ptr.Copy( aText );
+
+ UpnpString::StringReplaceInPlaceL( ptr,
+ KTab(),
+ KSpace() );
+ CleanupStack::Pop(); // Can't pop by name, name invalid now
+ return fixedText;
+ }
+
+// End of File