1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 * 

    14 * Description: Wrapper for equalizer framework - private implementation.

    15 *

    16 */

    17 

    18 // System includes

    19 #include <QDebug>

    20 #include <QStringList>

    21 #include <hbglobal.h>

    22 #include <AudioEqualizerUtility.h>

    23 #include <EqualizerConstants.h>

    24 #include <mpxuser.h>

    25 

    26 // User includes

    27 #include "mpequalizerframeworkwrapper.h"

    28 #include "mpequalizerframeworkwrapper_p.h"

    29 #include "mptrace.h"

    30 

    31 // CONSTANTS

    32 _LIT( KMPXNullSoundPath, "\\nullsound.mp3" );

    33 

    34 /*!

    35     \class MpEqualizerFrameworkWrapperPrivate

    36     \ingroup musicplayer

    37     \brief Wrapper for equalizer framework - private implementation.

    38     

    39     This is a private implementation of the audio eqalizer wrapper 

    40     utilties interface.

    41 

    42 */

    43 

    44 /*!

    45     Constructs a new MpEqualizerFrameworkWrapper with \a parent and initializes its

    46     private imaplementation.

    47 */

    48 MpEqualizerFrameworkWrapperPrivate::MpEqualizerFrameworkWrapperPrivate( MpEqualizerFrameworkWrapper *wrapper ): 

    49     q_ptr( wrapper ),

    50     mEqualizerUtility (NULL)

    51 {

    52     TX_LOG

    53 }

    54 

    55 /*!

    56     Destructs the class.    

    57  */

    58 MpEqualizerFrameworkWrapperPrivate::~MpEqualizerFrameworkWrapperPrivate()

    59 {

    60     TX_ENTRY

    61 

    62     delete mEqualizerUtility;

    63     

    64     if ( mMdaPlayUtility ) {

    65         mMdaPlayUtility->Close();

    66     }

    67     delete mMdaPlayUtility;

    68 

    69     TX_EXIT

    70 }

    71 

    72 /*!

    73     Calls the DoInit to initialize Symbian based components.

    74     

    75     \sa DoInitL()

    76  */

    77 void MpEqualizerFrameworkWrapperPrivate::init()

    78 {

    79     TX_ENTRY

    80 

    81     TRAPD(err, DoInitL());

    82     if ( err != KErrNone ) {

    83         TX_LOG_ARGS("MpEqualizerFrameworkWrapperPrivate::init err = " << err);

    84     }

    85     

    86     TX_EXIT

    87 }

    88 

    89 /*!

    90     Get the preset name key by giving preset index.

    91 

    92  */

    93 int MpEqualizerFrameworkWrapperPrivate::getPresetNameKey( int presetIndex )

    94 {

    95     TX_ENTRY_ARGS( "preset index=" << presetIndex );

    96 

    97     int presetKey( KEqualizerPresetNone );

    98     if ( mEqualizerUtility ) {

    99         TRAPD( err, presetKey = DoGetPresetNameKeyL( presetIndex ) );

   100         if ( err != KErrNone ) {

   101             TX_LOG_ARGS("DoGetPresetNameKeyL Error  = " << err);

   102             presetKey = KEqualizerPresetNone;

   103         }

   104         TX_LOG_ARGS( "Preset key in engine =" << presetKey );

   105     } 

   106     else {

   107         TX_LOG_ARGS( "Equalizer not ready." );

   108     }

   109 

   110     TX_EXIT_ARGS( "Preset Name Key = " << presetKey );

   111     

   112     return presetKey;

   113 }

   114 

   115 /*!

   116     Get the preset index by giving preset name key.

   117     

   118  */

   119 int MpEqualizerFrameworkWrapperPrivate::getPresetIndex( int presetNameKey )

   120 {

   121     TX_ENTRY_ARGS( "Preset Name Key = " << presetNameKey);

   122 

   123     int presetIndex = KEqualizerPresetNone;

   124     if ( mEqualizerUtility && presetNameKey != KEqualizerPresetNone ) {

   125         TArray<TEfAudioEqualizerUtilityPreset> presetArray = mEqualizerUtility->Presets();

   126         for ( TInt i = 0; i < presetArray.Count(); i++ ) {

   127             TX_LOG_ARGS("presetArray[" << i << "].iPresetNameKey (" 

   128                 << presetArray[i].iPresetNameKey << ") vs presetId (" <<presetNameKey << ")");

   129             if ( presetArray[i].iPresetNameKey == static_cast<TUint32>( presetNameKey ) ) {

   130                 presetIndex = i;

   131                 break;

   132             }

   133         }

   134     }

   135 

   136     TX_EXIT_ARGS( "Preset Index = " << presetIndex );

   137 

   138     return presetIndex;

   139 }

   140 

   141 

   142 /*!

   143     Returning the list of availale preset names.  

   144 

   145     \sa CAudioEqualizerUtility

   146  */

   147 QStringList MpEqualizerFrameworkWrapperPrivate::presetNames()

   148 {

   149     TX_ENTRY

   150 

   151     QStringList presetList;

   152 

   153     if ( mEqualizerUtility == NULL ) {

   154         TX_LOG_ARGS( "Equalizer not ready." );

   155         return presetList;

   156     }

   157 

   158     TArray<TEfAudioEqualizerUtilityPreset> presetArray = mEqualizerUtility->Presets();

   159     for (TInt i=0; i<presetArray.Count(); i++) {

   160         TPresetName selectedItem = presetArray[i].iPresetName;

   161         presetList << QString::fromUtf16( selectedItem.Ptr(), selectedItem.Length() );

   162     }

   163 

   164     TX_EXIT_ARGS( "PresetNames=" << presetList);

   165 

   166     return presetList;

   167 }

   168 

   169 /*!

   170  \internal

   171  */

   172 void MpEqualizerFrameworkWrapperPrivate::DoInitL()

   173 {

   174     TX_ENTRY

   175 

   176     if (mMdaPlayUtility) {

   177         mMdaPlayUtility->Close();

   178         delete mMdaPlayUtility;

   179         mMdaPlayUtility = NULL;

   180     }

   181     

   182     mMdaPlayUtility = ( CMdaAudioPlayerUtility* )User::LeaveIfNull(

   183         CMdaAudioPlayerUtility::NewL(

   184             *this,

   185             EMdaPriorityMin,

   186             EMdaPriorityPreferenceNone ));

   187 

   188     TX_LOG_ARGS("Loading null sound");

   189     TFileName nullSoundPath( KMPXNullSoundPath );

   190     User::LeaveIfError( MPXUser::CompleteWithDllPath( nullSoundPath ) );

   191     TX_LOG_ARGS("Loading null sound done!");

   192     mMdaPlayUtility->OpenFileL( nullSoundPath );

   193     

   194     TX_EXIT

   195 }

   196 

   197 /*!

   198  \internal

   199  */

   200 TInt MpEqualizerFrameworkWrapperPrivate::DoGetPresetNameKeyL( const TInt presetIndex ) const 

   201 {

   202     TX_ENTRY_ARGS( "preset index=" << presetIndex );

   203 

   204     TInt presetNameKey = KErrNotFound;

   205     TPresetName presetName = mEqualizerUtility->GetPresetL( presetIndex );

   206 

   207     TArray<TEfAudioEqualizerUtilityPreset> presets = mEqualizerUtility->Presets();

   208     for ( TInt index = 0; index < presets.Count(); index++ ) {

   209         TPresetName selectedItem = presets[index].iPresetName;

   210         TX_LOG_ARGS(" Comparing..." << presets[index].iPresetNameKey );

   211         if ( selectedItem == presetName ) {

   212             presetNameKey = presets[index].iPresetNameKey;

   213             TX_LOG_ARGS(" Comparing mached presetNameKey = " << presetNameKey );

   214             break;

   215             }

   216     }

   217 

   218     TX_EXIT

   219 

   220     return presetNameKey;

   221 }

   222 

   223 /*!

   224  \internal

   225  */

   226 void MpEqualizerFrameworkWrapperPrivate::MapcInitComplete(

   227     TInt aError,

   228     const TTimeIntervalMicroSeconds& /* aDuration */ )

   229 {

   230     TX_ENTRY_ARGS( "aError=" << aError );

   231 

   232     if ( !aError ) {

   233         TRAPD(err, mEqualizerUtility = CAudioEqualizerUtility::NewL( *mMdaPlayUtility ) );

   234         if ( err == KErrNone ) {

   235             emit q_ptr->equalizerReady();

   236         }

   237         else {

   238             TX_ENTRY_ARGS( "CAudioEquqlizerUtility error=" << err );

   239         }

   240     }

   241     else {

   242         TX_ENTRY_ARGS( "MapcInitComplete error=" << aError );

   243     }

   244 

   245     TX_EXIT

   246 }

   247 

   248 /*!

   249  \internal

   250  */

   251 void MpEqualizerFrameworkWrapperPrivate::MapcPlayComplete(

   252     TInt /* aError */ )

   253 {

   254     TX_LOG

   255     // Do nothing

   256 }

   257 

   258 //End of File