examples/SFExamples/RecipeEx/src/DeviceCapabilitiesScan.cpp

// Symbian Foundation Example Code
// 
// This software is in the public domain. No copyright is claimed, and you 
// may use it for any purpose without license from the Symbian Foundation.
// No warranty for any purpose is expressed or implied by the authors or
// the Symbian Foundation. 


#include <VersionInfo.h> 
#include <F32File.h> 
#include <W32std.h>
#include <HAL.h>
#include <aknutils.h>

#include <ecom/ecom.h>
#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <sensrvchannelfinder.h>
#include <sensrvchannel.h>
#include <sensrvmagnetometersensor.h>
#include <sensrvgeneralproperties.h>
#include <sensrvmagnetometersensor.h>
#include <sensrvaccelerometersensor.h>
#include <sensrvmagneticnorthsensor.h>
#include <sensrvproximitysensor.h>
#include <sensrvilluminationsensor.h>
#include <sensrvorientationsensor.h>
#include <sensrvdatalistener.h> 
#include <sensrvtappingsensor.h> 
#include <sensrvtypes.h> 
#include <PtiEngine.h>
#include <ptilanguage.h>


#include "DeviceCapabilitiesScan.h"
#include "LogContainer.h"

// Constants

#define KMmfUidPluginInterfaceCodec                             0x101F4AA6
//#define KMmfUidPluginInterfaceFormatEncode            0x101F53BF
//#define KMmfUidPluginInterfaceFormatDecode            0x101F53BE
//#define KMmfUidPluginInterfaceDataSource              0x101F53AF
//#define KMmfUidPluginInterfaceDataSink                        0x101F53B0
//#define KMmfUidPluginInterfaceController              0x101F4F47
//#define KMmfUidPluginInterfaceHwDevice                        0x101F4AA8
//#define KUidDevVideoDecoderHwDeviceDefine     0x101fb4be
//#define KUidDevVideoPostProcessorHwDeviceDefine 0x101fb4bf
//#define KUidDevVideoEncoderHwDeviceDefine     0x101fb4c0
//#define KUidDevVideoPreProcessorHwDeviceDefine  0x101fb4c1

static TInt interfaceUids[]=
        {
        KMmfUidPluginInterfaceCodec//,
        //KMmfUidPluginInterfaceFormatEncode,
        //KMmfUidPluginInterfaceFormatDecode,
        //KMmfUidPluginInterfaceDataSource,
        //KMmfUidPluginInterfaceDataSink,
        //KMmfUidPluginInterfaceController,
        //KMmfUidPluginInterfaceHwDevice,
        //KUidDevVideoDecoderHwDeviceDefine,
        //KUidDevVideoPostProcessorHwDeviceDefine,
        //KUidDevVideoEncoderHwDeviceDefine,
        //KUidDevVideoPreProcessorHwDeviceDefine
        };

_LIT(KFailure, "Failed to retrieve capabilities with error code %d");

_LIT(KDisplayMode0, "ENone");
_LIT(KDisplayMode1, "EGray2");
_LIT(KDisplayMode2, "EGray4");
_LIT(KDisplayMode3, "EGray16");
_LIT(KDisplayMode4, "EGray256");
_LIT(KDisplayMode5, "EColor16");
_LIT(KDisplayMode6, "EColor256");
_LIT(KDisplayMode7, "EColor64K");
_LIT(KDisplayMode8, "EColor16M");
_LIT(KDisplayMode9, "ERgb");
_LIT(KDisplayMode10, "EColor4K");
_LIT(KDisplayMode11, "EColor16MU");
_LIT(KDisplayMode12, "EColor16MA");
_LIT(KDisplayMode13, "EColor16MAP");
_LIT(KDisplayMode14, "EColorLast");

_LIT(KOrientation0, "EGraphicsOrientationNormal");
_LIT(KOrientation1, "EGraphicsOrientationRotated90");
_LIT(KOrientation2, "EGraphicsOrientationRotated180");
_LIT(KOrientation3, "EGraphicsOrientationRotated270");

