tsrc/CenrepEditor/Src/cenrepeditormodel.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Tue, 31 Aug 2010 15:12:07 +0300
branchRCL_3
changeset 22 73a1feb507fb
parent 0 f0cf47e981f9
child 23 bc78a40cd63c
permissions -rw-r--r--
Revision: 201032 Kit: 201035

/*
* Copyright (c) 2002-2005 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:  
*
*/


// INCLUDE FILES
#include "cenrepeditormodel.h"
#include "musresourceproperties.h"
#include "mussettingskeys.h"
#include <cenrepeditor.rsg>
#include <e32property.h>
#include <aknnotewrappers.h>
#ifdef _KODIAK_PHONE_CALL
#include <CTSYDomainPSKeys.h>
#else
const TUid KPSUidCtsyCallInformation = {0x102029AC};
const TUint32 KCTsyKodiakPtt = 0x00000003;    
enum TPSCTsyKodiakPtt
    {
    EPSCTsyKodiakPttNotActive,
    EPSCTsyKodiakPttActive
    };
#endif


// ================= MEMBER FUNCTIONS =======================

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

CPhoneResources* CPhoneResources::NewL()
    {
    CPhoneResources* self = CPhoneResources::NewLC();
    CleanupStack::Pop();
    return self;
    }

CPhoneResources::~CPhoneResources()
    {
    }

void CPhoneResources::ConstructL()
	{
    // If a P&S key is not found, set it to KErrNotFound.
	// This is why the RProperty::Get return values are not handled below.
	iCameraAvailability = KErrNotFound;
    RProperty::Get(NMusResourceApi::KCategoryUid, 
                   NMusResourceApi::KCameraAvailability, 
                   iCameraAvailability);

    iKeypadAvailability = KErrNotFound;
    RProperty::Get(NMusResourceApi::KCategoryUid, 
                   NMusResourceApi::KKeypadAvailability, 
                   iKeypadAvailability);

    iVideoPlayerAvailability = KErrNotFound;  
    RProperty::Get(NMusResourceApi::KCategoryUid, 
                   NMusResourceApi::KVideoPlayerAvailability, 
                   iVideoPlayerAvailability );

    iCameraInformation = KErrNotFound;    
    RProperty::Get(NMusResourceApi::KCategoryUid, 
                   NMusResourceApi::KCameraInformation, 
                   iCameraInformation );   
    
    iKodiakPhoneCall = KErrNotFound;
    TInt err = RProperty::Get(KPSUidCtsyCallInformation, 
                              KCTsyKodiakPtt, 
                              iKodiakPhoneCall );
    if (err != KErrNone)
        {  
        iKodiakPhoneCall = EPSCTsyKodiakPttNotActive;        
        RProperty::Define(KPSUidCtsyCallInformation,KCTsyKodiakPtt,EPSCTsyKodiakPttNotActive);
        }
	}

void CPhoneResources::SaveL()
    {
    SetValueL(NMusResourceApi::KCategoryUid, 
              NMusResourceApi::KCameraAvailability, 
              iCameraAvailability);

    SetValueL(NMusResourceApi::KCategoryUid, 
              NMusResourceApi::KKeypadAvailability, 
              iKeypadAvailability);

    SetValueL(NMusResourceApi::KCategoryUid, 
              NMusResourceApi::KVideoPlayerAvailability, 
              iVideoPlayerAvailability);

    SetValueL(NMusResourceApi::KCategoryUid, 
              NMusResourceApi::KCameraInformation, 
              iCameraInformation);

    SetValueL(KPSUidCtsyCallInformation, 
              KCTsyKodiakPtt, 
              iKodiakPhoneCall);                
    }

void CPhoneResources::SetValueL(TUid aCategory, TUint aKey, TInt aValue)
    {
    // Don't care if the key is not found initially
    if (aValue >= 0)
        {
        User::LeaveIfError(RProperty::Set(aCategory, aKey, aValue));
        }
    }

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

COtherResources* COtherResources::NewL()
    {
    COtherResources* self = COtherResources::NewLC();
    CleanupStack::Pop();
    return self;
    }

