videoplayerapp/videoplayerengine/tsrc/testvideoappuiengine/stub/src/mpxcollectionutilityimp_stub.cpp
changeset 36 8aed59de29f9
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9
       
     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:  mpx collection utility stub for unit testing
       
    15 *
       
    16 */
       
    17 
       
    18 // Version : %version: 1 %
       
    19 
       
    20 
       
    21 #include <mpxcollectionplaylist.h>
       
    22 #include <mpxcollectionpath.h>
       
    23 #include <mpxcollectionplaylistobserver.h>
       
    24 
       
    25 #include "testutilities.h"
       
    26 #include "mpxcollectionutilityimp_stub.h"
       
    27 #include "mpxvideo_debug.h"
       
    28 
       
    29 
       
    30 CMPXCollectionUtility*
       
    31 CMPXCollectionUtility::NewL( const TUid& /*aModeId*/, MMPXCollectionObserver* aObs )
       
    32 {
       
    33     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::NewL()"));
       
    34 /*
       
    35     TestUtilities* utility = reinterpret_cast<TestUtilities*>( Dll::Tls() );
       
    36 
       
    37     if ( ! utility )
       
    38     {
       
    39         utility = new (ELeave) TestUtilities;
       
    40 
       
    41         Dll::SetTls( utility );
       
    42     }
       
    43 
       
    44     if ( ! utility->iCollectionUtility )
       
    45     {
       
    46         utility->iCollectionUtility = new (ELeave) CMPXCollectionUtility( aObs );
       
    47     }
       
    48 
       
    49     utility->iCollectionUtility->AddRefCount();
       
    50 
       
    51     return utility->iCollectionUtility;
       
    52 */
       
    53 
       
    54     TestUtilities* utility = reinterpret_cast<TestUtilities*>( UserSvr::DllTls(12345678) );
       
    55     	
       
    56     if ( !utility )
       
    57     {
       
    58         utility = new (ELeave) TestUtilities;
       
    59     
       
    60         UserSvr::DllSetTls(12345678, utility);
       
    61     
       
    62         utility = reinterpret_cast<TestUtilities*>( UserSvr::DllTls(12345678) );        
       
    63     }
       
    64     		
       
    65     	
       
    66 
       
    67     	
       
    68     if ( ! utility->iCollectionUtility )
       
    69     {
       
    70         utility->iCollectionUtility = new (ELeave) CMPXCollectionUtility( aObs );
       
    71     }
       
    72 
       
    73     utility->iCollectionUtility->AddRefCount();
       
    74 
       
    75     return utility->iCollectionUtility;    	
       
    76     
       
    77 }
       
    78 
       
    79 CMPXCollectionUtility::~CMPXCollectionUtility()
       
    80 {
       
    81     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::~CMPXCollectionUtility()"));
       
    82 
       
    83     if ( iCollectionPath )
       
    84     {
       
    85         delete iCollectionPath;
       
    86     }
       
    87 }
       
    88 
       
    89 CMPXCollectionUtility::CMPXCollectionUtility( MMPXCollectionObserver* aObs )
       
    90     : iObserver( aObs ),
       
    91       iCollectionPath( NULL ),
       
    92       iRefCount(0)
       
    93 {
       
    94 }
       
    95 
       
    96 void CMPXCollectionUtility::ConstructL( const TUid& /*aModeId*/ )
       
    97 {
       
    98 }
       
    99 
       
   100 /*
       
   101 void CMPXCollectionUtility::AddTestObserverL( MAppUiEngineUnitTestObserver* aObserver )
       
   102 {
       
   103     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::AddTestObserverL()"));
       
   104 
       
   105     iTestObserver = aObserver;
       
   106 }
       
   107 
       
   108 void CMPXCollectionUtility::RemoveTestObserverL()
       
   109 {
       
   110     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::RemoveTestObserverL()"));
       
   111 
       
   112     iTestObserver = NULL;
       
   113 }
       
   114 */
       
   115 
       
   116 MMPXCollection&
       
   117 CMPXCollectionUtility::Collection()
       
   118 {
       
   119     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::Collection()"));
       
   120     return *this;
       
   121 }
       
   122 
       
   123 TUid
       
   124 CMPXCollectionUtility::CollectionIDL( const TArray<TUid>& /*aUids*/ )
       
   125 {
       
   126     return KNullUid;
       
   127 }
       
   128 
       
   129 void CMPXCollectionUtility::AddSubscriptionL( const CMPXSubscription& /*aSubscription*/ )
       
   130 {
       
   131 }
       
   132 
       
   133 void CMPXCollectionUtility::RemoveSubscriptionL( const CMPXSubscription& /*aSubscription*/ )
       
   134 {
       
   135 }
       
   136 
       
   137 void CMPXCollectionUtility::ClearSubscriptionsL()
       
   138 {
       
   139 }
       
   140 
       
   141 void CMPXCollectionUtility::AddRefCount()
       
   142 {
       
   143     iRefCount++;
       
   144 }
       
   145 
       
   146 void CMPXCollectionUtility::Close()
       
   147 {
       
   148     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::Close()"),
       
   149                    _L("iRefCount = %d"), iRefCount );
       
   150 
       
   151     if ( --iRefCount == 0 )
       
   152     {
       
   153         //TestUtilities* utility = reinterpret_cast<TestUtilities*>( Dll::Tls() );
       
   154         TestUtilities* utility = reinterpret_cast<TestUtilities*>( UserSvr::DllTls(12345678) );
       
   155 
       
   156         utility->DeleteCollectionUtility();
       
   157     }
       
   158 }
       
   159 
       
   160 void CMPXCollectionUtility::OpenL( TMPXOpenMode /*aMode*/ )
       
   161 {
       
   162 }
       
   163 
       
   164 void CMPXCollectionUtility::OpenL( TInt /*aIndex*/, TMPXOpenMode /*aMode*/ )
       
   165 {
       
   166 }
       
   167 
       
   168 void CMPXCollectionUtility::OpenL( const CMPXCollectionPath& /*aPath*/, TMPXOpenMode /*aMode*/ )
       
   169 {
       
   170     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::OpenL()"));
       
   171 
       
   172 /*    if ( iTestObserver )
       
   173     {
       
   174         TCallbackEvent* event = new TCallbackEvent;
       
   175         event->iEvent = ECollectionUtilityOpen;
       
   176         iTestObserver->HandleUtilityEvent( event );
       
   177     }
       
   178 */
       
   179 }
       
   180 
       
   181 void CMPXCollectionUtility::OpenL( TInt /*aIndex*/,
       
   182                                    const TArray<TMPXAttribute>& /*aAttrs*/,
       
   183                                    TMPXOpenMode /*aMode*/ )
       
   184 {
       
   185 }
       
   186 
       
   187 void CMPXCollectionUtility::OpenL( const CMPXCollectionPath& /*aPath*/,
       
   188                                    const TArray<TMPXAttribute>& /*aAttrs*/,
       
   189                                    TMPXOpenMode /*aMode*/ )
       
   190 {
       
   191 }
       
   192 
       
   193 void CMPXCollectionUtility::OpenL( const TArray<TUid>& /*aUids*/, TMPXOpenMode /*aMode*/ )
       
   194 {
       
   195 }
       
   196 
       
   197 void CMPXCollectionUtility::OpenL( const TUid& /*aUid*/, TMPXOpenMode /*aMode*/ )
       
   198 {
       
   199 }
       
   200 
       
   201 void CMPXCollectionUtility::SetFilterL( CMPXFilter* /*aFilter*/ )
       
   202 {
       
   203 }
       
   204 
       
   205 CMPXFilter* CMPXCollectionUtility::FilterL()
       
   206 {
       
   207     return NULL;
       
   208 }
       
   209 
       
   210 TUid
       
   211 CMPXCollectionUtility::UidL() const
       
   212 {
       
   213     return KNullUid;
       
   214 }
       
   215 
       
   216 CMPXCollectionPath* CMPXCollectionUtility::PathL()
       
   217 {
       
   218     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::PathL()"));
       
   219 
       
   220     CMPXCollectionPath* cp = CMPXCollectionPath::NewL();
       
   221 
       
   222     TMPXItemId item1;
       
   223     TMPXItemId item2;
       
   224 
       
   225     cp->AppendL( item1 );
       
   226     cp->AppendL( item2 );
       
   227 
       
   228     return cp;
       
   229 }
       
   230 
       
   231 void CMPXCollectionUtility::BackL()
       
   232 {
       
   233 }
       
   234 
       
   235 TBool CMPXCollectionUtility::IsRemote( const CMPXCollectionPath& /*aPath*/ )
       
   236 {
       
   237     return EFalse;
       
   238 }
       
   239 
       
   240 void CMPXCollectionUtility::CancelRequest()
       
   241 {
       
   242 }
       
   243 
       
   244 void CMPXCollectionUtility::AddL( const CMPXMedia& /*aNewProperties*/ )
       
   245 {
       
   246 }
       
   247 
       
   248 void CMPXCollectionUtility::RemoveL( const CMPXCollectionPath& /*aPath*/,
       
   249                                      MMPXCollectionRemoveObserver* /*aObs*/ )
       
   250 {
       
   251 }
       
   252 
       
   253 void CMPXCollectionUtility::RemoveL( const CMPXMedia& /*aProperties*/ )
       
   254 {
       
   255 }
       
   256 
       
   257 void CMPXCollectionUtility::SetSyncL( const CMPXMedia& /*aMedia*/ )
       
   258 {
       
   259 }
       
   260 
       
   261 void CMPXCollectionUtility::SetL( const CMPXMedia& /*aMedia*/ )
       
   262 {
       
   263 }
       
   264 
       
   265 void CMPXCollectionUtility::FindAllL( const CMPXMedia& /*aMedia*/,
       
   266                                       const TArray<TMPXAttribute>& /*aAttrs*/,
       
   267                                       MMPXCollectionFindObserver& /*aObs*/ )
       
   268 {
       
   269 }
       
   270 
       
   271 // ----------------------------------------------------------------------------
       
   272 // Find media sync
       
   273 // ----------------------------------------------------------------------------
       
   274 //
       
   275 CMPXMedia*
       
   276 CMPXCollectionUtility::FindAllL( const CMPXMedia& /*aMedia*/,
       
   277                                  const TArray<TMPXAttribute>& /*aAttrs*/ )
       
   278 {
       
   279     return NULL;
       
   280 }
       
   281 
       
   282 void CMPXCollectionUtility::MediaL( const CMPXCollectionPath& /*aPath*/,
       
   283                                     const TArray<TMPXAttribute>& /*aAttrs*/,
       
   284                                     CMPXAttributeSpecs* /*aSpecs*/,
       
   285                                     CMPXFilter* /*aFilter*/ )
       
   286 {
       
   287     MPX_ENTER_EXIT(_L("CMPXCollectionUtility::MediaL()"));
       
   288 
       
   289 /*    if ( iTestObserver )
       
   290     {
       
   291         TCallbackEvent* event = new TCallbackEvent;
       
   292         event->iEvent = ECollectionUtilityMedia;
       
   293         iTestObserver->HandleUtilityEvent( event );
       
   294     }
       
   295 */    
       
   296 }
       
   297 
       
   298 void CMPXCollectionUtility::NotifyL( TMPXCollectionBroadCastMsg /*aMsg*/, TInt /*aData*/ )
       
   299 {
       
   300 }
       
   301 
       
   302 void CMPXCollectionUtility::CommandL( TMPXCollectionCommand /*aCmd*/, TInt /*aData*/ )
       
   303 {
       
   304 }
       
   305 
       
   306 void CMPXCollectionUtility::CommandL( CMPXCommand& /*aCmd*/ )
       
   307 {
       
   308 }
       
   309 
       
   310 void CMPXCollectionUtility::GetSupportedTypesL( RPointerArray<CMPXCollectionType>& /*aArray*/ )
       
   311 {
       
   312 }
       
   313 
       
   314 void CMPXCollectionUtility::GetSupportedCapabilitiesL( TCollectionCapability& /*aCapability*/ )
       
   315 {
       
   316 }
       
   317 
       
   318 TUid CMPXCollectionUtility::CollectionIDL( TUid& /*aCollection*/ )
       
   319 {
       
   320     return KNullUid;
       
   321 }
       
   322 
       
   323 void CMPXCollectionUtility::MessageReceived( TInt /*aMsgData*/, TInt /*aError*/ )
       
   324 {
       
   325 }
       
   326 
       
   327 
       
   328 // End of file