_LIT(KTxtChannelDoubleTapping, "DoubleTapping");        
_LIT(KTxtChannelTapping, "Tapping");    
_LIT(KTxtChannelOrientation, "Orientation");    
_LIT(KTxtChannelRotation, "Rotation");
_LIT(KTxtChannelProximity, "Proximity");
_LIT(KTxtChannelMagnetometer, "Magnetometer");  
_LIT(KTxtChannelMagneticNorth, "Magnetic North");       
_LIT(KTxtChannelAmbientLight, "Ambient Light");
_LIT(KTxtChannelAccelerometer, "Accelerometer");
_LIT(KTxtChannelUnknown, "Unknown");


CDeviceCapabilitiesScan::CDeviceCapabilitiesScan(CLogContainer* aLogView) :
        CActive(EPriorityStandard), 
        iLogView(aLogView)
        {
        }

CDeviceCapabilitiesScan* CDeviceCapabilitiesScan::NewLC(CLogContainer* aLogView)
        {
        CDeviceCapabilitiesScan* self = new (ELeave) CDeviceCapabilitiesScan(aLogView);
        CleanupStack::PushL(self);
        self->ConstructL();
        return self;
        }

CDeviceCapabilitiesScan* CDeviceCapabilitiesScan::NewL(CLogContainer* aLogView)
        {
        CDeviceCapabilitiesScan* self = CDeviceCapabilitiesScan::NewLC(aLogView);
        CleanupStack::Pop(self); 
        return self;
        }

void CDeviceCapabilitiesScan::ConstructL()
        {
        CActiveScheduler::Add(this); // Add to scheduler
        }

CDeviceCapabilitiesScan::~CDeviceCapabilitiesScan()
        {
        Cancel(); // Cancel any request, if outstanding
        // Delete instance variables if any
        }

void CDeviceCapabilitiesScan::DoCancel()
        {
        }

void CDeviceCapabilitiesScan::Start()
        {
        Cancel(); // Cancel any request, just to be sure
                
        // Begin in the uninitialized state then complete the active object.
        // We can then move to the next state within the RunL.
        iState = EUninitialized;
        SelfComplete(KErrNone);
        }

void CDeviceCapabilitiesScan::RunL()
        {
        if (iStatus.Int()!=KErrNone)
                {
                TBuf<50> errBuf;
                errBuf.Format(KFailure, iStatus.Int());
                if (iLogView)
                        {
                        iLogView->LogEntryL(errBuf);
                        iState = EError;
                        return;
                        }
                }
        
        switch (iState)
                {
                case EUninitialized:
                        {
                        // First we will discover platform version information.
                        TRAPD(err, DiscoverPlatformVersionTextL());
                        SelfComplete(err);
                        break;
                        }
                case EDiscoveringPlatformVersion:
                        {
                        // Get screen data
                        TRAPD(err, DiscoverDisplayScreensInfoL());
                        SelfComplete(err);
                        break;
                        }
                case EDiscoveringDisplayScreenInfo:
                        {
                        // Get Touch support
                        TRAPD(ret, DiscoverAvailableInputModesL());
                        SelfComplete(ret);
                        break;
                        }
                case EDiscoveringInputCapabilities:     
                        {
                        // Discover multimedia plugin support
                        TRAPD(err, DiscoverMultimediaPluginSupportL());
                        SelfComplete(err);
                        break;
                        }       
                case EDiscoveringMultimediaEcomPlugins:
                        {
                        // Discover available sensors
                        TRAPD(err, DiscoverAvailableSensorsL());
                        SelfComplete(err);
                        break;
                        }       
                default:
                        break;
                }
        
        }

TInt CDeviceCapabilitiesScan::RunError(TInt /*aError*/)
        {
        return KErrNone;
        }

void CDeviceCapabilitiesScan::SelfComplete(TInt aErr)
        {
        iStatus = KRequestPending;
        SetActive();
        TRequestStatus* pStatus = &iStatus;
        User::RequestComplete(pStatus,aErr);
        }


/*
 * Discover and log the platform version information string
 */