void COtherResources::ConstructL()
    {
    iRepository = CRepository::NewL(MusSettingsKeys::KRepositoryUid);
    
    // If a CenRep key is not found, set it to KErrNotFound.
    // This is why the CRepository::Get return values are not handled below.
    iActivation = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KActivation, iActivation);
    
    iOperatorVariant = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KOperatorVariant,iOperatorVariant);
    
    iAuditoryNotification = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KAuditoryNotification, iAuditoryNotification);
    
    iPopupNotification = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KPopupNotification, iPopupNotification);
    
    iPopupNotificationType = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KPopupNotificationType, iPopupNotificationType);
    
    iEdgeDtmSupport = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KEdgeDtmSupport, iEdgeDtmSupport);
    
    iSessionSetupMethod = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KForceInternetSignaling, iSessionSetupMethod);
    
    iAutoRecord = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KAutoRecord, iAutoRecord);
    
    iVideoLocation = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KVideoLocation, iVideoLocation);
    
    iSipProfileId = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KSipProfileId, iSipProfileId);
    
    iUiOrientation = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KUiOrientation, iUiOrientation);
    
    iCapabilityQuery = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KCapabilityQuery, iCapabilityQuery);
    
    iProductModeVariation = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KProductModeVariation, iProductModeVariation);    
    
    iRepository->Get(MusSettingsKeys::KEncoderConfigurationInfo, iEncoderInfo );
    
    iEncodingDevice = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KEncodingDevice, iEncodingDevice );
    iEncodingDeviceStr.Zero();
    if ( iEncodingDevice >= 0 )
        {
        iEncodingDeviceStr.AppendNum(iEncodingDevice, EHex); 
        }
    
    iOnlyWithActiveCSCall = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KAllowOnlyWithActiveCSCall, iOnlyWithActiveCSCall);
    
    iOnlyIn3GNetwork = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KAllowOnlyIn3GNetwork, iOnlyIn3GNetwork); 
    
    iCameraUsage = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KCameraUsage, iCameraUsage); 
    
    iVideoDirection = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KVideoDirection, iVideoDirection);
    
    iVideoBandwidth = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KVideoBandwidth, iVideoBandwidth);
    
    iFastMode = KErrNotFound;
    iRepository->Get(MusSettingsKeys::KFastStartupMode, iFastMode);
    }

COtherResources::~COtherResources()
    {
    delete iRepository;
    }

void COtherResources::SaveL()
    {
    User::LeaveIfError(
        iRepository->StartTransaction(CRepository::EConcurrentReadWriteTransaction));    
    iRepository->CleanupCancelTransactionPushL();
    
    SetKeyValueL(MusSettingsKeys::KActivation, iActivation);
 	SetKeyValueL(MusSettingsKeys::KOperatorVariant, iOperatorVariant);
 	SetKeyValueL(MusSettingsKeys::KAuditoryNotification, iAuditoryNotification);
	SetKeyValueL(MusSettingsKeys::KPopupNotification, iPopupNotification);
	SetKeyValueL(MusSettingsKeys::KPopupNotificationType, iPopupNotificationType);
	SetKeyValueL(MusSettingsKeys::KEdgeDtmSupport, iEdgeDtmSupport);
	SetKeyValueL(MusSettingsKeys::KForceInternetSignaling, iSessionSetupMethod);
	SetKeyValueL(MusSettingsKeys::KAutoRecord, iAutoRecord);
	SetKeyValueL(MusSettingsKeys::KVideoLocation, iVideoLocation);
	SetKeyValueL(MusSettingsKeys::KSipProfileId, iSipProfileId);
	SetKeyValueL(MusSettingsKeys::KUiOrientation, iUiOrientation);    
	SetKeyValueL(MusSettingsKeys::KCapabilityQuery, iCapabilityQuery);    
    SetKeyValueL(MusSettingsKeys::KProductModeVariation, iProductModeVariation);    
    User::LeaveIfError( 
        iRepository->Set(MusSettingsKeys::KEncoderConfigurationInfo, iEncoderInfo));
    TLex lex( iEncodingDeviceStr );
    TUint tmpUid;
    lex.SkipSpace();
    if ( lex.Val(tmpUid, EHex) == KErrNone )
        {
        iEncodingDevice = tmpUid;     
        }
    else
        {
        iEncodingDevice = KErrNotFound;
        }
    SetKeyValueL(MusSettingsKeys::KEncodingDevice, iEncodingDevice);     
    SetKeyValueL(MusSettingsKeys::KAllowOnlyWithActiveCSCall, iOnlyWithActiveCSCall);
    SetKeyValueL(MusSettingsKeys::KAllowOnlyIn3GNetwork, iOnlyIn3GNetwork);
    SetKeyValueL(MusSettingsKeys::KCameraUsage, iCameraUsage);
    SetKeyValueL(MusSettingsKeys::KVideoDirection, iVideoDirection);
    SetKeyValueL(MusSettingsKeys::KVideoBandwidth, iVideoBandwidth);
    SetKeyValueL(MusSettingsKeys::KFastStartupMode, iFastMode);
    
    TUint32 modifiedKeyCount(0);
    User::LeaveIfError(iRepository->CommitTransaction(modifiedKeyCount));
    CleanupStack::Pop(); // transaction
    }

void COtherResources::SetKeyValueL(
    const TUint32& aKey, 
    TInt& aVal)
    {     
    TBool keyExistsInRepository(EFalse);
    TInt tmpVal(0);
    keyExistsInRepository = (iRepository->Get(aKey,tmpVal) == KErrNone);
    if (aVal < 0)
        {
        if (keyExistsInRepository)
            {
            User::LeaveIfError(iRepository->Delete(aKey));
            }
        }
    else
        {
        if (keyExistsInRepository)
            {
            User::LeaveIfError(iRepository->Set(aKey,aVal));
            }
        else
            {
            User::LeaveIfError(iRepository->Create(aKey,aVal));
            }
        }    
    }

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

