1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "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 * Ixonos Plc

    14 *

    15 * Description:  

    16 *

    17 */

    18 

    19 

    20 

    21 #include "ProcVisualizationAO.h"

    22 #include "ProcVisProcessor.h"

    23 #include "AudPanic.h"

    24 

    25 

    26 void CProcVisualizationAO::RunL()

    27     {

    28     __ASSERT_DEBUG(iProcVisProcessor != 0, TAudPanic::Panic(TAudPanic::EInternal));

    29     __ASSERT_DEBUG(iObserver != 0, TAudPanic::Panic(TAudPanic::EInternal));

    30     

    31     if(iVisualizationState == EProcVisualizationIdle) 

    32         {

    33         TAudPanic::Panic(TAudPanic::EInternal);

    34         }

    35     

    36     else if (iVisualizationState == EProcGettingClipVisualization) 

    37         {

    38         

    39         TBool completed = EFalse;

    40         TInt progress = 0;

    41         TRAPD(err, completed = iProcVisProcessor->VisualizeClipPieceL(progress));

    42         

    43         if (err != KErrNone)

    44             {

    45             delete iProcVisProcessor;

    46             iProcVisProcessor = 0;

    47             

    48             MAudVisualizationObserver* observer = iObserver;

    49             iObserver = 0;

    50             iSize = 0;

    51             iVisualizationState = EProcVisualizationIdle;

    52             observer->NotifyClipInfoVisualizationCompleted(*iClipInfo, err, NULL, 0);

    53             }

    54         else if (completed)

    55             {

    56             TInt8* visualization = 0;

    57             TInt size = 0;

    58             TRAPD(err2, iProcVisProcessor->GetFinalVisualizationL(visualization, size));

    59             

    60             if (err2 != KErrNone)

    61                 {

    62                 MAudVisualizationObserver* observer = iObserver;

    63                 iObserver = 0;

    64             

    65                 if (visualization != 0) delete[] visualization;

    66                 delete iProcVisProcessor;

    67                 iProcVisProcessor = 0;

    68                 iVisualizationState = EProcVisualizationIdle;

    69                 

    70                 observer->NotifyClipInfoVisualizationCompleted(*iClipInfo, err2, 0, 0);

    71                 return;

    72                 }

    73             

    74             delete iProcVisProcessor;

    75             iProcVisProcessor = 0;

    76             

    77             MAudVisualizationObserver* observer = iObserver;

    78             iObserver = 0;

    79             iSize = 0;

    80             iVisualizationState = EProcVisualizationIdle;

    81 

    82             // NOTE: the upper level application is responsible for releasing "visualization"

    83             observer->NotifyClipInfoVisualizationCompleted(*iClipInfo, KErrNone, visualization, size);

    84             }

    85         else

    86             {

    87 

    88             // progress is sent every 1 percent

    89             if (iPreviousProgressValue < progress)

    90                 {

    91                 iObserver->NotifyClipInfoVisualizationProgressed(*iClipInfo, progress);

    92                 iPreviousProgressValue = progress;

    93                 }

    94 

    95             SetActive();

    96             TRequestStatus* status = &iStatus;

    97             User::RequestComplete(status, KErrNone);

    98             }

    99         

   100         }

   101     }

   102 

   103 void CProcVisualizationAO::DoCancel() 

   104     {

   105 

   106     // ref to observer should be reset before callback to avoid recursion

   107     MAudVisualizationObserver* observer = iObserver;

   108     iObserver = 0;

   109     // ref to clipInfo is good to reset before callback

   110     const CAudClipInfo* clipInfo = iClipInfo;

   111     iClipInfo = 0;

   112     // processor not needed and should not exist any more; a new processor will be created for next visualization

   113     delete iProcVisProcessor;

   114     iProcVisProcessor = 0;

   115     

   116     if ((observer != 0) && (iVisualizationState == EProcGettingClipVisualization))

   117         {

   118         // reset state

   119         iVisualizationState = EProcVisualizationIdle;

   120 

   121         // note! this callback at least at the time of writing deletes this object => no operations should be done after this call

   122         observer->NotifyClipInfoVisualizationCompleted(*clipInfo, KErrCancel, 0, 0);

   123         }

   124     }

   125    

   126 CProcVisualizationAO* CProcVisualizationAO::NewL() 

   127     {

   128     CProcVisualizationAO* self = new (ELeave) CProcVisualizationAO();

   129     CleanupStack::PushL(self);

   130     self->ConstructL();

   131     CleanupStack::Pop(self);

   132     return self;

   133     }

   134 

   135 CProcVisualizationAO::~CProcVisualizationAO()

   136     {

   137     // cancel the active object; it also deletes or resets member variables

   138     Cancel();

   139     }

   140     

   141 

   142 void CProcVisualizationAO::ConstructL() 

   143     {

   144     // nothing to do; iProcVisProcessor will be created when started

   145     }

   146 

   147 CProcVisualizationAO::CProcVisualizationAO() : 

   148         CActive(0),

   149         iVisualizationState(EProcVisualizationIdle) 

   150         {

   151 

   152     CActiveScheduler::Add(this);

   153 

   154     }

   155 

   156 void CProcVisualizationAO::StartClipVisualizationL(const CAudClipInfo* aClipInfo, TInt aSize,

   157                                                    MAudVisualizationObserver& aObserver, 

   158                                                    TInt aPriority) 

   159     {

   160 

   161     if (iVisualizationState != EProcVisualizationIdle || iClipInfo != 0) 

   162         {

   163         TAudPanic::Panic(TAudPanic::EVisualizationProcessAlreadyRunning);

   164         }

   165 

   166     iSize = aSize;

   167     iClipInfo = aClipInfo;

   168     iProcVisProcessor = CProcVisProcessor::NewL();

   169     

   170     iPreviousProgressValue = 0;

   171 

   172 

   173     TRAPD(err, iProcVisProcessor->VisualizeClipL(aClipInfo, aSize));

   174 

   175     if (err != KErrNone)

   176         {

   177         delete iProcVisProcessor;

   178         iProcVisProcessor = 0;

   179         aObserver.NotifyClipInfoVisualizationCompleted(*aClipInfo, err, 0, 0);

   180         User::Leave(err);

   181         }

   182 

   183     aObserver.NotifyClipInfoVisualizationStarted(*aClipInfo, KErrNone);

   184 

   185     iObserver = &aObserver;

   186 

   187     SetPriority(aPriority);

   188     SetActive();

   189     TRequestStatus* status = &iStatus;

   190     User::RequestComplete(status, KErrNone);

   191 

   192     iVisualizationState = EProcGettingClipVisualization;

   193 

   194     }

   195 

   196 

   197 

   198 

   199 void CProcVisualizationAO::CancelVisualization() 

   200     {

   201     Cancel();

   202     }

   203