void CDeviceCapabilitiesScan::DiscoverPlatformVersionTextL()
        {
        _LIT(KTxtPlatformVersionTitle, "Identifying Platform");
        _LIT(KTxtPlatformVersion, "Platform Version: %d.%d");
        _LIT(KTxtPlatformVersionUnavailable, "Platform Version: Unavailable");
        
        iState = EDiscoveringPlatformVersion;
        iLogView->LogSectionTitleL(KTxtPlatformVersionTitle);
        
        RFs fs;
        User::LeaveIfError(fs.Connect());
        CleanupClosePushL(fs);
        
        VersionInfo::TPlatformVersion platformVersion;
        TInt ret = VersionInfo::GetVersion(platformVersion, fs);
        
        CleanupStack::PopAndDestroy(&fs);
        
        if (ret == KErrNone)
                {
                iLogView->LogEntryL(KTxtPlatformVersion, platformVersion.iMajorVersion, platformVersion.iMinorVersion);
                }
        else
                {
                iLogView->LogEntryL(KTxtPlatformVersionUnavailable);
                }
        
        }

void CDeviceCapabilitiesScan::FormatScreenInfoByModeL(CWsScreenDevice& aScreenDevice, TInt aScreenMode)
        {
        _LIT(KTxtDisplayScreensStep3, "Screen mode: %d");
        _LIT(KTxtDisplayScreensStep4, "Width: %d pixels, %d twips");    
        _LIT(KTxtDisplayScreensStep5, "Height: %d pixels, %d twips");
        _LIT(KTxtDisplayScreensStep6, "Orientation: %S");       
        
        // Discover screen orientation, height and width in pixels and twips, for this screen mode
        TPixelsTwipsAndRotation result;
        aScreenDevice.GetScreenModeSizeAndRotation(aScreenMode, result);

        // Log mode.
        iLogView->LogEntryL(KTxtDisplayScreensStep3, aScreenMode);
        
        // Log width and height
        iLogView->LogEntryL(KTxtDisplayScreensStep4, result.iPixelSize.iWidth, result.iTwipsSize.iWidth);
        iLogView->LogEntryL(KTxtDisplayScreensStep5, result.iPixelSize.iHeight, result.iTwipsSize.iHeight);     
        
        // Log orientation
        iLogView->LogEntryL(KTxtDisplayScreensStep6, &(Orientation(result.iRotation))); 
        }

void CDeviceCapabilitiesScan::DiscoverDisplayScreensInfoL()
        {
        _LIT(KTxtDisplayScreensTitle, "Screen information");
        _LIT(KTxtDisplayScreensStep1, "Number of screens: %d");
        _LIT(KTxtDisplayScreensStep2, "Screen: %d, Display mode: %S");
        
        iState = EDiscoveringDisplayScreenInfo;
        iLogView->LogSectionTitleL(KTxtDisplayScreensTitle);

        RWsSession wsSession;
        User::LeaveIfError(wsSession.Connect());
        CleanupClosePushL(wsSession);
        
        TInt numScreens=0;      
        User::LeaveIfError(  HAL::Get( HAL::EDisplayNumberOfScreens, numScreens ) ) ; 
        
        // Log the number of screens
        iLogView->LogEntryL(KTxtDisplayScreensStep1, numScreens);

        for (TInt i=0; i<numScreens; i++)
                {
                CWsScreenDevice* screenDevice = new (ELeave) CWsScreenDevice(wsSession);
                CleanupStack::PushL(screenDevice);
                User::LeaveIfError(screenDevice->Construct(i));
                
                // Log the screen number and display mode
                iLogView->LogEntryL(KTxtDisplayScreensStep2, i, &(DisplayMode(screenDevice->DisplayMode())));

                for (TInt j=0; j<screenDevice->NumScreenModes(); j++)
                        {
                        FormatScreenInfoByModeL(*screenDevice, j);                      
                        }
                
                CleanupStack::PopAndDestroy(screenDevice);
                screenDevice = NULL;
                }

        CleanupStack::PopAndDestroy(&wsSession);
        }