CMusApplication* CMusApplication::NewL()
    {
    CMusApplication* self = CMusApplication::NewLC();
    CleanupStack::Pop();
    return self;
    }

void CMusApplication::ConstructL()
    {
    iUseCase = MultimediaSharing::EMusLiveVideo;     
    iMultimediasharing=CMusManager::NewL();    
    iMultimediasharing->ExamineAvailabilityL();
    }

CMusApplication::~CMusApplication()
	{
    delete iMultimediasharing;
    iMultimediasharing=NULL;
	}

void CMusApplication::HandleError(TInt aError , TPtrC aVal )
    {
    CAknErrorNote *dlg = new CAknErrorNote(ETrue);
    TBuf<100> buf;        
    buf.Append(aVal);
    buf.Append(_L(" Error "));
    buf.AppendNum(aError);
    dlg->ExecuteLD(buf); 
    }

TBool CMusApplication::Start(TInt aUseCase)
    {
    TRAPD(err,iMultimediasharing->StartApplicationL(
                            MultimediaSharing::TMusUseCase(aUseCase)));
    if(err)HandleError(err,_L("MusStart "));    
    return (err)?EFalse :ETrue;        
    }
     
TBool CMusApplication::Stop()
    {
    TRAPD(err,iMultimediasharing->StopApplicationL());
    if(err)HandleError(err,_L("MusStop "));
    return (err)?EFalse :ETrue;    
    }

TInt CMusApplication::Availability()
    {
    TInt status=-1;
    TRAPD(err,status=iMultimediasharing->AvailabilityL());
    if(err)HandleError(err,_L("MusAvailability "));
    return status;    
    }
TInt CMusApplication::MonitorAvailability()
    {
    return KErrGeneral;        
    }

TBool CMusApplication::AvailabilityInfo()
    {                                   
    TBuf<100> buf(_L("Availability Info: ")); 
    TBool available = EFalse ;
    switch(Availability())
        {
            case MultimediaSharing::ESipRegistrationPending:
                 buf.Append(_L("SipRegistrationPending "));
                 break;

            case MultimediaSharing::ESipOptionsSent:
                 buf.Append(_L("SipOptionsSent "));
                 available = ETrue ;
                 break;

            case MultimediaSharing::ESipOptionsNotCapable:
                 buf.Append(_L("SipOptionsNotCapable "));
                 available = ETrue ;
                 break;

            case MultimediaSharing::ESipOptionsNotSent:
                 buf.Append(_L("SipOptionsNotSent "));
                 available = ETrue ;
                 break;

            case MultimediaSharing::EErrSipRegistration:
                 buf.Append(_L("ErrSipRegistration "));
                 break;

            case MultimediaSharing::EErrNoActiveCall:
                 buf.Append(_L("ErrNoActiveCall "));
                 break;

            case MultimediaSharing::EErrCallOnHold:
                 buf.Append(_L("ErrCallOnHold "));
                 break;

            case MultimediaSharing::EErrConferenceCall:
                 buf.Append(_L("ErrConferenceCall "));
                 break;

            case MultimediaSharing::EErrRoaming:
                 buf.Append(_L("ErrRoaming "));
                 break;

            case MultimediaSharing::EErrNetwork:
                 buf.Append(_L("ErrNetwork "));
                 break;

            default:
                 buf.Append(_L("Error Occured "));
                 break;

        }     
    CAknErrorNote *dlg = new CAknErrorNote(ETrue);    
    dlg->ExecuteLD(buf);     
    return available;
    }

void CMusApplication::MusUseCaseInfo(TBool aStart)
    {
    CAknErrorNote *dlg = new CAknErrorNote(ETrue);                                   
    TBuf<50> buf;  
    switch (iUseCase)
        {
            case MultimediaSharing::EMusLiveVideo:                    
            buf.Append(_L("MusLiveVideo "));
            break;
            case MultimediaSharing::EMusClipVideo:
            buf.Append(_L("MusClipVideo "));
            break;                     
            case MultimediaSharing::EMusStillImage:
            buf.Append(_L("MusStillImage "));
            break;
            case MultimediaSharing::EMusReceive:
            buf.Append(_L("MusReceive "));
            break;
            case MultimediaSharing::EMusContinue:
            buf.Append(_L("MusContinue "));
            break;
            default :
            buf.Append(_L("Unknown Usecase "));
            break;
        }          
    (aStart) ? buf.Append(_L("Started")) : buf.Append(_L("Stoped"));
    dlg->ExecuteLD(buf);      
    }

// End of File