|
1 /* |
|
2 * Copyright (c) 2002-2005 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 the License "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: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 |
|
21 #include "BavpNPObject.h" |
|
22 #include "BavpLogger.h" |
|
23 |
|
24 #include <badesca.h> |
|
25 #include <stdlib.h> |
|
26 #include <string.h> |
|
27 #include <npscript.h> |
|
28 |
|
29 #include "BavpPlugin.h" |
|
30 #include "BavpController.h" |
|
31 #include "BavpControllerVideo.h" |
|
32 #include "BavpControllerAudio.h" |
|
33 |
|
34 |
|
35 const int NUM_METHOD_IDENTIFIERS = 5; |
|
36 const int ID_PLAY = 0; |
|
37 const int ID_STOP = 1; |
|
38 const int ID_PAUSE = 2; |
|
39 const int ID_FASTFORWARD = 3; |
|
40 const int ID_REWIND = 4; |
|
41 static NPIdentifier bavpMethodIdentifiers[NUM_METHOD_IDENTIFIERS]; |
|
42 static const NPUTF8 *bavpIdentifierNames[NUM_METHOD_IDENTIFIERS] = { |
|
43 "play", |
|
44 "stop", |
|
45 "pause", |
|
46 "fastforward", |
|
47 "rewind", |
|
48 }; |
|
49 |
|
50 const int NUM_PROPERTY_IDENTIFIERS = 10; |
|
51 const int ID_VOLUME = 0; |
|
52 const int ID_POSITION = 1; |
|
53 const int ID_DURATION = 2; |
|
54 const int ID_STATE_CHANGED_CALLBACK = 3; |
|
55 const int ID_STATE = 4; |
|
56 const int ID_ISVIDEOCLIP = 5; |
|
57 const int ID_ISSEEKABLE = 6; |
|
58 const int ID_CLIPNAME = 7; |
|
59 const int ID_FULLSCREENMODE = 8; |
|
60 const int ID_MIMETYPE = 9; |
|
61 static NPIdentifier bavpPropertyIdentifiers[NUM_PROPERTY_IDENTIFIERS]; |
|
62 static const NPUTF8 *bavpPropertyIdentifierNames[NUM_PROPERTY_IDENTIFIERS] = { |
|
63 "volume", |
|
64 "position", |
|
65 "duration", |
|
66 "statechangedcallback", |
|
67 "state", |
|
68 "isvideoclip", |
|
69 "isseekable", |
|
70 "clipname", |
|
71 "fullscreenmode", |
|
72 "mimetype", |
|
73 }; |
|
74 |
|
75 static bool _initializedIdentifiers = false; |
|
76 static void initializeIdentifiers() |
|
77 { |
|
78 if (!_initializedIdentifiers) { |
|
79 _initializedIdentifiers = true; |
|
80 NPN_GetStringIdentifiers (bavpPropertyIdentifierNames, NUM_PROPERTY_IDENTIFIERS, bavpPropertyIdentifiers); |
|
81 NPN_GetStringIdentifiers (bavpIdentifierNames, NUM_METHOD_IDENTIFIERS, bavpMethodIdentifiers); |
|
82 } |
|
83 }; |
|
84 |
|
85 |
|
86 _LIT8(KNone,"None"); |
|
87 _LIT8(KBuffering,"Buffering"); |
|
88 _LIT8(KPlaying,"Playing"); |
|
89 _LIT8(KPlayComplete,"Playcomplete"); |
|
90 _LIT8(KStopped,"Stopped"); |
|
91 _LIT8(KPaused,"Paused"); |
|
92 _LIT8(KBadContent,"Badcontent"); |
|
93 _LIT8(KFastForwarding,"Fastforwarding"); |
|
94 _LIT8(KFFComplete,"Fastforward complete"); |
|
95 _LIT8(KRewinding,"Rewinding"); |
|
96 _LIT8(KRewindComplete,"Rewinding complete"); |
|
97 _LIT8(KInvalidState,"Invalid State"); |
|
98 |
|
99 |
|
100 static const TPtrC8 getState(int state) |
|
101 { |
|
102 TPtrC8 ret; |
|
103 |
|
104 switch (state) |
|
105 { |
|
106 case EBavpNone: |
|
107 ret.Set(KNone); |
|
108 break; |
|
109 |
|
110 case EBavpBuffering: |
|
111 ret.Set(KBuffering); |
|
112 break; |
|
113 |
|
114 case EBavpPlaying: |
|
115 ret.Set(KPlaying); |
|
116 break; |
|
117 |
|
118 case EBavpPlayComplete: |
|
119 ret.Set(KPlayComplete); |
|
120 break; |
|
121 |
|
122 case EBavpStopped: |
|
123 ret.Set(KStopped); |
|
124 break; |
|
125 |
|
126 case EBavpPaused: |
|
127 ret.Set(KPaused); |
|
128 break; |
|
129 |
|
130 case EBavpBadContent: |
|
131 ret.Set(KBadContent); |
|
132 break; |
|
133 |
|
134 case EBavpFastForwarding: |
|
135 ret.Set(KFastForwarding); |
|
136 break; |
|
137 |
|
138 case EBavpFastForwardComplete: |
|
139 ret.Set(KFFComplete); |
|
140 break; |
|
141 |
|
142 case EBavpRewinding: |
|
143 ret.Set(KRewinding); |
|
144 break; |
|
145 |
|
146 case EBavpRewindComplete: |
|
147 ret.Set(KRewindComplete); |
|
148 break; |
|
149 |
|
150 default: |
|
151 ret.Set(KInvalidState); |
|
152 break; |
|
153 } |
|
154 return ret; |
|
155 } |
|
156 |
|
157 static void reportVolumeResults(int vol,CBavpController *ctlr) |
|
158 { |
|
159 Log(ETrue,_L("SetProperty: Volume")); |
|
160 |
|
161 TInt setvol = ctlr->GetPlayerVolume(); |
|
162 Log(ETrue,_L("Requested volume: "), vol); |
|
163 Log(ETrue,_L("Volume set to: "),setvol); |
|
164 |
|
165 |
|
166 if ( setvol == vol || setvol == KCRVolumeMax || setvol == KCRVolume0 ) |
|
167 { |
|
168 Log(ETrue,_L("Result: Passed")); |
|
169 } |
|
170 else |
|
171 { |
|
172 Log(ETrue,_L("Result: Failed")); |
|
173 } |
|
174 } |
|
175 |
|
176 static void reportPositionResultsL(int pos, CBavpController *ctlr) |
|
177 { |
|
178 Log(ETrue,_L("SetProperty: Position")); |
|
179 |
|
180 if ( !(ctlr->IsClipSeekable()) && !(ctlr->IsClipLocalMedia()) ) |
|
181 { |
|
182 Log(ETrue,_L("Cannot set position for non-seekable and non-local media content")); |
|
183 return; |
|
184 } |
|
185 |
|
186 TTimeIntervalMicroSeconds ms = ctlr->getPositionL(); |
|
187 TTimeIntervalMicroSeconds durationms = ctlr->Duration(); |
|
188 |
|
189 int setpos = (int)ms.Int64(); |
|
190 int duration = (int)durationms.Int64(); |
|
191 |
|
192 Log(ETrue,_L("Requested position: "), pos); |
|
193 Log(ETrue,_L("Position set to: "),setpos); |
|
194 |
|
195 if ( setpos == pos || setpos == duration || setpos == 0) |
|
196 { |
|
197 Log(ETrue,_L("Result: Passed")); |
|
198 } |
|
199 else |
|
200 { |
|
201 Log(ETrue,_L("Result: Failed")); |
|
202 } |
|
203 } |
|
204 |
|
205 static void reportPlayResultsL(int initState, CBavpController *ctlr) |
|
206 { |
|
207 if ( ctlr->IsClipVideo()) |
|
208 { |
|
209 TPtrC8 expectedState = getState(EBavpPlaying); |
|
210 TPtrC8 expectedState2 = getState(EBavpBuffering); |
|
211 TPtrC8 actualState = getState(ctlr->State()); |
|
212 |
|
213 if ( initState == EBavpStopped || |
|
214 initState == EBavpPlayComplete || |
|
215 initState == EBavpRewindComplete || |
|
216 initState == EBavpFastForwardComplete || |
|
217 initState == EBavpBadContent) |
|
218 { |
|
219 TTimeIntervalMicroSeconds ms = ctlr->getPositionL(); |
|
220 int actualpos = (int)ms.Int64(); |
|
221 |
|
222 Log(ETrue,_L("Expected Position: "), 0); |
|
223 Log(ETrue,_L("Actual Position: "),actualpos); |
|
224 |
|
225 if ( actualpos != 0) |
|
226 { |
|
227 Log(ETrue,_L("Result: Position test failed")); |
|
228 } |
|
229 else |
|
230 { |
|
231 Log(ETrue,_L("Result:Position test passed")); |
|
232 } |
|
233 } |
|
234 |
|
235 if ( ctlr->IsClipOnDemand() && initState == EBavpStopped ) |
|
236 { |
|
237 Log(ETrue,_L8("Expected State: "), expectedState2); |
|
238 Log(ETrue,_L8("Actual State: "), actualState); |
|
239 } |
|
240 else |
|
241 { |
|
242 Log(ETrue,_L8("Expected State: "), expectedState); |
|
243 Log(ETrue,_L8("Actual State: "), actualState); |
|
244 } |
|
245 |
|
246 if ( actualState.Compare(expectedState) != 0 && actualState.Compare(expectedState2) != 0) |
|
247 { |
|
248 Log(ETrue,_L("Result: State test failed")); |
|
249 } |
|
250 else |
|
251 { |
|
252 Log(ETrue,_L("Result: State test passed")); |
|
253 } |
|
254 } |
|
255 else |
|
256 { |
|
257 TPtrC8 expectedState = getState(EBavpPlaying); |
|
258 TPtrC8 actualState = getState(ctlr->State()); |
|
259 |
|
260 Log(ETrue,_L8("Expected State: "), expectedState); |
|
261 Log(ETrue,_L8("Actual State: "), actualState); |
|
262 |
|
263 if ( expectedState.Compare(actualState) != 0) |
|
264 { |
|
265 Log(ETrue,_L("Result: Failed")); |
|
266 } |
|
267 else |
|
268 { |
|
269 Log(ETrue,_L("Result: Passed")); |
|
270 } |
|
271 } |
|
272 } |
|
273 |
|
274 static void reportStopResultsL(CBavpController *ctlr) |
|
275 { |
|
276 TPtrC8 expectedState = getState(EBavpStopped); |
|
277 TPtrC8 actualState = getState(ctlr->State()); |
|
278 TTimeIntervalMicroSeconds ms = ctlr->getPositionL(); |
|
279 int position = (int)ms.Int64(); |
|
280 |
|
281 Log(ETrue,_L8("Expected State: "), expectedState); |
|
282 Log(ETrue,_L8("Actual State: "), actualState); |
|
283 Log(ETrue,_L("Current Position: "), position); |
|
284 |
|
285 if ( (position != 0) || (expectedState.Compare(actualState) != 0) ) |
|
286 { |
|
287 Log(ETrue,_L("Result: Failed")); |
|
288 } |
|
289 else |
|
290 { |
|
291 Log(ETrue,_L("Result: Passed")); |
|
292 } |
|
293 } |
|
294 |
|
295 static void reportRewindResults(CBavpController *ctlr) |
|
296 { |
|
297 if ( ctlr->IsClipVideo() ) |
|
298 { |
|
299 if ( !(ctlr->IsClipSeekable()) && !(ctlr->IsClipLocalMedia()) ) |
|
300 { |
|
301 Log(ETrue,_L("Result: Rewind is not applicable to non-seekable and non-local media content")); |
|
302 } |
|
303 else |
|
304 { |
|
305 TPtrC8 expectedState = getState(EBavpRewinding); |
|
306 TPtrC8 expectedState2 = getState(EBavpRewindComplete); |
|
307 TPtrC8 actualState = getState(ctlr->State()); |
|
308 |
|
309 Log(ETrue,_L8("Expected State: "), expectedState); |
|
310 Log(ETrue,_L8("Actual State: "), actualState); |
|
311 |
|
312 if ( (expectedState.Compare(actualState) != 0) && (expectedState2.Compare(actualState) != 0) ) |
|
313 { |
|
314 Log(ETrue,_L("Result: Failed")); |
|
315 } |
|
316 else |
|
317 { |
|
318 Log(ETrue,_L("Result: Passed")); |
|
319 } |
|
320 } |
|
321 } |
|
322 else |
|
323 { |
|
324 Log(ETrue,_L("Result: Rewind is not applicable to Audio")); |
|
325 } |
|
326 |
|
327 } |
|
328 |
|
329 static void reportFFResults(CBavpController *ctlr) |
|
330 { |
|
331 if ( ctlr->IsClipVideo() ) |
|
332 { |
|
333 if ( !(ctlr->IsClipSeekable()) && !(ctlr->IsClipLocalMedia()) ) |
|
334 { |
|
335 Log(ETrue,_L("Result: Fastforward is not applicable to non-seekable and non-local media content")); |
|
336 } |
|
337 else |
|
338 { |
|
339 TPtrC8 expectedState = getState(EBavpFastForwarding); |
|
340 TPtrC8 expectedState2 = getState(EBavpFastForwardComplete); |
|
341 TPtrC8 actualState = getState(ctlr->State()); |
|
342 |
|
343 Log(ETrue,_L8("Expected State: "), expectedState); |
|
344 Log(ETrue,_L8("Actual State: "), actualState); |
|
345 |
|
346 if ( (expectedState.Compare(actualState) != 0) && (expectedState2.Compare(actualState) != 0) ) |
|
347 { |
|
348 Log(ETrue,_L("Result: Failed")); |
|
349 } |
|
350 else |
|
351 { |
|
352 Log(ETrue,_L("Result: Passed")); |
|
353 } |
|
354 } |
|
355 } |
|
356 else |
|
357 { |
|
358 Log(ETrue,_L("Result: Fastforward is not applicable to Audio")); |
|
359 } |
|
360 |
|
361 } |
|
362 |
|
363 static void reportPauseResultsL(CBavpController *ctlr) |
|
364 { |
|
365 TBool seekablevideo = (ctlr->IsClipSeekable() && ctlr->IsClipVideo()); |
|
366 TBool seekableaudio = (ctlr->IsClipSeekable() && !ctlr->IsClipVideo() |
|
367 && (ctlr->State() == EBavpPaused || ctlr->State() == EBavpPlaying)); |
|
368 |
|
369 if ( seekablevideo || seekableaudio ) |
|
370 { |
|
371 TPtrC8 expectedState = getState(EBavpPaused); |
|
372 TPtrC8 actualState = getState(ctlr->State()); |
|
373 |
|
374 Log(ETrue,_L8("Expected State: "), expectedState); |
|
375 Log(ETrue,_L8("Actual State: "), actualState); |
|
376 |
|
377 if ( (expectedState.Compare(actualState) != 0) ) |
|
378 { |
|
379 Log(ETrue,_L("Result: Failed")); |
|
380 } |
|
381 else |
|
382 { |
|
383 Log(ETrue,_L("Result: Passed")); |
|
384 } |
|
385 |
|
386 } |
|
387 else |
|
388 { |
|
389 reportStopResultsL(ctlr); |
|
390 } |
|
391 } |
|
392 |
|
393 static void BavpDesToNpvariant(TPtrC& string, NPVariant*& variant) |
|
394 { |
|
395 char* newString = NULL; |
|
396 if (string.Length()) { |
|
397 newString = new char[string.Length()]; |
|
398 } |
|
399 if (newString) { |
|
400 TPtr8 newStringPtr((unsigned char*)newString, 0, string.Length()); |
|
401 newStringPtr.Copy(string); |
|
402 STRINGN_TO_NPVARIANT(newString, string.Length(), *variant); |
|
403 } |
|
404 } |
|
405 |
|
406 static void BavpDesToNpvariant(TPtrC8& string, NPVariant*& variant) |
|
407 { |
|
408 char* newString = NULL; |
|
409 if (string.Length()) { |
|
410 newString = new char[string.Length()]; |
|
411 } |
|
412 if (newString) { |
|
413 Mem::Copy(newString, string.Ptr(), string.Length()); |
|
414 STRINGN_TO_NPVARIANT(newString, string.Length(), *variant); |
|
415 } |
|
416 } |
|
417 |
|
418 NPObject *BavpAllocate () |
|
419 { |
|
420 BavpNPObject *newInstance = (BavpNPObject *)User::AllocZ (sizeof(BavpNPObject)); |
|
421 |
|
422 return (NPObject *)newInstance; |
|
423 } |
|
424 |
|
425 void BavpInvalidate () |
|
426 { |
|
427 // Make sure we've released any remainging references to JavaScript |
|
428 // objects. |
|
429 } |
|
430 |
|
431 void BavpDeallocate (BavpNPObject *obj) |
|
432 { |
|
433 if (obj->stateChangedCallback) |
|
434 NPN_ReleaseObject((struct NPObject*)obj->stateChangedCallback); |
|
435 User::Free ((void *)obj); |
|
436 } |
|
437 |
|
438 bool BavpHasMethod(BavpNPObject */*obj*/, NPIdentifier name) |
|
439 { |
|
440 int i; |
|
441 for (i = 0; i < NUM_METHOD_IDENTIFIERS; i++) { |
|
442 if (name == bavpMethodIdentifiers[i]){ |
|
443 return true; |
|
444 } |
|
445 } |
|
446 return false; |
|
447 } |
|
448 |
|
449 |
|
450 bool BavpInvokeL(BavpNPObject *obj, NPIdentifier name, const NPVariant */* args */, uint32_t /* argCount */, NPVariant *result) |
|
451 { |
|
452 if (!obj->plugin) { |
|
453 NULL_TO_NPVARIANT(*result); |
|
454 return true; |
|
455 } |
|
456 |
|
457 CBavpController *ctlr = obj->plugin->Controller(); |
|
458 |
|
459 if (!ctlr) |
|
460 { |
|
461 NULL_TO_NPVARIANT(*result); |
|
462 return true; |
|
463 } |
|
464 |
|
465 int initState = ctlr->State(); |
|
466 Log( ETrue, _L("\n")); |
|
467 Log( ETrue, _L8("Initial state:"), getState(initState)); |
|
468 |
|
469 if (name == bavpMethodIdentifiers[ID_PLAY]) |
|
470 { |
|
471 Log( ETrue, _L("Method Invoked: Play")); |
|
472 if ( ctlr->State() != EBavpPlaying ) |
|
473 { |
|
474 ctlr->PlayL(); |
|
475 } |
|
476 VOID_TO_NPVARIANT(*result); |
|
477 reportPlayResultsL(initState,ctlr); |
|
478 } |
|
479 else if (name == bavpMethodIdentifiers[ID_STOP]) |
|
480 { |
|
481 Log( ETrue, _L("Method Invoked: Stop")); |
|
482 if ( ctlr->State() != EBavpStopped ) |
|
483 { |
|
484 ctlr->Stop(); |
|
485 } |
|
486 VOID_TO_NPVARIANT(*result); |
|
487 reportStopResultsL(ctlr); |
|
488 } |
|
489 else if (name == bavpMethodIdentifiers[ID_PAUSE]) |
|
490 { |
|
491 Log( ETrue, _L("Method Invoked: Pause")); |
|
492 if ( ctlr->State() != EBavpPaused ) |
|
493 { |
|
494 ctlr->PauseL(); |
|
495 } |
|
496 VOID_TO_NPVARIANT(*result); |
|
497 reportPauseResultsL(ctlr); |
|
498 } |
|
499 else if (name == bavpMethodIdentifiers[ID_FASTFORWARD]) |
|
500 { |
|
501 Log( ETrue, _L("Method Invoked: FastForward")); |
|
502 if ( ctlr->State() == EBavpRewinding ) |
|
503 { |
|
504 ctlr->PauseL(); |
|
505 } |
|
506 |
|
507 if ( ctlr->State() != EBavpFastForwarding ) |
|
508 { |
|
509 ctlr->FastForwardL(); |
|
510 } |
|
511 VOID_TO_NPVARIANT(*result); |
|
512 reportFFResults(ctlr); |
|
513 } |
|
514 else if (name == bavpMethodIdentifiers[ID_REWIND]) |
|
515 { |
|
516 Log( ETrue, _L("Method Invoked: Rewind")); |
|
517 if ( ctlr->State() == EBavpFastForwarding ) |
|
518 { |
|
519 ctlr->PauseL(); |
|
520 } |
|
521 |
|
522 if ( ctlr->State() != EBavpRewinding ) |
|
523 { |
|
524 ctlr->RewindL(); |
|
525 } |
|
526 VOID_TO_NPVARIANT(*result); |
|
527 reportRewindResults(ctlr); |
|
528 } |
|
529 else |
|
530 { |
|
531 Log( ETrue, _L("Unknown method invoked")); |
|
532 return false; |
|
533 } |
|
534 |
|
535 return true; |
|
536 } |
|
537 |
|
538 bool BavpHasProperty(BavpNPObject */*obj*/, NPIdentifier name) |
|
539 { |
|
540 int i; |
|
541 for (i = 0; i < NUM_PROPERTY_IDENTIFIERS; i++) |
|
542 { |
|
543 if (name == bavpPropertyIdentifiers[i]){ |
|
544 return true; |
|
545 } |
|
546 } |
|
547 return false; |
|
548 } |
|
549 |
|
550 bool BavpGetPropertyL (BavpNPObject *obj, NPIdentifier name, NPVariant *variant) |
|
551 { |
|
552 if (!obj->plugin || !(obj->plugin->Controller())){ |
|
553 NULL_TO_NPVARIANT(*variant); |
|
554 return false; |
|
555 } |
|
556 |
|
557 |
|
558 if (name == bavpPropertyIdentifiers[ID_VOLUME]) |
|
559 { |
|
560 INT32_TO_NPVARIANT(obj->plugin->Controller()->GetPlayerVolume(), *variant); |
|
561 } |
|
562 |
|
563 else if (name == bavpPropertyIdentifiers[ID_POSITION]) |
|
564 { |
|
565 TTimeIntervalMicroSeconds ms = obj->plugin->Controller()->getPositionL(); |
|
566 int time = (int)ms.Int64(); |
|
567 INT32_TO_NPVARIANT(time, *variant); |
|
568 |
|
569 } |
|
570 |
|
571 else if (name == bavpPropertyIdentifiers[ID_DURATION]) |
|
572 { |
|
573 TTimeIntervalMicroSeconds ms = obj->plugin->Controller()->Duration(); |
|
574 int time = (int)ms.Int64(); |
|
575 INT32_TO_NPVARIANT(time, *variant); |
|
576 } |
|
577 |
|
578 else if (name == bavpPropertyIdentifiers[ID_STATE_CHANGED_CALLBACK]) |
|
579 { |
|
580 if (obj->stateChangedCallback) |
|
581 OBJECT_TO_NPVARIANT(obj->stateChangedCallback, *variant); |
|
582 else |
|
583 NULL_TO_NPVARIANT(*variant); |
|
584 } |
|
585 else if (name == bavpPropertyIdentifiers[ID_STATE]) |
|
586 { |
|
587 TPtrC8 state = getState((TInt)(obj->plugin->Controller()->State())); |
|
588 BavpDesToNpvariant(state, variant); |
|
589 } |
|
590 else if (name == bavpPropertyIdentifiers[ID_ISVIDEOCLIP]) |
|
591 { |
|
592 BOOLEAN_TO_NPVARIANT(obj->plugin->Controller()->IsClipVideo(), *variant); |
|
593 } |
|
594 else if (name == bavpPropertyIdentifiers[ID_ISSEEKABLE]) |
|
595 { |
|
596 BOOLEAN_TO_NPVARIANT(obj->plugin->Controller()->IsClipSeekable(), *variant); |
|
597 } |
|
598 else if (name == bavpPropertyIdentifiers[ID_CLIPNAME]) |
|
599 { |
|
600 const HBufC& name = obj->plugin->Controller()->ClipName(); |
|
601 |
|
602 TInt lastSlashPos = name.LocateReverse( '/' ); |
|
603 //retrieve the clip name |
|
604 if( lastSlashPos == KErrNotFound ) { |
|
605 lastSlashPos = 0; |
|
606 } |
|
607 |
|
608 TInt len = name.Length()-lastSlashPos-1; |
|
609 TPtrC namePtr( name.Right(len)); |
|
610 BavpDesToNpvariant(namePtr, variant); |
|
611 } |
|
612 else if (name == bavpPropertyIdentifiers[ID_FULLSCREENMODE]) |
|
613 { |
|
614 BOOLEAN_TO_NPVARIANT(obj->plugin->Controller()->IsClipFullScreen(), *variant); |
|
615 } |
|
616 else if (name == bavpPropertyIdentifiers[ID_MIMETYPE]) |
|
617 { |
|
618 const HBufC8& name = obj->plugin->Controller()->MimeType(); |
|
619 TPtrC8 namePtr(name); |
|
620 BavpDesToNpvariant(namePtr, variant); |
|
621 } |
|
622 else |
|
623 { |
|
624 return false; |
|
625 } |
|
626 |
|
627 return true; |
|
628 |
|
629 } |
|
630 |
|
631 |
|
632 bool BavpSetPropertyL (BavpNPObject *obj, NPIdentifier name, NPVariant *variant) |
|
633 { |
|
634 if (!obj->plugin) |
|
635 return false; |
|
636 |
|
637 CBavpController *ctlr = obj->plugin->Controller(); |
|
638 |
|
639 if (!ctlr) |
|
640 return false; |
|
641 |
|
642 Log(ETrue,_L("\n")); |
|
643 |
|
644 if (name == bavpPropertyIdentifiers[ID_VOLUME]) |
|
645 { |
|
646 int vol = 0; |
|
647 |
|
648 if (NPVARIANT_IS_DOUBLE(*variant)) |
|
649 vol = (int)NPVARIANT_TO_DOUBLE(*variant); |
|
650 else if (NPVARIANT_IS_INT32(*variant)) |
|
651 vol = NPVARIANT_TO_INT32(*variant); |
|
652 else |
|
653 { |
|
654 Log(ETrue,_L("SetProperty: Not a valid value for volume")); |
|
655 return false; |
|
656 } |
|
657 |
|
658 ctlr->SetPlayerVolume(vol); |
|
659 reportVolumeResults(vol,ctlr); |
|
660 } |
|
661 |
|
662 else if (name == bavpPropertyIdentifiers[ID_POSITION]) |
|
663 { |
|
664 int pos = 0; |
|
665 |
|
666 if (NPVARIANT_IS_DOUBLE(*variant)) |
|
667 pos = (int)NPVARIANT_TO_DOUBLE(*variant); |
|
668 else if (NPVARIANT_IS_INT32(*variant)) |
|
669 pos = NPVARIANT_TO_INT32(*variant); |
|
670 else |
|
671 { |
|
672 Log(ETrue,_L("SetProperty: Not a valid value for position")); |
|
673 return false; |
|
674 } |
|
675 |
|
676 TInt64 ms(pos); |
|
677 CBavpController *ctlr = obj->plugin->Controller(); |
|
678 int state = ctlr->State(); |
|
679 |
|
680 if ( state != EBavpRewinding && state != EBavpFastForwarding ) |
|
681 { |
|
682 ctlr->setPositionL(TTimeIntervalMicroSeconds(ms)); |
|
683 } |
|
684 else |
|
685 { |
|
686 ctlr->Stop(); |
|
687 ctlr->setPositionL(TTimeIntervalMicroSeconds(ms)); |
|
688 } |
|
689 |
|
690 reportPositionResultsL(pos,ctlr); |
|
691 } |
|
692 |
|
693 else if (name == bavpPropertyIdentifiers[ID_STATE_CHANGED_CALLBACK]) |
|
694 { |
|
695 //int count = 0; |
|
696 if (NPVARIANT_IS_NULL(*variant)) |
|
697 { |
|
698 if (obj->stateChangedCallback) |
|
699 { |
|
700 NPN_ReleaseObject((struct NPObject*)obj->stateChangedCallback); |
|
701 obj->stateChangedCallback = 0; |
|
702 } |
|
703 } |
|
704 else if (NPVARIANT_IS_OBJECT(*variant)) |
|
705 { |
|
706 NPObject* callback = NPVARIANT_TO_OBJECT(*variant); |
|
707 if (obj->stateChangedCallback) |
|
708 { |
|
709 NPN_ReleaseObject((struct NPObject*)obj->stateChangedCallback); |
|
710 obj->stateChangedCallback = 0; |
|
711 } |
|
712 NPN_RetainObject((struct NPObject*)callback); |
|
713 obj->stateChangedCallback = callback; |
|
714 } |
|
715 return true; |
|
716 } |
|
717 |
|
718 else if (name == bavpPropertyIdentifiers[ID_FULLSCREENMODE]) |
|
719 { |
|
720 int pos = 0; |
|
721 TBool newmode, needtochange; |
|
722 CBavpController *ctlr = obj->plugin->Controller(); |
|
723 |
|
724 if ( !(ctlr->IsClipVideo()) ) |
|
725 { |
|
726 Log(ETrue,_L("Fullscreenmode not applicable for audio")); |
|
727 return false; |
|
728 } |
|
729 |
|
730 if (NPVARIANT_IS_INT32(*variant)) |
|
731 { |
|
732 pos = NPVARIANT_TO_INT32(*variant); |
|
733 } |
|
734 else if (NPVARIANT_IS_DOUBLE(*variant)) |
|
735 { |
|
736 pos = (int)NPVARIANT_TO_DOUBLE(*variant); |
|
737 } |
|
738 else if (NPVARIANT_IS_BOOLEAN(*variant)) |
|
739 { |
|
740 pos = NPVARIANT_TO_BOOLEAN(*variant) ? 1 : 0; |
|
741 } |
|
742 |
|
743 else |
|
744 { |
|
745 Log(ETrue,_L("SetProperty: Not a valid value for fullscreenmode")); |
|
746 return false; |
|
747 } |
|
748 |
|
749 Log(ETrue,_L("SetProperty: Fullscreenmode")); |
|
750 |
|
751 newmode = (pos == 1); |
|
752 needtochange = (ctlr->IsClipFullScreen() != newmode); |
|
753 |
|
754 if ( ctlr->IsClipFullScreen() ) |
|
755 { |
|
756 Log(ETrue,_L("Current mode: Fullscreen")); |
|
757 } |
|
758 else |
|
759 { |
|
760 Log(ETrue,_L("Current mode: Normalscreen")); |
|
761 } |
|
762 |
|
763 if ( newmode ) |
|
764 { |
|
765 Log(ETrue,_L("Requested mode: Fullscreen")); |
|
766 } |
|
767 else |
|
768 { |
|
769 Log(ETrue,_L("Requested mode: Normalscreen")); |
|
770 } |
|
771 |
|
772 |
|
773 if ( !needtochange ) |
|
774 { |
|
775 Log(ETrue,_L("No need for mode change")); |
|
776 return false; |
|
777 } |
|
778 |
|
779 ((CBavpControllerVideo *)ctlr)->HandleCommandL(EBavpCmdPlayFullScreen); |
|
780 } |
|
781 else |
|
782 { |
|
783 return false; |
|
784 } |
|
785 |
|
786 return true; |
|
787 } |
|
788 |
|
789 |
|
790 static NPClass _BavpNPClass = { |
|
791 0, |
|
792 (NPAllocateFunctionPtr) BavpAllocate, |
|
793 (NPDeallocateFunctionPtr) BavpDeallocate, |
|
794 (NPInvalidateFunctionPtr) BavpInvalidate, |
|
795 (NPHasMethodFunctionPtr) BavpHasMethod, |
|
796 (NPInvokeFunctionPtr) BavpInvokeL, |
|
797 (NPInvokeDefaultFunctionPtr) 0, |
|
798 (NPHasPropertyFunctionPtr) BavpHasProperty, |
|
799 (NPGetPropertyFunctionPtr) BavpGetPropertyL, |
|
800 (NPSetPropertyFunctionPtr) BavpSetPropertyL, |
|
801 (NPRemovePropertyFunctionPtr) 0 |
|
802 }; |
|
803 static NPClass *BavpNPClass = &_BavpNPClass; |
|
804 |
|
805 |
|
806 BavpNPObject* BavpNPObject_new(NPP instance) |
|
807 { |
|
808 initializeIdentifiers(); |
|
809 BavpNPObject *self = (BavpNPObject *)NPN_CreateObject (instance, BavpNPClass); |
|
810 return self; |
|
811 } |
|
812 |
|
813 void BavpNPObject_stateChanged(BavpNPObject* obj, char* state) |
|
814 { |
|
815 if (!obj || !obj->stateChangedCallback) |
|
816 return; |
|
817 NPVariant arg; |
|
818 NPVariant res; |
|
819 STRINGZ_TO_NPVARIANT(state, arg); |
|
820 NPN_InvokeDefault(obj->nppInstance, obj->stateChangedCallback, &arg, 1, &res); |
|
821 } |