const TDesC& CDeviceCapabilitiesScan::DisplayMode(TDisplayMode aMode)
        {
        switch (aMode)
                {
                case ENone:
                        {
                        return KDisplayMode0;
                        }
                case EGray2:
                        {
                        return KDisplayMode1;
                        }
                case EGray4:
                        {
                        return KDisplayMode2;
                        }
                case EGray16:
                        {
                        return KDisplayMode3;
                        }
                case EGray256:
                        {
                        return KDisplayMode4;
                        }
                case EColor16:
                        {
                        return KDisplayMode5;
                        }
                case EColor256:
                        {
                        return KDisplayMode6;
                        }
                case EColor64K:
                        {
                        return KDisplayMode7;
                        }
                case EColor16M:
                        {
                        return KDisplayMode8;
                        }
                case ERgb:
                        {
                        return KDisplayMode9;
                        }
                case EColor4K:
                        {
                        return KDisplayMode10;
                        }
                case EColor16MU:
                        {
                        return KDisplayMode11;
                        }
                case EColor16MA:
                        {
                        return KDisplayMode12;
                        }
                case EColor16MAP:
                        {
                        return KDisplayMode13;
                        }
                //Place holder for additional modes
                case EColorLast:                
                        {
                        return KDisplayMode14;
                        }
                default:
                        return KNullDesC;
                }
        }
        
const TDesC& CDeviceCapabilitiesScan::Orientation(CFbsBitGc::TGraphicsOrientation aOrientation)
        {
        switch (aOrientation)
                {
                case CFbsBitGc::EGraphicsOrientationNormal:
                        {
                        return KOrientation0;                   
                        }                       
                case CFbsBitGc::EGraphicsOrientationRotated90:
                        {
                        return KOrientation1;                   
                        }                       
                case CFbsBitGc::EGraphicsOrientationRotated180:
                        {
                        return KOrientation2;                   
                        }                       
                case CFbsBitGc::EGraphicsOrientationRotated270:
                        {
                        return KOrientation3;                   
                        }                       
                default:
                        return KNullDesC;
                }               
        }

/* Check if touch or pen support is provided */
void CDeviceCapabilitiesScan::CheckForTouchSupportL()
        {
        _LIT(KTxtTouchSupported, "\nTouch supported\n");
        _LIT(KTxtTouchNotSupported, "\nTouch not supported\n");
        
        if (AknLayoutUtils::PenEnabled())
                {
                iLogView->LogEntryL(KTxtTouchSupported);
                }
        else
                {
                iLogView->LogEntryL(KTxtTouchNotSupported);
                }
        }

/* Discover available input modes */
void CDeviceCapabilitiesScan::DiscoverAvailableInputModesL()
        {
        _LIT(KTxtInputCapabilities, "Input Capabilities");
        
        iLogView->LogSectionTitleL(KTxtInputCapabilities);
        iState = EDiscoveringInputCapabilities; 
        
        // Display available modes for a particular language 
        EnumerateAvailableInputModesL();
        
        // Check for touch support
        CheckForTouchSupportL();
        }

/* Enumerate available input modes */
void CDeviceCapabilitiesScan::EnumerateAvailableInputModesL()
        {
        _LIT(KInputMode, "Input mode %d");
        CPtiEngine* ptiEngine = CPtiEngine::NewL();
        CleanupStack::PushL(ptiEngine);
        
        CPtiCoreLanguage* currentLanguage = static_cast<CPtiCoreLanguage*>(ptiEngine->GetLanguage(User::Language()));
        if (currentLanguage)
                {
                RArray<TInt> modes;
                CleanupClosePushL(modes);
                currentLanguage->GetAvailableInputModesL(modes);
                
                for (TInt count=0; count < modes.Count(); count++)
                        {
                        iLogView->LogEntryL(KInputMode, modes[count]);                  
                        }

                CleanupStack::PopAndDestroy(&modes);
                }

        CleanupStack::PopAndDestroy(ptiEngine); 
        }

