|
1 /* |
|
2 * Copyright (c) 2007 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: Music specific memory plugin |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <e32base.h> |
|
20 #include <f32file.h> |
|
21 #include <badesca.h> |
|
22 #include <apgcli.h> |
|
23 #include <mpxcollectiontype.h> |
|
24 #include <mpxcollectionpath.h> |
|
25 #include <mpxmediageneraldefs.h> |
|
26 #include <mpxmediamusicdefs.h> |
|
27 #include <mpxmediaaudiodefs.h> |
|
28 #include <mpxmediacontainerdefs.h> |
|
29 #include <mpxmediadrmdefs.h> |
|
30 #include <mpxmediaarray.h> |
|
31 #include <mpxcollectionpluginobserver.h> |
|
32 #include <mpxdrmmediautility.h> |
|
33 |
|
34 #include <mpxmetadataextractor.h> |
|
35 #include "mpxmusicmemoryplugin.h" |
|
36 |
|
37 // CONSTANTS |
|
38 const TInt KIMMusicPluginUid = 0x10282960; |
|
39 const TMPXAttributeData KMPXMediaFetched = {KIMMusicPluginUid, 0x01}; // TInt |
|
40 |
|
41 // ======== MEMBER FUNCTIONS ======== |
|
42 |
|
43 // --------------------------------------------------------------------------- |
|
44 // Default Constructor |
|
45 // --------------------------------------------------------------------------- |
|
46 // |
|
47 CMPXMusicMemoryPlugin::CMPXMusicMemoryPlugin() |
|
48 { |
|
49 } |
|
50 |
|
51 |
|
52 // --------------------------------------------------------------------------- |
|
53 // 2nd phased constructor |
|
54 // --------------------------------------------------------------------------- |
|
55 // |
|
56 void CMPXMusicMemoryPlugin::ConstructL() |
|
57 { |
|
58 User::LeaveIfError( iFs.Connect() ); |
|
59 User::LeaveIfError( iAppArc.Connect() ); |
|
60 RPointerArray<CMPXCollectionType> dummy; |
|
61 CleanupClosePushL( dummy ); |
|
62 iMetadataExtractor = CMPXMetadataExtractor::NewL( iFs, iAppArc, dummy ); |
|
63 dummy.ResetAndDestroy(); |
|
64 CleanupStack::PopAndDestroy( &dummy ); |
|
65 |
|
66 iAttributes.AppendL(KMPXMediaDrmAll); |
|
67 |
|
68 // Base class construction |
|
69 CMPXInMemoryPlugin::ConstructL(); |
|
70 } |
|
71 |
|
72 |
|
73 // --------------------------------------------------------------------------- |
|
74 // Two-phased constructor |
|
75 // --------------------------------------------------------------------------- |
|
76 // |
|
77 CMPXMusicMemoryPlugin* CMPXMusicMemoryPlugin::NewL() |
|
78 { |
|
79 CMPXMusicMemoryPlugin* self = new(ELeave) CMPXMusicMemoryPlugin(); |
|
80 CleanupStack::PushL( self ); |
|
81 self->ConstructL(); |
|
82 CleanupStack::Pop( self ); |
|
83 return self; |
|
84 } |
|
85 |
|
86 // --------------------------------------------------------------------------- |
|
87 // Virtual destructor |
|
88 // --------------------------------------------------------------------------- |
|
89 // |
|
90 CMPXMusicMemoryPlugin::~CMPXMusicMemoryPlugin() |
|
91 { |
|
92 iFs.Close(); |
|
93 iAppArc.Close(); |
|
94 delete iMetadataExtractor; |
|
95 iAttributes.Close(); |
|
96 } |
|
97 |
|
98 |
|
99 // ---------------------------------------------------------------------------- |
|
100 // Extended properties of the current file (async) |
|
101 // ---------------------------------------------------------------------------- |
|
102 // |
|
103 void CMPXMusicMemoryPlugin::MediaL ( |
|
104 const CMPXCollectionPath& aPath, |
|
105 const TArray<TMPXAttribute>& aAttrs, |
|
106 const TArray<TCapability>& /*aCaps*/, |
|
107 CMPXAttributeSpecs* /*aSpecs*/) |
|
108 { |
|
109 RArray<TInt> supportedIds; |
|
110 CleanupClosePushL(supportedIds); |
|
111 supportedIds.AppendL(KMPXMediaIdGeneral); |
|
112 CMPXMedia* entries=CMPXMedia::NewL(supportedIds.Array()); |
|
113 CleanupStack::PopAndDestroy(&supportedIds); |
|
114 CleanupStack::PushL(entries); |
|
115 |
|
116 // Based on Path, what is the embedded client context id? |
|
117 // |
|
118 TInt err = KErrNone; |
|
119 TInt depth = aPath.Levels(); |
|
120 switch( depth ) |
|
121 { |
|
122 case 2: // Playlist / Song level |
|
123 case 3: // Song in a playlist level, fall through |
|
124 { |
|
125 TInt context = aPath.Id(1); |
|
126 TInt contextIndex = iEmbeddedContext.Find( context ); |
|
127 if( contextIndex >= KErrNone ) |
|
128 { |
|
129 CMPXMedia& media = *iTemporaryData[contextIndex]; |
|
130 |
|
131 TMPXGeneralCategory cat; |
|
132 cat = *media.Value<TMPXGeneralCategory>(KMPXMediaGeneralCategory); |
|
133 |
|
134 // Playlist media |
|
135 // |
|
136 if( cat == EMPXPlaylist && depth == 2) |
|
137 { |
|
138 // Get |
|
139 const TDesC& title = media.ValueText( KMPXMediaGeneralTitle ); |
|
140 const TDesC& uri = media.ValueText( KMPXMediaGeneralUri ); |
|
141 // Set |
|
142 entries->SetTextValueL( KMPXMediaGeneralTitle, title ); |
|
143 entries->SetTextValueL( KMPXMediaGeneralUri, uri ); |
|
144 entries->SetTObjectValueL<TUid>(KMPXMediaGeneralCollectionId, |
|
145 TUid::Uid(KIMMusicPluginUid) ); |
|
146 } |
|
147 // Item in a playlist media |
|
148 // |
|
149 else if( cat == EMPXPlaylist && depth == 3 ) |
|
150 { |
|
151 const CMPXMediaArray* plarray = media.Value<CMPXMediaArray>(KMPXMediaArrayContents); |
|
152 TInt selection = aPath.Id(2); |
|
153 TInt count = plarray->Count(); |
|
154 if( selection < count ) |
|
155 { |
|
156 if( (*plarray)[selection]->IsSupported(KMPXMediaFetched) ) |
|
157 { |
|
158 *entries = *(*plarray)[selection]; |
|
159 } |
|
160 else // not fetched yet |
|
161 { |
|
162 // Extract the data |
|
163 const TDesC& uri = (*plarray)[selection]->ValueText( KMPXMediaGeneralUri ); |
|
164 CMPXMedia* metadata = ExtractMetadataL( uri, iAttributes.Array() ); |
|
165 CleanupStack::PushL( metadata ); |
|
166 |
|
167 // Return to client |
|
168 *entries = *metadata; |
|
169 |
|
170 // Save the data |
|
171 *(*plarray)[selection] = *metadata; |
|
172 (*plarray)[selection]->SetTObjectValueL(KMPXMediaFetched, ETrue); |
|
173 |
|
174 CleanupStack::PopAndDestroy( metadata ); |
|
175 } |
|
176 entries->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, |
|
177 TUid::Uid(KIMMusicPluginUid) ); |
|
178 } |
|
179 else |
|
180 { |
|
181 // Bounds check |
|
182 err = KErrArgument; |
|
183 } |
|
184 } |
|
185 // Otherwise, assume it is a song |
|
186 // |
|
187 else // cat == song/image/video/etc |
|
188 { |
|
189 if( media.IsSupported(KMPXMediaFetched) ) |
|
190 { |
|
191 *entries = media; |
|
192 } |
|
193 else |
|
194 { |
|
195 const TDesC& uri = media.ValueText( KMPXMediaGeneralUri ); |
|
196 CMPXMedia* metadata = ExtractMetadataL( uri, iAttributes.Array() ); |
|
197 CleanupStack::PushL( metadata ); |
|
198 // Return to client |
|
199 *entries = *metadata; |
|
200 |
|
201 //Save the data |
|
202 media = *metadata; |
|
203 media.SetTObjectValueL(KMPXMediaFetched, ETrue); |
|
204 |
|
205 CleanupStack::PopAndDestroy( metadata ); |
|
206 } |
|
207 entries->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, |
|
208 TUid::Uid(KIMMusicPluginUid) ); |
|
209 } |
|
210 } |
|
211 break; |
|
212 } |
|
213 default: |
|
214 { |
|
215 // Return Nothing because a MediaL at this depth contains nothing |
|
216 break; |
|
217 } |
|
218 } |
|
219 // Copy Path |
|
220 TMPXAttribute pathAttr(KMPXMediaGeneralPath); |
|
221 for (TInt i=aAttrs.Count();--i>=0;) |
|
222 { |
|
223 if (aAttrs[i]==pathAttr) |
|
224 { |
|
225 entries->SetCObjectValueL(pathAttr, |
|
226 const_cast<CMPXCollectionPath*>(&aPath)); |
|
227 break; |
|
228 } |
|
229 } |
|
230 // Callback to collection client context |
|
231 iObs->HandleMedia( entries, err ); |
|
232 CleanupStack::PopAndDestroy(entries); |
|
233 } |
|
234 |
|
235 // ---------------------------------------------------------------------------------------------------------- |
|
236 // Set all the attributes in CMPXMedia corresponding to KMPXMediaIdDrm |
|
237 // ---------------------------------------------------------------------------------------------------------- |
|
238 // |
|
239 CMPXMedia* CMPXMusicMemoryPlugin::ExtractMetadataL( const TDesC& aUri, |
|
240 const TArray<TMPXAttribute>& aAttrs ) |
|
241 { |
|
242 CMPXMedia* media( NULL ); |
|
243 iMetadataExtractor->CreateMediaL( aUri, media, ETrue ); |
|
244 |
|
245 // Also set drm |
|
246 if( media ) |
|
247 { |
|
248 CleanupStack::PushL( media ); |
|
249 DoSetMediaDrmL( *media, aAttrs, aUri ); |
|
250 CleanupStack::Pop( media ); |
|
251 } |
|
252 return media; // ownership transferred |
|
253 } |
|
254 |
|
255 // ---------------------------------------------------------------------------------------------------------- |
|
256 // Set all the attributes in CMPXMedia corresponding to KMPXMediaIdDrm |
|
257 // ---------------------------------------------------------------------------------------------------------- |
|
258 // |
|
259 void CMPXMusicMemoryPlugin::DoSetMediaDrmL(CMPXMedia& aMedia, |
|
260 const TArray<TMPXAttribute>& aAttrs, |
|
261 const TDesC& aLocation ) |
|
262 { |
|
263 // Gather all DRM attributes |
|
264 TUint aDrmAttributes(0); |
|
265 for( TInt i=0; i<aAttrs.Count(); ++i ) |
|
266 { |
|
267 if( aAttrs[i].ContentId() == KMPXMediaIdDrm ) |
|
268 { |
|
269 aDrmAttributes |= aAttrs[i].AttributeId(); |
|
270 } |
|
271 } |
|
272 |
|
273 iDrmMediaUtility->InitL(aLocation); |
|
274 const CMPXMedia* drmMedia( iDrmMediaUtility->GetMediaL( aDrmAttributes )); |
|
275 |
|
276 // Only get attributes if it's a DRM file |
|
277 if ( drmMedia ) |
|
278 { |
|
279 if ( aDrmAttributes & KMPXMediaDrmType.iAttributeId ) |
|
280 { |
|
281 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
282 EMPXMediaDrmType ); |
|
283 if ( drmMedia->IsSupported( mpxAtt )) |
|
284 { |
|
285 TInt val( *drmMedia->Value<TInt>( mpxAtt )); |
|
286 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
287 } |
|
288 } |
|
289 if ( aDrmAttributes & KMPXMediaDrmRightsStatus.iAttributeId ) |
|
290 { |
|
291 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
292 EMPXMediaDrmRightsStatus ); |
|
293 if ( drmMedia->IsSupported( mpxAtt )) |
|
294 { |
|
295 TInt val( *drmMedia->Value<TInt>( mpxAtt )); |
|
296 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
297 } |
|
298 } |
|
299 if ( aDrmAttributes & KMPXMediaDrmRightsType.iAttributeId ) |
|
300 { |
|
301 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
302 EMPXMediaDrmRightsType ); |
|
303 if ( drmMedia->IsSupported( mpxAtt )) |
|
304 { |
|
305 TInt val( *drmMedia->Value<TInt>( mpxAtt )); |
|
306 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
307 } |
|
308 } |
|
309 if ( aDrmAttributes & KMPXMediaDrmCount.iAttributeId ) |
|
310 { |
|
311 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
312 EMPXMediaDrmCount ); |
|
313 if ( drmMedia->IsSupported( mpxAtt )) |
|
314 { |
|
315 TInt val( *drmMedia->Value<TInt>( mpxAtt )); |
|
316 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
317 } |
|
318 } |
|
319 if ( aDrmAttributes & KMPXMediaDrmProtected.iAttributeId ) |
|
320 { |
|
321 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
322 EMPXMediaDrmProtected ); |
|
323 if ( drmMedia->IsSupported( mpxAtt )) |
|
324 { |
|
325 TBool val( *drmMedia->Value<TBool>( mpxAtt )); |
|
326 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
327 } |
|
328 } |
|
329 if ( aDrmAttributes & KMPXMediaDrmSendingAllowed.iAttributeId ) |
|
330 { |
|
331 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
332 EMPXMediaDrmSendingAllowed ); |
|
333 if ( drmMedia->IsSupported( mpxAtt )) |
|
334 { |
|
335 TBool val( *drmMedia->Value<TBool>( mpxAtt )); |
|
336 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
337 } |
|
338 } |
|
339 if ( aDrmAttributes & KMPXMediaDrmCanSetAutomated.iAttributeId ) |
|
340 { |
|
341 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
342 EMPXMediaDrmCanSetAutomated ); |
|
343 if ( drmMedia->IsSupported( mpxAtt )) |
|
344 { |
|
345 TBool val( *drmMedia->Value<TBool>( mpxAtt )); |
|
346 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
347 } |
|
348 } |
|
349 if ( aDrmAttributes & KMPXMediaDrmHasInfoUrl.iAttributeId ) |
|
350 { |
|
351 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
352 EMPXMediaDrmHasInfoUrl ); |
|
353 if ( drmMedia->IsSupported( mpxAtt )) |
|
354 { |
|
355 TBool val( *drmMedia->Value<TBool>( mpxAtt )); |
|
356 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
357 } |
|
358 } |
|
359 if ( aDrmAttributes & KMPXMediaDrmHasPreviewUrl.iAttributeId ) |
|
360 { |
|
361 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
362 EMPXMediaDrmHasPreviewUrl ); |
|
363 if ( drmMedia->IsSupported( mpxAtt )) |
|
364 { |
|
365 TBool val( *drmMedia->Value<TBool>( mpxAtt )); |
|
366 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
367 } |
|
368 } |
|
369 if ( aDrmAttributes & KMPXMediaDrmAboutToExpire.iAttributeId ) |
|
370 { |
|
371 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
372 EMPXMediaDrmAboutToExpire ); |
|
373 if ( drmMedia->IsSupported( mpxAtt )) |
|
374 { |
|
375 TBool val( *drmMedia->Value<TBool>( mpxAtt )); |
|
376 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
377 } |
|
378 } |
|
379 if ( aDrmAttributes & KMPXMediaDrmStartTime.iAttributeId ) |
|
380 { |
|
381 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
382 EMPXMediaDrmStartTime ); |
|
383 if ( drmMedia->IsSupported( mpxAtt )) |
|
384 { |
|
385 TInt64 val( *drmMedia->Value<TInt64>( mpxAtt )); |
|
386 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
387 } |
|
388 } |
|
389 if ( aDrmAttributes & KMPXMediaDrmEndTime.iAttributeId ) |
|
390 { |
|
391 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
392 EMPXMediaDrmEndTime ); |
|
393 if ( drmMedia->IsSupported( mpxAtt )) |
|
394 { |
|
395 TInt64 val( *drmMedia->Value<TInt64>( mpxAtt )); |
|
396 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
397 } |
|
398 } |
|
399 if ( aDrmAttributes & KMPXMediaDrmIntervalStartTime.iAttributeId ) |
|
400 { |
|
401 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
402 EMPXMediaDrmIntervalStartTime ); |
|
403 if ( drmMedia->IsSupported( mpxAtt )) |
|
404 { |
|
405 TInt64 val( *drmMedia->Value<TInt64>( mpxAtt )); |
|
406 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
407 } |
|
408 } |
|
409 if ( aDrmAttributes & KMPXMediaDrmAccumulatedTime.iAttributeId ) |
|
410 { |
|
411 TMPXAttribute mpxAtt( KMPXMediaIdDrm, |
|
412 EMPXMediaDrmAccumulatedTime ); |
|
413 if ( drmMedia->IsSupported( mpxAtt )) |
|
414 { |
|
415 TInt64 val( *drmMedia->Value<TInt64>( mpxAtt )); |
|
416 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
417 } |
|
418 } |
|
419 if ( aDrmAttributes & KMPXMediaDrmInterval.iAttributeId ) |
|
420 { |
|
421 TMPXAttribute mpxAtt( KMPXMediaIdDrm, EMPXMediaDrmInterval ); |
|
422 if ( drmMedia->IsSupported( mpxAtt )) |
|
423 { |
|
424 TTimeIntervalSeconds val( |
|
425 *drmMedia->Value<TTimeIntervalSeconds>( mpxAtt )); |
|
426 aMedia.SetTObjectValueL( mpxAtt, val ); |
|
427 } |
|
428 } |
|
429 } |
|
430 iDrmMediaUtility->Close(); |
|
431 } |
|
432 // END OF FILE |