diff -r 000000000000 -r 96612d01cf9f videofeeds/utils/src/CIptvUtil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videofeeds/utils/src/CIptvUtil.cpp Mon Jan 18 20:21:12 2010 +0200 @@ -0,0 +1,988 @@ +/* +* 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 the License "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: Utility class and constants used by Iptv application.* +*/ + + + + +// INCLUDE FILES +#include +#include +#include // RFs +#include // RApaLsSession +#include +#include +#include +//#include // Some Mime types used by player. +#include +#include + +#include "CIptvUtil.h" +#include "IptvDebug.h" +#include +#include "CIptvDriveMonitor.h" +#include "IptvExternalFolderInfo.h" + +// CONSTANTS + +_LIT(KIptvRootPathC, ":\\data\\videocenter"); // System drive +_LIT(KIptvRootPathE, ":\\data\\videocenter"); // E drive and other drives + +// Permanent folders. Beginning of path is generated dynamically. +_LIT( KMyVideosExternalFolderOwn, "My Videos" ); + +_LIT(KSlash,"\\"); +_LIT(KColonAndSlash, ":\\"); + +static const TInt KNumberOfLanguages = 96; + +typedef struct + { + TLanguage iLanguage; + char* iLanguageCode; + } SLanguageItem; + +static const SLanguageItem languageArray[ KNumberOfLanguages ] = + { + { ELangEnglish, "en" }, + { ELangFrench, "fr" }, + { ELangGerman, "de" }, + { ELangSpanish, "es" }, + { ELangItalian, "it" }, + { ELangSwedish, "sv" }, + { ELangDanish, "da" }, + { ELangNorwegian, "nn" }, + { ELangFinnish, "fi" }, + { ELangAmerican, "am" }, + { ELangSwissFrench, "sf" }, + { ELangSwissGerman, "sg" }, + { ELangPortuguese, "pt" }, + { ELangTurkish, "tr" }, + { ELangIcelandic, "is" }, + { ELangRussian, "ru" }, + { ELangHungarian, "hu" }, + { ELangDutch, "nl" }, + { ELangBelgianFlemish, "bl" }, + { ELangAustralian, "au" }, + { ELangBelgianFrench, "bf" }, + { ELangAustrian, "as" }, + { ELangNewZealand, "nz" }, + { ELangInternationalFrench, "if" }, + { ELangCzech, "cs" }, + { ELangSlovak, "sk" }, + { ELangPolish, "pl" }, + { ELangSlovenian, "sl" }, + { ELangTaiwanChinese, "tc" }, + { ELangHongKongChinese, "hk" }, + { ELangPrcChinese, "zh" }, + { ELangJapanese, "ja" }, + { ELangThai, "th" }, + { ELangAfrikaans, "af" }, + { ELangAlbanian, "sq" }, + { ELangAmharic, "ah" }, + { ELangArabic, "ar" }, + { ELangArmenian, "hy" }, + { ELangTagalog, "tl" }, + { ELangBelarussian, "be" }, + { ELangBengali, "bn" }, + { ELangBulgarian, "bg" }, + { ELangBurmese, "my" }, + { ELangCatalan, "ca" }, + { ELangCroatian, "hr" }, + { ELangCanadianEnglish, "ce" }, + { ELangInternationalEnglish, "ie" }, + { ELangSouthAfricanEnglish, "sa" }, + { ELangEstonian, "et" }, + { ELangFarsi, "fa" }, + { ELangCanadianFrench, "cf" }, + { ELangScotsGaelic, "gd" }, + { ELangGeorgian, "ka" }, + { ELangGreek, "el" }, + { ELangCyprusGreek, "gr" }, + { ELangGujarati, "gu" }, + { ELangHebrew, "he" }, + { ELangHindi, "hi" }, + { ELangIndonesian, "id" }, + { ELangIrish, "ga" }, + { ELangSwissItalian, "sz" }, + { ELangKannada, "kn" }, + { ELangKazakh, "kk" }, + { ELangKhmer, "km" }, + { ELangKorean, "ko" }, + { ELangLao, "lo" }, + { ELangLatvian, "lv" }, + { ELangLithuanian, "lt" }, + { ELangMacedonian, "mk" }, + { ELangMalay, "ms" }, + { ELangMalayalam, "ml" }, + { ELangMarathi, "mr" }, + { ELangMoldavian, "mo" }, + { ELangMongolian, "mn" }, + { ELangNorwegianNynorsk, "nn" }, + { ELangBrazilianPortuguese, "bp" }, + { ELangPunjabi, "pa" }, + { ELangRomanian, "ro" }, + { ELangSerbian, "sr" }, + { ELangSinhalese, "si" }, + { ELangSomali, "so" }, + { ELangInternationalSpanish, "os" }, + { ELangLatinAmericanSpanish, "ls" }, + { ELangSwahili, "sw" }, + { ELangFinlandSwedish, "fs" }, + { ELangTamil, "ta" }, + { ELangTelugu, "te" }, + { ELangTibetan, "bo" }, + { ELangTigrinya, "ti" }, + { ELangCyprusTurkish, "ct" }, + { ELangTurkmen, "tk" }, + { ELangUkrainian, "uk" }, + { ELangUrdu, "ur" }, + { ELangVietnamese, "vi" }, + { ELangWelsh, "cy" }, + { ELangZulu, "zu" } + }; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CIptvUtil::LongPrintL() +// ----------------------------------------------------------------------------- +// +#if IPTV_LOGGING_METHOD != 0 +EXPORT_C void CIptvUtil::LongPrintL( TDesC& aData ) + { + const TInt KMaxLength = 80; + TInt length = aData.Length(); + + if ( length > KMaxLength ) + { + for ( TInt i = 0; i <= length; i += KMaxLength ) + { + HBufC* temp = HBufC::NewLC( KMaxLength ); + TInt counter = length - i; + if ( counter < KMaxLength ) + { + temp->Des().Copy( aData.Mid( i, counter ) ); + } + else + { + temp->Des().Copy( aData.Mid( i, KMaxLength ) ); + } + + IPTVLOGSTRING2_HIGH_LEVEL("Value = %S", temp); + CleanupStack::PopAndDestroy( temp ); + } + } + else + { + IPTVLOGSTRING2_HIGH_LEVEL("Value = %S", &aData); + } + } +#else +EXPORT_C void CIptvUtil::LongPrintL( TDesC& /*aData*/ ) + { + } +#endif + +// ----------------------------------------------------------------------------- +// CIptvUtil::StringToInt() +// ----------------------------------------------------------------------------- +// +EXPORT_C TUint32 CIptvUtil::StringToInt(TDesC& value) + { + TUint32 id = 0; + if (value.Compare(_L("")) != 0) + { + TLex l(value); + l.Val(id, EDecimal); + } + return id; + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::GetPathL() +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::GetPathL( RFs& aFs, + TIptvPathSelection aSelection, + TDes& aPath, + TDriveNumber aDrive, + TBool aCreatePath ) + { + IPTVLOGSTRING_HIGH_LEVEL( "CIptvUtil::GetPathL(1) - Enter" ); + + TChar driveChar; + TUint driveDoubleChar; + + aFs.DriveToChar( aDrive, driveChar ); + driveDoubleChar = driveChar; + + // Most of the data is stored to "private" folder that is hidden so that + // harvesters don't find possible thumbnail pictures, etc. in them. + if ( aSelection != EIptvPathMyVideosVideo ) + { + if ( aDrive == EDriveC ) + { + aPath.Format( _L("%c%S"), driveDoubleChar, &KIptvRootPathC ); + } + else + { + aPath.Format( _L("%c%S"), driveDoubleChar, &KIptvRootPathE ); + } + + if ( aCreatePath ) + { + EnsureAndHidePathL( aFs, aPath, ETrue ); + } + } + // Videos and their thumbnails are stored under \My Videos. + else + { + if ( aDrive == EDriveC ) + { + TFileName cRoot = PathInfo::PhoneMemoryRootPath(); + aPath.Format( _L("%S%S"), &cRoot, &KMyVideosExternalFolderOwn ); + } + else + { + aPath.Format( _L("%c%S%S"), driveDoubleChar, + &KColonAndSlash, + &KMyVideosExternalFolderOwn ); + } + + if ( aCreatePath ) + { + EnsureAndHidePathL( aFs, aPath, EFalse ); + } + } + + // Add subfolder based on the exact path requested. + switch ( aSelection ) + { + case EIptvPathWritableRoot: + { + } + break; + + case EIptvPathTmp: + { + _LIT( KTempSuffix, "\\tmp" ); + aPath.Append( KTempSuffix ); + } + break; + + case EIptvPathMyVideosDb: + { + _LIT( KMyVideosDbSuffix, "\\mv" ); + aPath.Append( KMyVideosDbSuffix ); + } + break; + + case EIptvPathMyVideosVideo: + { + _LIT( KMyVideosVideoSuffix, "\\Downloads" ); + aPath.Append( KMyVideosVideoSuffix ); + } + break; + + case EIptvPathEcg: + { + _LIT( KContentGuideSuffix, "\\ecg" ); + aPath.Append( KContentGuideSuffix ); + } + break; + + case EIptvPathService: + { + _LIT( KServicePathSuffix, "\\srv" ); + aPath.Append( KServicePathSuffix ); + } + break; + + case EIptvPathEcgLive: + { + _LIT( KEcgLiveSuffix, "\\ecg\\live" ); + aPath.Append( KEcgLiveSuffix ); + } + break; + + case EIptvPathTmpLive: + { + _LIT( KTmpLiveSuffix, "\\tmp\\live" ); + aPath.Append( KTmpLiveSuffix ); + } + break; + + default: + { + IPTVLOGSTRING_HIGH_LEVEL("CIptvUtil::GetPathL(1) - Invalid argument!" ); + User::Leave( KErrPathNotFound ); + } + break; + } + + // Add trailing slash. + aPath.Append( KSlash ); + + // Ensure / hide the path, depending on exact path. + if ( aCreatePath ) + { + if ( aSelection == EIptvPathMyVideosVideo ) + { + EnsureAndHidePathL( aFs, aPath, EFalse ); + } + else + { + EnsureAndHidePathL( aFs, aPath, ETrue ); + } + } + + IPTVLOGSTRING2_HIGH_LEVEL( "CIptvUtil::GetPathL(1) - Exit (%S)", &aPath ); + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::GetPathL() +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::GetPathL( RFs& aFs, + TIptvPathSelection aSelection, + TUint32 aServiceId, + TDes& aPath, + TBool aCreatePath ) + { + IPTVLOGSTRING_HIGH_LEVEL("CIptvUtil::GetPathL(2) - Enter" ); + + switch ( aSelection ) + { + case EIptvPathEcgLive: + case EIptvPathTmpLive: + { + // First get normal path based on TIptvPathSelection + GetPathL( aFs, aSelection, aPath, EDriveC, aCreatePath ); + // Append serviceId directory at the end of the path as a directory + aPath.AppendNum( aServiceId ); + // Finally add '\' at the end of the path + aPath.Append( KSlash ); + } + break; + + case EIptvPathRssSearchThumbnail: + case EIptvPathRssThumbnail: + { + // First of all get the ecg path for thumbnails. + // Thumbnail path is c:\data\videocenter\ecg\\(stbn/tbn) + GetPathL( aFs, EIptvPathEcg, aPath, EDriveC, aCreatePath ); + + // Append serviceid and slash + aPath.AppendNum( aServiceId ); + aPath.Append( KSlash ); + + if ( aCreatePath ) + { + EnsureAndHidePathL( aFs, aPath, ETrue ); + } + + // Select thumbnail dir based on what client requested + if ( aSelection == EIptvPathRssThumbnail ) + { + _LIT( KIptvVodThumbnailDir, "tbn\\" ); + aPath.Append( KIptvVodThumbnailDir ); + } + else + { + _LIT( KSearchThumbnailDir, "stbn\\"); + aPath.Append( KSearchThumbnailDir ); + } + + // Now in aPath we have either + // \\data\\videocenter\\ecg\\\\tbn\\ + // or + // \\data\\videocenter\\ecg\\\\stbn\\ + // First one is for vod, second one is for search + } + break; + + default: + { + IPTVLOGSTRING_HIGH_LEVEL("CIptvUtil::GetPathL(2) - Invalid argument!" ); + User::Leave( KErrPathNotFound ); + } + break; + } + + if ( aCreatePath ) + { + EnsureAndHidePathL( aFs, aPath, ETrue ); + } + + IPTVLOGSTRING2_HIGH_LEVEL("CIptvUtil::GetPathL(2) - Exit (%S)", &aPath ); + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::ReadDes +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::ReadDesFromStreamL(TDes& aDes, RReadStream& aStream) + { + TInt i; + TInt length = aStream.ReadUint16L(); + + aDes.Zero(); + + if ( aDes.MaxLength() < length ) + { + User::Leave( KErrArgument ); + } + + for(i = 0; i < length; i++) + { + aDes.Append(aStream.ReadUint16L()); + } + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::WriteDes +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::WriteDesToStreamL(const TDesC& aDes, RWriteStream& aStream) + { + TInt i; + TInt length = aDes.Length(); + + aStream.WriteUint16L(length); + for(i = 0; i < length; i++) + { + aStream.WriteUint16L(aDes[i]); + } + } +// ----------------------------------------------------------------------------- +// CIptvUtil::ReadDes8 +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::ReadDes8FromStreamL(TDes8& aDes, RReadStream& aStream) + { + TInt i; + TInt length = aStream.ReadUint16L(); + + aDes.Zero(); + + if ( aDes.MaxLength() < length ) + { + User::Leave( KErrArgument ); + } + + for(i = 0; i < length; i++) + { + aDes.Append(aStream.ReadUint8L()); + } + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::WriteDes8 +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::WriteDes8ToStreamL(const TDesC8& aDes, RWriteStream& aStream) + { + TInt i; + TInt length = aDes.Length(); + + aStream.WriteUint16L(length); + for(i = 0; i < length; i++) + { + aStream.WriteUint8L(aDes[i]); + } + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::ReadUint64FromStream +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::ReadUint64FromStreamL(TUint64& aData, RReadStream& aStream) + { + TUint low = static_cast(aStream.ReadUint32L()); + TUint high = static_cast(aStream.ReadUint32L()); + aData = high; + aData = aData << 32; + aData |= low; + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::WriteTUint64ToStreamL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::WriteUint64ToStreamL(const TUint64 aData, RWriteStream& aStream) + { + aStream.WriteUint32L( aData & 0x00000000FFFFFFFFULL); + aStream.WriteUint32L( (aData & 0xFFFFFFFF00000000ULL) >> 32); + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::ReadHBufCFromStreamL +// ----------------------------------------------------------------------------- +// +EXPORT_C HBufC* CIptvUtil::ReadHBufCFromStreamL( RReadStream& aStream ) + { + TUint32 length = aStream.ReadUint32L(); + + HBufC* data = HBufC::NewL( length ); + CleanupStack::PushL( data ); // 1-> + + TPtr dataPtr( data->Des() ); + + for ( TInt i = 0; i < length; i++ ) + { + dataPtr.Append( aStream.ReadUint16L() ); + } + + CleanupStack::Pop( data ); // <-1 + return data; + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::WriteHBufCToStreamL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::WriteHBufCToStreamL( HBufC* aData, RWriteStream& aStream ) + { + aStream.WriteUint32L( aData->Length() ); + + TPtrC dataPtr( aData->Des() ); + + for ( TInt i = 0; i < aData->Length(); i++ ) + { + aStream.WriteUint16L( dataPtr[i] ); + } + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::GetLanguageByCountryCode +// ----------------------------------------------------------------------------- +// +EXPORT_C TLanguage CIptvUtil::GetLanguageByCountryCode( const TDesC& aLanguageCode ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvUtil::GetLanguageByCountryCode"); + + TLanguage language = ELangNone; + for( TInt i = 0; i < KNumberOfLanguages; i++ ) + { + SLanguageItem item = languageArray[i]; + TBuf8<10> buf; + buf.Copy( (unsigned char*) item.iLanguageCode ); + TBuf16<10> buf2; + buf2.Copy( buf ); + if( buf2.Compare( aLanguageCode ) == 0 ) + { + language = item.iLanguage; + i = KNumberOfLanguages; + } + } + + IPTVLOGSTRING2_LOW_LEVEL("CIptvUtil::GetLanguageByCountryCode Language to be used = %d (65535 = ELangNone)", language); + return language; + } + +// ----------------------------------------------------------------------------- +// Runs recognizers on the given file to determine its mime type +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIptvUtil::RecognizeFile( + RFs& aFsSession, + const TDesC& aFilePath, + TDataType& aDataType ) + { + TBuf8<200> buffer; // Enough file content to recognize the type + RFile file; + TInt err = file.Open( aFsSession, aFilePath, EFileRead | EFileShareAny ); + if ( err == KErrNone ) + { + err = file.Read( buffer ); + file.Close(); + + if ( err == KErrNone ) + { + RApaLsSession apaSession; + err = apaSession.Connect(); + if ( err == KErrNone ) + { + TDataRecognitionResult result; + err = apaSession.RecognizeData( aFilePath, buffer, result ); + if ( result.iConfidence >= CApaDataRecognizerType::EProbable ) + { + aDataType = result.iDataType; + } + + apaSession.Close(); + } + } + } + + return err; + } + +// ----------------------------------------------------------------------------- +// Runs recognizers on the given file to determine its mime type +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIptvUtil::RecognizeFile( + const RFile& aFileHandle, + TDataType& aDataType ) + { +#ifdef __S60_30__ + + IPTVLOGSTRING_HIGH_LEVEL( "CIptvUtil::RecognizeFile() returns KErrNotSupported" ); + ( void )aFileHandle; + return KErrNotSupported; + +#else // __S60_30__ + + RApaLsSession apaSession; + TInt err( apaSession.Connect() ); + if ( err == KErrNone ) + { + TDataRecognitionResult result; + err = apaSession.RecognizeData( const_cast( aFileHandle ), result ); + if ( result.iConfidence >= CApaDataRecognizerType::EProbable ) + { + aDataType = result.iDataType; + } + + apaSession.Close(); + } + + return err; + +#endif // __S60_30__ + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::RemoveTrailingBackSlashesL() +// ----------------------------------------------------------------------------- +// +void CIptvUtil::RemoveTrailingBackSlashesL( HBufC* & aString ) + { + while ( aString->LocateReverse( '\\' ) == ( aString->Length() - 1 ) ) + { + aString->Des().SetLength( aString->Length() - 1 ); + } + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::ConnectionTypeL +// ----------------------------------------------------------------------------- +// +EXPORT_C CIptvUtil::TConnectionType CIptvUtil::ConnectionTypeL(TUint32 aIapId) + { + TBool isHiddenWlanIap; + return ConnectionTypeL(aIapId, isHiddenWlanIap); + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::ConnectionTypeL +// ----------------------------------------------------------------------------- +// +EXPORT_C CIptvUtil::TConnectionType CIptvUtil::ConnectionTypeL( TUint32 aIapId, + TBool& aIsHiddenWlanIap ) + { + TConnectionType connectionType = EUnknown; + + CCommsDatabase* commsDbIap = CCommsDatabase::NewL(); + CleanupStack::PushL(commsDbIap); // 1-> + CCommsDbTableView* iapTableView; + iapTableView = commsDbIap->OpenTableLC(TPtrC(IAP)); // 2-> + + //Search correct iap and pick connection type + TInt err = iapTableView->GotoFirstRecord(); + while(err == KErrNone) + { + TUint32 iapId; + iapTableView->ReadUintL(TPtrC(COMMDB_ID), iapId); + + if ( aIapId == iapId ) + { + TBuf colText; + TUint32 serviceId; + + iapTableView->ReadUintL(TPtrC(IAP_SERVICE), serviceId); + iapTableView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), colText); + + if ( colText == KIptvUtilLanService ) + { + //was lan service + if ( IsWlanIapL( serviceId, aIsHiddenWlanIap ) ) + { + //was wlan iap + connectionType = EWlan; + } + } + else if ( colText == KIptvUtilOutGoingGprs ) + { + connectionType = EGprs; + } + else if( colText == KIptvUtilDialOutISP ) + { + connectionType = ECsd; + } + break; + } + err = iapTableView->GotoNextRecord(); + } + + CleanupStack::PopAndDestroy(iapTableView); //<-2 + CleanupStack::PopAndDestroy(commsDbIap); //<-1 + + return connectionType; + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::IsWlanIapL +// ----------------------------------------------------------------------------- +// +#ifndef __WINSCW__ + +EXPORT_C TBool CIptvUtil::IsWlanIapL(TUint32 aIapService) + { + TBool isHiddenWlanIap; + return IsWlanIapL( aIapService, isHiddenWlanIap ); + } + +#else + +EXPORT_C TBool CIptvUtil::IsWlanIapL(TUint32 /*aIapService*/) + { + return EFalse; + } + +#endif + +// ----------------------------------------------------------------------------- +// CIptvUtil::IsWlanIapL +// ----------------------------------------------------------------------------- +// +#ifdef __WINSCW__ + +EXPORT_C TBool CIptvUtil::IsWlanIapL( TUint32 /*aIapService*/, TBool& /*aIsHiddenWlanIap*/) + { + return EFalse; + } + +#else + +EXPORT_C TBool CIptvUtil::IsWlanIapL( TUint32 aIapService, TBool& aIsHiddenWlanIap ) + { + TBool retval; + + CCommsDbTableView* wlantable = NULL; + CCommsDatabase* commsDbWlan = CCommsDatabase::NewL( EDatabaseTypeUnspecified ); + CleanupStack::PushL( commsDbWlan ); // 1-> + wlantable = commsDbWlan->OpenViewMatchingUintLC( TPtrC(WLAN_SERVICE), + TPtrC(WLAN_SERVICE_ID), + aIapService ); // 2-> + + TInt err = wlantable->GotoFirstRecord(); + if ( err == KErrNotFound ) + { + //is not a wlan iap + retval = EFalse; + } + else + { + User::LeaveIfError( err ); + //is a wlan iap + TUint32 scanSsid = 0; + wlantable->ReadUintL( TPtrC(WLAN_SCAN_SSID), scanSsid ); + aIsHiddenWlanIap = static_cast( scanSsid ); + retval = ETrue; + } + + CleanupStack::PopAndDestroy( wlantable ); // <-2 + CleanupStack::PopAndDestroy( commsDbWlan ); // <-1 + + return retval; + } +#endif + +// ----------------------------------------------------------------------------- +// CIptvUtil::GetAllowedIapsListL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::GetAllowedIapsListL( RArray& aAllowedIaps ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvUtil::GetAllowedIapsListL() - Enter" ); + + CCommsDatabase* database = NULL; + CCommsDbTableView* view = NULL; + TInt result = KErrNotFound; + TUint32 iapId = 0; + + aAllowedIaps.Reset(); + + database = CCommsDatabase::NewL(); + CleanupStack::PushL( database ); + +// For ARMV5 we do the check as we should, by taking IAPs from WAP_ACCESS_POINT table. +#if !defined(__WINS__) && !defined(__WINSCW__) + + TUint32 wapId = 0; + CCommsDbTableView* wapbearer = NULL; + + view = database->OpenTableLC( TPtrC( WAP_ACCESS_POINT ) ); + result = view->GotoFirstRecord(); + + while ( result == KErrNone ) + { + view->ReadUintL( TPtrC( COMMDB_ID ), wapId ); + + wapbearer = database->OpenViewMatchingUintLC( TPtrC( WAP_IP_BEARER ), + TPtrC( WAP_ACCESS_POINT_ID ), + wapId ); + wapbearer->GotoFirstRecord(); + wapbearer->ReadUintL( TPtrC( WAP_IAP ), iapId ); + +#ifdef _DEBUG + + TBuf<40> name; + wapbearer->ReadTextL( TPtrC( COMMDB_NAME ), name ); + IPTVLOGSTRING3_LOW_LEVEL( + "CIptvUtil::GetAllowedIapsListL(ARMV5) adding IAP ID %d (%S).", + iapId, + &name ); + +#endif // _DEBUG + + CleanupStack::PopAndDestroy( wapbearer ); + aAllowedIaps.AppendL( iapId ); + result = view->GotoNextRecord(); + } + +// For WINSCW we read IAP table as WAP_ACCESS_POINT table is not normally configured. +#else + + view = database->OpenTableLC( TPtrC( IAP ) ); + result = view->GotoFirstRecord(); + + while ( result == KErrNone ) + { + view->ReadUintL( TPtrC( COMMDB_ID ), iapId ); + +#ifdef _DEBUG + + TBuf<40> name; + view->ReadTextL( TPtrC( COMMDB_NAME ), name ); + IPTVLOGSTRING3_LOW_LEVEL( + "CIptvUtil::GetAllowedIapsListL(WINSCW) adding IAP ID %d (%S).", + iapId, + &name ); + +#endif // _DEBUG + + aAllowedIaps.AppendL( iapId ); + result = view->GotoNextRecord(); + } + +#endif // if !defined(__WINS__) && !defined(__WINSCW__) + + CleanupStack::PopAndDestroy( view ); + CleanupStack::PopAndDestroy( database ); + + IPTVLOGSTRING_LOW_LEVEL( "CIptvUtil::GetAllowedIapsListL() - Exit" ); + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::IsAllowedIapL +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CIptvUtil::IsAllowedIapL( TUint32 aIapId, RArray& aAllowedIaps ) + { + TBool allowed = EFalse; + + for ( TInt i = 0; i < aAllowedIaps.Count(); i++ ) + { + if ( aIapId == aAllowedIaps[i] ) + { + allowed = ETrue; + break; + } + } + + IPTVLOGSTRING3_LOW_LEVEL( "CIptvUtil::IsAllowedIapL() returning %d for IAP %d", + static_cast( allowed ), + aIapId ); + + return allowed; + } + +// ----------------------------------------------------------------------------- +// CIptvUtil::EnsureAndHidePathL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIptvUtil::EnsureAndHidePathL( RFs& aFsSession, + const TDesC& aPath, + TBool aHide ) + { + if ( aPath.Length() == 0 ) + { + IPTVLOGSTRING_LOW_LEVEL( + "CIptvUtil::EnsureAndHidePathL() empty path supplied!" ); + User::Leave( KErrArgument ); + } + + // Ensure that the path exists. + TRAPD( baflError, BaflUtils::EnsurePathExistsL( aFsSession, aPath ) ); + + if ( baflError != KErrNone && + ( aPath[0] == 'c' || aPath[0] == 'C' ) ) + { + IPTVLOGSTRING2_LOW_LEVEL( + "CIptvUtil::EnsureAndHidePathL() problem %d with C-drive!", baflError ); + User::Leave( baflError ); + } + + // Hide the path if requested. + if ( aHide && baflError == KErrNone ) + { + TUint attValue = 0; + if ( aFsSession.Att( aPath, attValue ) == KErrNone ) + { + if ( ! ( attValue & KEntryAttHidden ) ) + { + User::LeaveIfError( aFsSession.SetAtt( aPath, KEntryAttHidden, 0 ) ); + } + } + } + } + +// ---------------------------------------------------------------------------- +// CIptvUtil::LastPlaybackPositionFeatureSupported +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool CIptvUtil::LastPlaybackPositionFeatureSupported() + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvUtil::LastPlaybackPositionFeatureSupported() - Enter" ); + + TBool isSupported( ETrue ); + + CRepository* cenRep( NULL ); + TRAP_IGNORE( cenRep = CRepository::NewL( KIptvCenRepUid ) ); + + if ( cenRep ) + { + cenRep->Get( KIptvCenRepLastPlaybackPositionFeatureKey, isSupported ); + delete cenRep; + } + IPTVLOGSTRING2_LOW_LEVEL( + "CIptvUtil::LastPlaybackPositionFeatureSupported() - Exit, return value = %b", isSupported ); + + return isSupported; + }