/* Discover and log multimedia plugin support */        
void CDeviceCapabilitiesScan::DiscoverMultimediaPluginSupportL()
        {
        _LIT(KTxtMultimediaTitle, "\nMultimedia support\n");
        _LIT(KTxtMultimediaInterfaceUid, "interface uid: 0x%08x");
        _LIT(KTxtMultimediaFailure, "Failed to list implementations: err %d");
        _LIT(KTxtMultimediaPluginDetails, "ECOM plugin: 0x%08x %S;");
        
        iState = EDiscoveringMultimediaEcomPlugins;
        iLogView->LogSectionTitleL(KTxtMultimediaTitle);
        
        RImplInfoPtrArray impls;
        CleanupResetAndDestroyPushL(impls);

        for(TInt ui=0;ui!=sizeof(interfaceUids)/sizeof(interfaceUids[0]);++ui)
                {
                iLogView->LogEntryL(KTxtMultimediaInterfaceUid,interfaceUids[ui]);
                
                impls.ResetAndDestroy();
                TRAPD(leaveCode,REComSession::ListImplementationsL(TUid::Uid(interfaceUids[ui]),impls));
                if(leaveCode!=KErrNone)
                        {
                        iLogView->LogEntryL(KTxtMultimediaFailure, leaveCode);
                        }
                else for(TInt i=0,count=impls.Count();i!=count;++i)
                        {
                        CImplementationInformation* info = impls[i];
                        iLogView->LogEntryL(KTxtMultimediaPluginDetails, info->ImplementationUid().iUid,&info->DisplayName());
                        }
                }
        CleanupStack::PopAndDestroy(&impls);    
        }

void CDeviceCapabilitiesScan::DiscoverAvailableSensorsL()
        {
        _LIT(KTxtSensorTitle, "Sensor information");
        _LIT(KTxtChannelCount, "Channel count: %d");
        _LIT(KTxtChannelsAvailable, "Available channels");      
        
        iState = EDiscoveringAvailableSensors;
        iLogView->LogSectionTitleL(KTxtSensorTitle);
        
        CSensrvChannelFinder* SensrvChannelFinder = CSensrvChannelFinder::NewLC(); 
        RSensrvChannelInfoList ChannelInfoList;
        CleanupClosePushL( ChannelInfoList );
                        
        TSensrvChannelInfo mySearchConditions; // none, so matches all.
        SensrvChannelFinder->FindChannelsL(ChannelInfoList,mySearchConditions);

        iLogView->LogEntryL(KTxtChannelCount, ChannelInfoList.Count());
        iLogView->LogEntryL(KTxtChannelsAvailable);

        for (TInt i = 0; i < ChannelInfoList.Count() ; i++)
                {
                TSensrvChannelInfo channelInfo = ChannelInfoList[i];
                switch (channelInfo.iChannelType)
                        {
                        /* Note that the S60 5th SDK v1.0 declares the double-tapping
                        * channel id but doesn't define the associated class for data.
                        */
                        case KSensrvChannelTypeIdAccelerometerDoubleTappingData:
                                {
                                iLogView->LogEntryL(KTxtChannelDoubleTapping);
                                break;  
                                }
                        /* Note that the S60 5th SDK v1.0 declares the class for tapping
                        * data but doesn't declare the associated channel id, so we resort
                        * to using the data type id here (it's fortunately the same).
                        */
                        case TSensrvTappingData::KDataTypeId:
                                {
                                iLogView->LogEntryL(KTxtChannelTapping);
                                break;  
                                }
                        case KSensrvChannelTypeIdProximityMonitor:
                                {
                                iLogView->LogEntryL(KTxtChannelProximity);
                                break;  
                                }
                        case KSensrvChannelTypeIdOrientationData:
                                {
                                iLogView->LogEntryL(KTxtChannelOrientation);
                                break;  
                                }
                        case KSensrvChannelTypeIdRotationData:
                                {
                                iLogView->LogEntryL(KTxtChannelRotation);
                                break;  
                                }
                        case KSensrvChannelTypeIdMagnetometerXYZAxisData:
                                {
                                iLogView->LogEntryL(KTxtChannelMagnetometer);
                                break;  
                                }
                        case KSensrvChannelTypeIdMagneticNorthData:
                                {
                                iLogView->LogEntryL(KTxtChannelMagneticNorth);
                                break;  
                                }
                        case KSensrvChannelTypeIdAmbientLightData:
                                {
                                iLogView->LogEntryL(KTxtChannelAmbientLight);
                                break;  
                                }
                        case KSensrvChannelTypeIdAccelerometerXYZAxisData:              
                                {
                                iLogView->LogEntryL(KTxtChannelAccelerometer);
                                break;  
                                }
                        default:
                                {
                                iLogView->LogEntryL(KTxtChannelUnknown);
                                break;  
                                }
                        }
                }
                
        CleanupStack::PopAndDestroy( 2, SensrvChannelFinder ); // ChannelnfoList and SensrvChannelFinder
        }

// End of file

---