/*
* Copyright (c) 2007 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:  Handler for camera, keypad and video player resources
*
*/



#include "musuiresourcehandler.h"
#include "musuipropertywatch.h"
#include "musuieventobserver.h"
#include "musuidialogutil.h"
#include "muslogger.h"
#include "mussettings.inl"

#include <musui.rsg>
#include <AknWaitDialog.h>
#include <StringLoader.h>

using namespace NMusResourceApi;


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiResourceHandler::~CMusUiResourceHandler()
    {    
    delete iCameraResourceWatch;
    delete iKeypadResourceWatch;
    
    delete iChangeProductModeDialog;
    delete iDialogPrompt;
    }
    
    
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiResourceHandler* CMusUiResourceHandler::NewL( 
                                            MMusUiEventObserver& aObserver )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiResourceHandler::NewL()" )
    
    CMusUiResourceHandler* self = 
                            new ( ELeave ) CMusUiResourceHandler( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    MUS_LOG( "mus: [MUSUI ] <- CMusUiResourceHandler::NewL()" )
    return self;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMusUiResourceHandler::RequestKeypadL( TBool aMandatory )
    {
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiResourceHandler::RequestKeypadL" )
    
    TBool keypadAvailable( EFalse ); 
    
    switch ( iKeypadAvailability )
        {        
        case NMusResourceApi::EAvailable:
            {
            MUS_LOG( "mus: [MUSUI ]     Keypad is available" )            
		    break;		            
            }			         
        case NMusResourceApi::ENotAvailable:
            {
            MUS_LOG( "mus: [MUSUI ]     Keypad is not available, changing mode" )
            iKeypadAvailibilityInProgress = ETrue;
            delete iDialogPrompt;
            iDialogPrompt = NULL;
            iDialogPrompt = StringLoader::LoadL( R_MUS_CHANGE_KEYPAD_MODE_TXT );
            ShowChangeProductModeDialogL( *iDialogPrompt );            
            MUS_LOG( "                 Product mode changed" )
            MUS_LOG1( "                 Keypad availability is %d", 
                      iKeypadAvailability )            
            break;
            }
        default:
            {
            MUS_LOG( "mus: [MUSUI ]     availability default." )
            break;
            }
            
        }
        
    switch(iKeypadUsability)
    	{
    	case MusSettingsKeys::EUsabilityLandscape:
            {
            MUS_LOG( "mus: [MUSUI ]     Keypad is usable in landscape" )
            iObserver.SwitchOrientationL( 
                                    CAknAppUiBase::EAppUiOrientationLandscape );            
            break;
            }
        case MusSettingsKeys::EUsabilityPortrait:
            {
            MUS_LOG( "mus: [MUSUI ]     Keypad is usable in portrait" )
            iObserver.SwitchOrientationL( 
                                    CAknAppUiBase::EAppUiOrientationPortrait );            
            break;
            }	
    	case MusSettingsKeys::EUsabilityAlways:
    		{
    		MUS_LOG( "mus: [MUSUI ]     Keypad is usable in all mode" )
    		keypadAvailable = ETrue;	
    		}
    		break;
    	default:
    	  	MUS_LOG( "mus: [MUSUI ]     usuability default ." )
    	  	break;
    	}
    	
    keypadAvailable = IsCurrentlyAvailable( iKeypadAvailability,
		                                    iKeypadUsability );
            
    if ( aMandatory && !keypadAvailable )
        {
        MUS_LOG( "mus: [MUSUI ]     Mandatory keypad not available, exiting" )
        MusUiDialogUtil::ShowGlobalInformationDialogL( 
                                R_MUS_LIVE_SHARING_VIEW_NOTE_SHARING_ENDED );
        iObserver.HandleExit();
        }
    
    MUS_LOG1( "mus: [MUSUI ]  <- CMusUiResourceHandler::RequestKeypadL( %d )",
              keypadAvailable )
    
    return keypadAvailable;
    
    
    }
    
    
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMusUiResourceHandler::RequestCameraL( TBool aMandatory )
    {
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiResourceHandler::RequestCameraL" )
    
    TBool cameraAvailable( EFalse );
    
    switch ( iCameraAvailability )
        {        
        case NMusResourceApi::EAvailable:
            {
            MUS_LOG( "mus: [MUSUI ]     Camera is available" )            
            cameraAvailable = ETrue;
            break;
            }
        
        case NMusResourceApi::ENotAvailable:
            {
            MUS_LOG( "mus: [MUSUI ]     Camera is not available, changing mode" )

            iCameraAvailibilityInProgress = ETrue;
            delete iDialogPrompt;
            iDialogPrompt = NULL;
            iDialogPrompt = StringLoader::LoadL(
                R_MUS_LIVE_SHARING_VIEW_OPEN_CAMERA_LENS_COVER_WAIT_NOTE_TXT );
            ShowChangeProductModeDialogL( *iDialogPrompt );
            
            MUS_LOG( "                 Product mode changed" )
            MUS_LOG1( "                 Camera availability is %d", 
                      iCameraAvailability )                                  
            break;
            }
        default:
        	MUS_LOG( "mus: [MUSUI ]     availability default." )
            break;
        }
        
    switch(iCameraUsability)
    	{
    	case MusSettingsKeys::EUsabilityLandscape:
            {
            MUS_LOG( "mus: [MUSUI ]     Camera is usable in landscape" )
            iObserver.SwitchOrientationL( 
                                CAknAppUiBase::EAppUiOrientationLandscape );            
            break;
            }
        case MusSettingsKeys::EUsabilityPortrait:
            {
            MUS_LOG( "mus: [MUSUI ]     Camera is usable in portrait" )
            iObserver.SwitchOrientationL( 
                                CAknAppUiBase::EAppUiOrientationPortrait );           
            break;
            }	
        case MusSettingsKeys::EUsabilityAlways:
    		{
    		MUS_LOG( "mus: [MUSUI ]     camera is usable in all mode" )
    		cameraAvailable = ETrue;	
    		}
    	default:
            {
            MUS_LOG( "mus: [MUSUI ]     usuability default." )
            break;
            }
    	}
    
    cameraAvailable = IsCurrentlyAvailable( iCameraAvailability,
		                                    iCameraUsability );
    if ( aMandatory && !cameraAvailable )
        {
        MUS_LOG( "mus: [MUSUI ]     Mandatory camera not available, exiting" )
        MusUiDialogUtil::ShowGlobalInformationDialogL( 
                                R_MUS_LIVE_SHARING_VIEW_NOTE_SHARING_ENDED ); 
        iObserver.HandleExit();        
        }
    
    MUS_LOG1( "mus: [MUSUI ]  <- CMusUiResourceHandler::RequestCameraL( %d )",
              cameraAvailable )
        
    return cameraAvailable;
    }
 

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMusUiResourceHandler::RequestVideoPlayerL( TBool aMandatory )
    { 
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiResourceHandler::RequestVideoPlayerL" )
    
    TBool videoPlayerAvailable( EFalse );
    
    /* Video Player will be always available. There is no dynamic variation */
    NMusResourceApi::TAvailability vpAvailability = NMusResourceApi::EAvailable;
    
    switch ( iVideoplayerUsability )
        {       
        case MusSettingsKeys::EUsabilityAlways:
            {
            MUS_LOG( "mus: [MUSUI ]     Video player is usuable in all mode" )            
            videoPlayerAvailable = ETrue;
            break;
            }
        case MusSettingsKeys::EUsabilityLandscape:
            {
            MUS_LOG( "mus: [MUSUI ]     Video player is usable in landscape" )

            iObserver.SwitchOrientationL( 
                                    CAknAppUiBase::EAppUiOrientationLandscape );
            videoPlayerAvailable = IsCurrentlyAvailable( vpAvailability,
                                                         iVideoplayerUsability );
            break;
            }
        case MusSettingsKeys::EUsabilityPortrait:
            {
            MUS_LOG( "mus: [MUSUI ]     Video player is usable in portrait" )

            iObserver.SwitchOrientationL( 
                                    CAknAppUiBase::EAppUiOrientationPortrait );
            videoPlayerAvailable = IsCurrentlyAvailable( vpAvailability,
                                                         iVideoplayerUsability );
            break;
            }        
        default:
            {
            MUS_LOG( "mus: [MUSUI ]     usuability default." )
            break;
            }
        }
    
    if ( aMandatory && !videoPlayerAvailable )
        {
        MUS_LOG( "mus: [MUSUI ]     Mandatory player not available, exiting" )
        MusUiDialogUtil::ShowGlobalInformationDialogL( 
                                R_MUS_LIVE_SHARING_VIEW_NOTE_SHARING_ENDED );
        iObserver.HandleExit();
        }
        
    MUS_LOG1( "mus: [MUSUI ]  <- CMusUiResourceHandler::RequestVideoPlayerL(%d)",
              videoPlayerAvailable )
    
    return videoPlayerAvailable;
    }


// -----------------------------------------------------------------------------
// Called by CMusUiPropertyWatch, when resource key values change in P&S
// -----------------------------------------------------------------------------
//
void CMusUiResourceHandler::PropertyChanged( const TUint aKey,
                                             const TInt aValue )
    {
    
    MUS_LOG2( "mus: [MUSUI ] -> CMusUiResourceHandler::ResourcePropertyChanged:\
              aKey: [%u] aValue: [%d]", aKey, aValue )
              
    switch( aKey )
        {
        case NMusResourceApi::KCameraAvailability:
            {
            MUS_LOG( "mus: [MUSUI ]  KCameraAvailability   " )            
            iCameraAvailability = static_cast< TAvailability >( aValue );
            if ( iCameraAvailibilityInProgress && iChangeProductModeDialog )
                {
                TRAP_IGNORE( iChangeProductModeDialog->ProcessFinishedL() );
                }
            iCameraAvailibilityInProgress = EFalse;
            break;
            }
        case NMusResourceApi::KKeypadAvailability:
            {
            MUS_LOG( "mus: [MUSUI ]  KKeypadAvailability   " )            
            iKeypadAvailability = static_cast< TAvailability >( aValue );
            if ( iKeypadAvailibilityInProgress && iChangeProductModeDialog )
                {
                TRAP_IGNORE( iChangeProductModeDialog->ProcessFinishedL() );
                }
            iKeypadAvailibilityInProgress = EFalse;
            break;
            }       
        default:
            {
            MUS_LOG( "mus: [MUSUI ]     avilability property watch default." )
            break;
            }
            
        }
        
    MUS_LOG( "mus: [MUSUI ]  <- CMusUiResourceHandler::ResourcePropertyChanged" )
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiResourceHandler::HandlePropertyError( const TInt aReason )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiResourceHandler::HandlePropertyError()" )

    iObserver.HandleError( aReason );
    }


// -----------------------------------------------------------------------------
// C++ constructor
// -----------------------------------------------------------------------------
//
CMusUiResourceHandler::CMusUiResourceHandler( MMusUiEventObserver& aObserver )
    :iObserver( aObserver ),
     iCameraAvailability(NMusResourceApi::EAvailable),
     iKeypadAvailability(NMusResourceApi::EAvailable),
     iCameraUsability(MusSettingsKeys::EUsabilityAlways),
     iKeypadUsability(MusSettingsKeys::EUsabilityAlways),
     iVideoplayerUsability(MusSettingsKeys::EUsabilityAlways)
    {
    }


// -----------------------------------------------------------------------------
// Symbian second phase constructor
// -----------------------------------------------------------------------------
//
void CMusUiResourceHandler::ConstructL()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiResourceHandler::ConstructL()" )
    
	iCameraAvailibilityInProgress = EFalse;
    iKeypadAvailibilityInProgress = EFalse;     
             
    // Read the value from cenrep and check whether camera,keypad
    // and videoplayer usability.
    MultimediaSharingSettings::ResourceUsability( iCameraUsability ,
    											  iKeypadUsability,
    											  iVideoplayerUsability);
        
    // Read the value from cenrep and check whether camera and keypad
    // available dynamically.
    MusSettingsKeys::TAvailability camera,keypad;    
    MultimediaSharingSettings::ResourceAvailability( camera ,
    												 keypad);
    
    TInt err = KErrNone;
    
    // Set Camera availability     
    if(camera == MusSettingsKeys::EAvailabilityDynamic)    												 
    	{
    	// read the PS key intial value
    	err = RProperty::Get(
                            NMusResourceApi::KCategoryUid,
                            NMusResourceApi::KCameraAvailability,
                            (TInt&)iCameraAvailability );
        if(err) 
        	{
        	MUS_LOG1( "mus: [MUSUI ] Error = %d",err )
        	iCameraAvailability = NMusResourceApi::ENotAvailable;
        	}
        // watch the camera ps key for further change
    	iCameraResourceWatch = CMusUiPropertyWatch::NewL(
                            *this,
                            NMusResourceApi::KCategoryUid,
                            KCameraAvailability ); 
    	}
    else
    	{
    	iCameraAvailability = NMusResourceApi::EAvailable;	
    	}
    	
    // Set Keypad availability    
     if(keypad == MusSettingsKeys::EAvailabilityDynamic)    												 
    	{
    	// read the PS key intial value
    	err = RProperty::Get(
                            NMusResourceApi::KCategoryUid,
                            NMusResourceApi::KKeypadAvailability,
                            (TInt&)iKeypadAvailability ); 
        if(err) 
        	{
        	MUS_LOG1( "mus: [MUSUI ] Error = %d",err )
        	iKeypadAvailability = NMusResourceApi::ENotAvailable;
        	}
    	// watch the keypad ps key
    	iKeypadResourceWatch = CMusUiPropertyWatch::NewL(
                            		*this,
                            		NMusResourceApi::KCategoryUid,
                            		KKeypadAvailability );        
    	}
    else
    	{
    	iKeypadAvailability = NMusResourceApi::EAvailable;	
    	}
    
    // Videoplayer availability always static
     
    MUS_LOG( "mus: [MUSUI ] <- CMusUiResourceHandler::ConstructL()" )
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMusUiResourceHandler::ShowChangeProductModeDialogL( 
                                                        const TDesC& aPrompt )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiResourceHandler::ShowChangeProductModeDialogL()" )
    
    TBool returnValue = EFalse;

    if ( !iChangeProductModeDialog )
        {    
        iChangeProductModeDialog = new ( ELeave ) CAknWaitDialog( (
                reinterpret_cast<CEikDialog**>( &iChangeProductModeDialog )  ), 
                ETrue );
                    
        iChangeProductModeDialog->SetTextL( aPrompt );
        
        iChangeProductModeDialog->PrepareLC( 
                        R_MUS_LIVE_SHARING_VIEW_ACTIVATE_CAMERA_WAIT_NOTE );
        returnValue = iChangeProductModeDialog->RunLD();
        
        iChangeProductModeDialog = NULL;
        }
    
    MUS_LOG( "mus: [MUSUI ] <- CMusUiResourceHandler::ShowChangeProductModeDialogL()" )
    
    return returnValue;
    }
    

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMusUiResourceHandler::IsCurrentlyAvailable( 
                        NMusResourceApi::TAvailability aResourceAvailability,
                        MusSettingsKeys::TUsability aResourceUsability
                         )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiResourceHandler::IsCurrentlyAvailable()" )

    CAknAppUiBase::TAppUiOrientation orientation = iObserver.AppOrientation();
    
    MUS_LOG( "mus: [MUSUI ] <- CMusUiResourceHandler::IsCurrentlyAvailable()" )
    
    return ( aResourceAvailability == NMusResourceApi::EAvailable && 
             (
              aResourceUsability == MusSettingsKeys::EUsabilityAlways ||
              (aResourceUsability == MusSettingsKeys::EUsabilityLandscape && 
               orientation == CAknAppUiBase::EAppUiOrientationLandscape) ||
              (aResourceUsability == MusSettingsKeys::EUsabilityPortrait &&
               orientation == CAknAppUiBase::EAppUiOrientationPortrait)
             )
            );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiResourceHandler::CheckInitialOrientationL(MultimediaSharing::TMusUseCase aUsecase )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiResourceHandler::CheckInitialOrientationL()" )
    if ( aUsecase != MultimediaSharing::EMusLiveVideo &&
         aUsecase != MultimediaSharing::EMusClipVideo &&
         aUsecase != MultimediaSharing::EMusReceive )
        {
        return;   
        }
    
    MusSettingsKeys::TUsability usability = ( aUsecase == MultimediaSharing::EMusLiveVideo ) ?
        iCameraUsability : iVideoplayerUsability;
    if ( usability == MusSettingsKeys::EUsabilityPortrait )
        {
        iObserver.SwitchOrientationL( CAknAppUiBase::EAppUiOrientationPortrait );
        }
    else if ( usability == MusSettingsKeys::EUsabilityLandscape )
        {
        iObserver.SwitchOrientationL( CAknAppUiBase::EAppUiOrientationLandscape );
        }
    MUS_LOG( "mus: [MUSUI ] <- CMusUiResourceHandler::CheckInitialOrientationL()" )
    }





















