/*
* 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