1 /*

     2 * Copyright (c) 2002 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:  This class is used for creating MIDI player.

    15 *

    16 */

    17 

    18 

    19 //  INCLUDE FILES

    20 #include <logger.h>

    21 

    22 #include "cmmamidiplayerfactory.h"

    23 #include "cmmamidiplayer.h"

    24 #include "cmmamidivolumecontrol.h"

    25 #include "cmmamidistoptimecontrol.h"

    26 #include "cmmamidicontrol.h"

    27 #include "cmmamiditempocontrol.h"

    28 #include "cmmamidipitchcontrol.h"

    29 #include "cmmammfresolver.h"

    30 #include "cmmamidimetadatacontrol.h"

    31 

    32 

    33 _LIT(KMMAMidi, "midi");

    34 _LIT(KDeviceMidiContentType, "audio/midi");

    35 

    36 CMMAMIDIPlayerFactory* CMMAMIDIPlayerFactory::NewLC()

    37 {

    38     CMMAMIDIPlayerFactory* pFactory =

    39         new(ELeave) CMMAMIDIPlayerFactory();

    40     CleanupStack::PushL(pFactory);

    41     return pFactory;

    42 }

    43 

    44 CMMAMIDIPlayerFactory::CMMAMIDIPlayerFactory()

    45 {

    46 }

    47 

    48 

    49 CMMAMIDIPlayerFactory::~CMMAMIDIPlayerFactory()

    50 {

    51 }

    52 

    53 CMMAPlayer* CMMAMIDIPlayerFactory::CreatePlayerL(

    54     CMMAMMFResolver* aResolver)

    55 {

    56     // if we get this far then MIDI is supported

    57     HBufC* contentType = aResolver->ContentType();

    58     HBufC* tmpFileName = aResolver->FileNameOwnership();

    59     TFileName fileName;

    60     if (tmpFileName)

    61     {

    62         fileName.Copy(tmpFileName->Des());

    63     }

    64     else

    65     {

    66         fileName = KNullDesC;

    67     }

    68     delete tmpFileName;

    69     CMMAPlayer* player = CreateMidiFilePlayerL(*contentType, fileName);

    70     return player;

    71 }

    72 

    73 

    74 void CMMAMIDIPlayerFactory::MediaIdsL(RArray<TUid>& aMediaIds)

    75 {

    76     User::LeaveIfError(aMediaIds.Append(KUidMediaTypeMidi));

    77 }

    78 

    79 CMMAPlayer* CMMAMIDIPlayerFactory::CreatePlayerL(

    80     const TDesC& aProtocol,

    81     const TDesC& aMiddlePart,

    82     const TDesC& aProperties)

    83 {

    84     CMMAPlayer* player = NULL;

    85     if ((aProtocol == KMMADeviceProtocol) &&

    86             (aMiddlePart == KMMAMidi))

    87     {

    88         // locator was device://midi

    89         player = CreateMidiSynthPlayerL(KDeviceMidiContentType);

    90     }

    91     else

    92     {

    93         // other locator, if it is midi file CMMAMMFPlayerFactory

    94         // calls CreatePlayerL( CMMAMMFResolver* aResolver ) method.

    95         player = CMMAMMFPlayerFactory::CreatePlayerL(aProtocol,

    96                  aMiddlePart,

    97                  aProperties);

    98     }

    99     return player;

   100 }

   101 

   102 void CMMAMIDIPlayerFactory::GetSupportedProtocolsL(

   103     const TDesC& aContentType,

   104     CDesC16Array& aProtocolArray)

   105 {

   106     if (IsSupportedContentTypeL(aContentType))

   107     {

   108         aProtocolArray.AppendL(KMMADeviceProtocol);

   109     }

   110 }

   111 

   112 CMMAPlayer* CMMAMIDIPlayerFactory::CreateMidiFilePlayerL(const TDesC& aContentType,

   113         TFileName aFileName)

   114 {

   115     CMMAMIDIPlayer* player = CMMAMIDIPlayer::NewLC(aContentType, aFileName);

   116 

   117     CMMAMIDIVolumeControl* volumeControl = CMMAMIDIVolumeControl::NewL(player);

   118     CleanupStack::PushL(volumeControl);

   119     player->AddControlL(volumeControl);

   120     CleanupStack::Pop(volumeControl);

   121 

   122     CMMAMIDIStopTimeControl* stopTimeControl = CMMAMIDIStopTimeControl::NewL(player);

   123     CleanupStack::PushL(stopTimeControl);

   124     player->AddControlL(stopTimeControl);

   125     CleanupStack::Pop(stopTimeControl);

   126 

   127     CMMAMIDIControl* midiControl = CMMAMIDIControl::NewL(player);

   128     CleanupStack::PushL(midiControl);

   129     player->AddControlL(midiControl);

   130     CleanupStack::Pop(midiControl);

   131 

   132     CMMAMIDITempoControl* tempoControl = CMMAMIDITempoControl::NewL(player);

   133     CleanupStack::PushL(tempoControl);

   134     player->AddControlL(tempoControl);

   135     CleanupStack::Pop(tempoControl);

   136 

   137     CMMAMIDIPitchControl* pitchControl = CMMAMIDIPitchControl::NewL(player);

   138     CleanupStack::PushL(pitchControl);

   139     player->AddControlL(pitchControl);

   140     CleanupStack::Pop(pitchControl);

   141 

   142 #ifdef __MMA_METADATA_CONTROL__

   143     CMMAMIDIMetaDataControl* metaDataControl =

   144         new(ELeave) CMMAMIDIMetaDataControl(player);

   145     CleanupStack::PushL(metaDataControl);

   146     player->AddControlL(metaDataControl);

   147     CleanupStack::Pop(metaDataControl);

   148 #endif // __MMA_METADATA_CONTROL__

   149 

   150     CleanupStack::Pop(player);

   151     return player;

   152 }

   153 

   154 CMMAPlayer* CMMAMIDIPlayerFactory::CreateMidiSynthPlayerL(const TDesC& aContentType)

   155 {

   156     CMMAMIDIPlayer* player = CMMAMIDIPlayer::NewLC(aContentType, KNullDesC());

   157 

   158     CMMAMIDIVolumeControl* volumeControl = CMMAMIDIVolumeControl::NewL(player);

   159     CleanupStack::PushL(volumeControl);

   160     player->AddControlL(volumeControl);

   161     CleanupStack::Pop(volumeControl);

   162 

   163     CMMAMIDIControl* midiControl = CMMAMIDIControl::NewL(player);

   164     CleanupStack::PushL(midiControl);

   165     player->AddControlL(midiControl);

   166     CleanupStack::Pop(midiControl);

   167 

   168     CMMAMIDIPitchControl* pitchControl = CMMAMIDIPitchControl::NewL(player);

   169     CleanupStack::PushL(pitchControl);

   170     player->AddControlL(pitchControl);

   171     CleanupStack::Pop(pitchControl);

   172 

   173     CleanupStack::Pop(player);

   174     return player;

   175 }

   176 

   177 //  END OF FILE

   178