125 } |
124 } |
126 |
125 |
127 return translatedActions; |
126 return translatedActions; |
128 } |
127 } |
129 |
128 |
|
129 QList<PhoneAction *> PhoneUiCommandController::toolBarActions( |
|
130 int resourceId, |
|
131 QMap<int,int> callStates, |
|
132 QMap<int,int> serviceIds, |
|
133 int serviceId, |
|
134 int callId) |
|
135 { |
|
136 QList<PhoneAction *> actions; |
|
137 |
|
138 //Set tool bar button flags |
|
139 setJoinFlag(callStates, serviceIds); |
|
140 setConferenceFlag(callStates.values()); |
|
141 setHoldFlag(callStates.value(callId)); |
|
142 setMultiCallFlag(callStates.values()); |
|
143 setOutgoingFlag(callStates.values()); |
|
144 |
|
145 //Get tool bar item list by resource id. |
|
146 QList<PhoneAction::ToolBarItem> commands = PhoneResourceAdapter::Instance()-> |
|
147 convertToToolBarCommandList(resourceId); |
|
148 |
|
149 if (serviceId != -1) { |
|
150 PhoneCommandExtensionWrapper *extension = commandExtension(serviceId); |
|
151 |
|
152 if (extension) { |
|
153 QList<XQTelUiCommandExtension::CallInfo> callInfo; |
|
154 extension->getCallInfoList( |
|
155 callInfo,callStates,serviceIds,callId); |
|
156 |
|
157 QList<XQTelUiCommandExtension::ToolBarCommand> toolBarCmdList; |
|
158 |
|
159 mapToExtensionToolBarItems(commands,toolBarCmdList); |
|
160 //Modify tool bar command list by extension |
|
161 extension->modifyToolBarCommandList(callInfo,toolBarCmdList); |
|
162 // Map tool bar item list back to the phone action tool bar item list. |
|
163 mapToPhoneActionToolBarItems(toolBarCmdList,commands); |
|
164 } |
|
165 } |
|
166 |
|
167 for ( int i=0; i < commands.count(); ++i) { |
|
168 PhoneAction *action = mapCommandToAction( |
|
169 commands.at(i).mCommandId, !commands.at(i).mEnabled); |
|
170 if (action) { |
|
171 actions.append(action); |
|
172 } |
|
173 } |
|
174 |
|
175 return actions; |
|
176 } |
|
177 |
130 QList<int> PhoneUiCommandController::menuCommands( |
178 QList<int> PhoneUiCommandController::menuCommands( |
131 QMap<int,int> callStates, QMap<int,int> serviceIds ) |
179 QMap<int,int> callStates, QMap<int,int> serviceIds ) const |
132 { |
180 { |
133 PHONE_DEBUG("PhoneMenuController::menuCommands"); |
181 PHONE_DEBUG("PhoneMenuController::menuCommands"); |
134 QList<int> commands; |
182 QList<int> commands; |
135 bool sameServices = areServicesSame(callStates,serviceIds); |
183 bool sameServices = areServicesSame(callStates,serviceIds); |
136 |
184 |
300 m_lastCommandExtension = 0; |
340 m_lastCommandExtension = 0; |
301 } |
341 } |
302 } |
342 } |
303 |
343 |
304 bool PhoneUiCommandController::areServicesSame( |
344 bool PhoneUiCommandController::areServicesSame( |
305 QMap<int,int> callStates, QMap<int,int> serviceIds) |
345 QMap<int,int> callStates, QMap<int,int> serviceIds) const |
306 { |
346 { |
307 bool ret(true); |
347 bool ret(true); |
308 int serviceId(-1); |
348 int serviceId(-1); |
309 for(int i=0;i<callStates.count()&&ret;++i) { |
349 for(int i=0;i<callStates.count()&&ret;++i) { |
310 if (-1==serviceId) { |
350 if (-1==serviceId) { |
311 serviceId = serviceIds.value(callStates.keys().at(i)); |
351 serviceId = serviceIds.value(callStates.keys().at(i)); |
312 } else if (serviceId!=serviceIds.value(callStates.keys().at(i))) { |
352 } else if (serviceId != serviceIds.value(callStates.keys().at(i))) { |
313 ret = false; |
353 ret = false; |
314 } |
354 } |
315 } |
355 } |
316 |
356 |
317 return ret; |
357 return ret; |
|
358 } |
|
359 |
|
360 void PhoneUiCommandController::setJoinFlag( |
|
361 QMap<int,int> callStates, QMap<int,int> serviceIds) const |
|
362 { |
|
363 bool disable(PhoneResourceAdapter::Instance()->buttonsController()-> |
|
364 getButtonFlags(PhoneUIQtButtonsController::FullConference)); |
|
365 |
|
366 if (!disable) { |
|
367 disable = !areServicesSame(callStates, serviceIds); |
|
368 } |
|
369 |
|
370 PhoneResourceAdapter::Instance()->buttonsController()-> |
|
371 setButtonFlags(PhoneUIQtButtonsController::DisableJoin, disable); |
|
372 } |
|
373 |
|
374 void PhoneUiCommandController::setHoldFlag(int callState) const |
|
375 { |
|
376 bool hold = (callState == EPEStateHeldConference || |
|
377 callState == EPEStateHeld ); |
|
378 |
|
379 PhoneResourceAdapter::Instance()->buttonsController()-> |
|
380 setButtonFlags(PhoneUIQtButtonsController::Hold,hold); |
|
381 } |
|
382 |
|
383 void PhoneUiCommandController::setOutgoingFlag( |
|
384 QList<int> callStates) const |
|
385 { |
|
386 bool outgoing(callStates.contains(EPEStateDialing) || |
|
387 callStates.contains(EPEStateConnecting)); |
|
388 |
|
389 PhoneResourceAdapter::Instance()->buttonsController()-> |
|
390 setButtonFlags(PhoneUIQtButtonsController::Outgoing, outgoing); |
|
391 } |
|
392 |
|
393 void PhoneUiCommandController::setConferenceFlag( |
|
394 QList<int> callStates) const |
|
395 { |
|
396 bool conference(callStates.contains(EPEStateConnectedConference) || |
|
397 callStates.contains(EPEStateHeldConference)); |
|
398 |
|
399 PhoneResourceAdapter::Instance()->buttonsController()-> |
|
400 setButtonFlags(PhoneUIQtButtonsController::Conference, conference); |
|
401 } |
|
402 |
|
403 void PhoneUiCommandController::setMultiCallFlag( |
|
404 QList<int> callStates) const |
|
405 { |
|
406 bool multicall(false); |
|
407 |
|
408 if (1<callStates.count()) { |
|
409 if (callStates.count() == 2 && callStates.contains(EPEStateRinging)) { |
|
410 multicall = false; |
|
411 } else { |
|
412 multicall = true; |
|
413 } |
|
414 } |
|
415 |
|
416 PhoneResourceAdapter::Instance()->buttonsController()-> |
|
417 setButtonFlags(PhoneUIQtButtonsController::MultiCall, multicall); |
|
418 } |
|
419 |
|
420 void PhoneUiCommandController::mapToExtensionToolBarItems( |
|
421 const QList<PhoneAction::ToolBarItem> &sourceList, |
|
422 QList<XQTelUiCommandExtension::ToolBarCommand> &toolBarCmdList) const |
|
423 { |
|
424 toolBarCmdList.clear(); |
|
425 |
|
426 for (int i=0;i<sourceList.count();++i) { |
|
427 XQTelUiCommandExtension::ToolBarCommand command; |
|
428 command.mCommandId = sourceList.at(i).mCommandId; |
|
429 command.mIsEnabled = sourceList.at(i).mEnabled; |
|
430 toolBarCmdList.append(command); |
|
431 } |
|
432 } |
|
433 |
|
434 void PhoneUiCommandController::mapToPhoneActionToolBarItems( |
|
435 const QList<XQTelUiCommandExtension::ToolBarCommand> &sourceList, |
|
436 QList<PhoneAction::ToolBarItem> &commandList) const |
|
437 { |
|
438 commandList.clear(); |
|
439 |
|
440 for (int i=0;i<sourceList.count();++i) { |
|
441 PhoneAction::ToolBarItem command( |
|
442 sourceList.at(i).mCommandId, |
|
443 sourceList.at(i).mIsEnabled); |
|
444 commandList.append(command); |
|
445 } |
318 } |
446 } |
319 |
447 |
320 QList<int> PhoneUiCommandController::buttonCommandList( |
448 QList<int> PhoneUiCommandController::buttonCommandList( |
321 int callState, |
449 int callState, |
322 bool emergencyCall, |
450 bool emergencyCall, |
323 bool sameServices, |
451 QList<int> callStates) const |
324 QList<int> callStates) |
|
325 { |
452 { |
326 QList<int> ret; |
453 QList<int> ret; |
327 |
454 |
328 switch( callState ) { |
455 switch( callState ) { |
329 case EPEStateIdle: |
456 case EPEStateIdle: |
345 } |
502 } |
346 } |
503 } |
347 break; |
504 break; |
348 |
505 |
349 case EPEStateConnected: |
506 case EPEStateConnected: |
350 case EPEStateConnectedConference: { |
507 case EPEStateConnectedConference: |
351 if (!emergencyCall) { |
|
352 if ( 1 == callStates.size() || |
|
353 (2 == callStates.size() && |
|
354 callStates.contains(EPEStateRinging)) ) { |
|
355 ret.append(PhoneInCallCmdHold); |
|
356 } else { |
|
357 |
|
358 if (EPEStateConnectedConference == callState) { |
|
359 ret.append(PhoneInCallCmdSwap); |
|
360 } else if (sameServices && |
|
361 false == PhoneResourceAdapter::Instance()->buttonsController()-> |
|
362 getButtonFlags(PhoneUIQtButtonsController::DisableJoin)) { |
|
363 if ( callStates.contains(EPEStateHeldConference) ) { |
|
364 ret.append(PhoneInCallCmdJoinToConference); |
|
365 } else { |
|
366 ret.append(PhoneInCallCmdCreateConference); |
|
367 } |
|
368 } |
|
369 } |
|
370 } |
|
371 |
|
372 ret.append(PhoneInCallCmdEndActive); |
|
373 } |
|
374 break; |
|
375 |
|
376 case EPEStateHeld: |
508 case EPEStateHeld: |
377 case EPEStateHeldConference: { |
509 case EPEStateHeldConference: { |
378 if (1 == callStates.size() || |
510 if (!emergencyCall) { |
379 (2 == callStates.size() && |
511 if (PhoneResourceAdapter::Instance()->buttonsController()-> |
380 callStates.contains(EPEStateRinging))) { |
512 getButtonFlags( |
381 |
513 PhoneUIQtButtonsController::IhfAsPushButton)) { |
382 ret.append(PhoneInCallCmdUnhold); |
514 if (PhoneResourceAdapter::Instance()->buttonsController()->getButtonFlags( |
383 } else { |
515 PhoneUIQtButtonsController::BluetoothAvailable)) { |
384 if (EPEStateHeldConference == callState) { |
516 if (PhoneResourceAdapter::Instance()->buttonsController()->getButtonFlags( |
385 ret.append(PhoneInCallCmdSwap); |
517 PhoneUIQtButtonsController::Btaa)) { |
386 } else if (sameServices && |
518 ret.append(PhoneInCallCmdHandset); |
387 false == PhoneResourceAdapter::Instance()->buttonsController()-> |
519 } else { |
388 getButtonFlags(PhoneUIQtButtonsController::DisableJoin)) { |
520 ret.append(PhoneInCallCmdBtHandsfree); |
389 if ( callStates.contains(EPEStateConnectedConference)) { |
521 } |
390 ret.append(PhoneInCallCmdJoinToConference); |
|
391 } else { |
522 } else { |
392 ret.append(PhoneInCallCmdCreateConference); |
523 if (!PhoneResourceAdapter::Instance()->buttonsController()-> |
|
524 getButtonFlags(PhoneUIQtButtonsController::Ihf)) { |
|
525 ret.append(PhoneInCallCmdActivateIhf); |
|
526 } else { |
|
527 ret.append(PhoneInCallCmdDeactivateIhf); |
|
528 } |
|
529 } |
|
530 } else { |
|
531 if (PhoneResourceAdapter::Instance()->buttonsController()-> |
|
532 getButtonFlags(PhoneUIQtButtonsController::Mute)) { |
|
533 ret.append(PhoneInCallCmdUnmute); |
|
534 } else { |
|
535 ret.append(PhoneInCallCmdMute); |
393 } |
536 } |
394 } |
537 } |
395 } |
538 } |
396 |
539 |
397 ret.append(PhoneInCallCmdEndActive); |
540 ret.append(PhoneInCallCmdEndActive); |
406 } |
549 } |
407 |
550 |
408 return ret; |
551 return ret; |
409 } |
552 } |
410 |
553 |
411 PhoneAction *PhoneUiCommandController::mapCommandToAction(int command) |
554 PhoneAction *PhoneUiCommandController::mapCommandToAction( |
|
555 int command, bool disabled) const |
412 { |
556 { |
413 PhoneAction *action=0; |
557 PhoneAction *action=0; |
414 |
558 |
415 switch( command ) { |
559 switch( command ) { |
416 case PhoneInCallCmdJoinToConference: { |
560 case PhoneInCallCmdJoinToConference: { |
417 action = new PhoneAction; |
561 action = new PhoneAction; |
418 action->setIcon(HbIcon("qtg_mono_join_call")); |
562 action->setIcon(HbIcon("qtg_mono_join_call")); |
|
563 action->setDisabled(disabled); |
419 action->setCommand(EPhoneInCallCmdJoin); |
564 action->setCommand(EPhoneInCallCmdJoin); |
420 } |
565 } |
421 break; |
566 break; |
422 |
567 |
423 case PhoneInCallCmdCreateConference: { |
568 case PhoneInCallCmdCreateConference: { |
424 action = new PhoneAction; |
569 action = new PhoneAction; |
425 action->setIcon(HbIcon("qtg_mono_join_call")); |
570 action->setIcon(HbIcon("qtg_mono_join_call")); |
|
571 action->setDisabled(disabled); |
426 action->setCommand(EPhoneInCallCmdCreateConference); |
572 action->setCommand(EPhoneInCallCmdCreateConference); |
427 } |
573 } |
428 break; |
574 break; |
429 |
575 |
430 case PhoneInCallCmdAnswer: { |
576 case PhoneInCallCmdAnswer: { |
431 action = new PhoneAction; |
577 action = new PhoneAction; |
432 action->setIcon(HbIcon("qtg_mono_call")); |
578 action->setIcon(HbIcon("qtg_mono_call")); |
433 action->setCommand (EPhoneCallComingCmdAnswer); |
579 action->setDisabled(disabled); |
|
580 action->setCommand (EPhoneCallComingCmdAnswer); |
434 action->setActionRole(PhoneAction::Accept); |
581 action->setActionRole(PhoneAction::Accept); |
435 } |
582 } |
436 break; |
583 break; |
437 |
584 |
438 case PhoneInCallCmdReject: { |
585 case PhoneInCallCmdReject: { |
439 action = new PhoneAction; |
586 action = new PhoneAction; |
440 action->setIcon(HbIcon("qtg_mono_reject_call")); |
587 action->setIcon(HbIcon("qtg_mono_reject_call")); |
|
588 action->setDisabled(disabled); |
441 action->setCommand (EPhoneCallComingCmdReject); |
589 action->setCommand (EPhoneCallComingCmdReject); |
442 action->setActionRole(PhoneAction::Decline); |
590 action->setActionRole(PhoneAction::Decline); |
443 } |
591 } |
444 break; |
592 break; |
445 |
593 |
446 case PhoneInCallCmdHold: { |
594 case PhoneInCallCmdHold: { |
447 action = new PhoneAction; |
595 action = new PhoneAction; |
448 action->setIcon(HbIcon("qtg_mono_hold_call")); |
596 action->setIcon(HbIcon("qtg_mono_hold_call")); |
|
597 action->setDisabled(disabled); |
449 action->setCommand(EPhoneInCallCmdHold); |
598 action->setCommand(EPhoneInCallCmdHold); |
450 } |
599 } |
451 break; |
600 break; |
452 |
601 |
453 case PhoneInCallCmdUnhold: { |
602 case PhoneInCallCmdUnhold: { |
454 action = new PhoneAction; |
603 action = new PhoneAction; |
455 action->setIcon(HbIcon("qtg_mono_call")); |
604 action->setIcon(HbIcon("qtg_mono_call")); |
|
605 action->setDisabled(disabled); |
456 action->setCommand(EPhoneInCallCmdUnhold); |
606 action->setCommand(EPhoneInCallCmdUnhold); |
457 } |
607 } |
458 break; |
608 break; |
459 |
609 |
460 case PhoneInCallCmdEndActive: { |
610 case PhoneInCallCmdEndActive: { |
461 action = new PhoneAction; |
611 action = new PhoneAction; |
462 action->setIcon(HbIcon("qtg_mono_end_call")); |
612 action->setIcon(HbIcon("qtg_mono_end_call")); |
|
613 action->setDisabled(disabled); |
463 action->setCommand(EPhoneInCallCmdEndThisActiveCall); |
614 action->setCommand(EPhoneInCallCmdEndThisActiveCall); |
464 action->setActionRole(PhoneAction::Decline); |
615 action->setActionRole(PhoneAction::Decline); |
465 } |
616 } |
466 break; |
617 break; |
467 |
618 |
468 case PhoneInCallCmdEndOutgoingCall: { |
619 case PhoneInCallCmdEndOutgoingCall: { |
469 action = new PhoneAction; |
620 action = new PhoneAction; |
470 action->setIcon(HbIcon("qtg_mono_end_call")); |
621 action->setIcon(HbIcon("qtg_mono_end_call")); |
|
622 action->setDisabled(disabled); |
471 action->setCommand(EPhoneInCallCmdEndThisOutgoingCall); |
623 action->setCommand(EPhoneInCallCmdEndThisOutgoingCall); |
472 action->setActionRole(PhoneAction::Decline); |
624 action->setActionRole(PhoneAction::Decline); |
473 } |
625 } |
474 break; |
626 break; |
475 |
627 |
476 case PhoneInCallCmdReplace: { |
628 case PhoneInCallCmdReplace: { |
477 action = new PhoneAction; |
629 action = new PhoneAction; |
478 action->setIcon(HbIcon("qtg_mono_replace_call")); |
630 action->setIcon(HbIcon("qtg_mono_replace_call")); |
|
631 action->setDisabled(disabled); |
479 action->setCommand(EPhoneInCallCmdReplace); |
632 action->setCommand(EPhoneInCallCmdReplace); |
480 action->setActionRole(PhoneAction::Accept); |
633 action->setActionRole(PhoneAction::Accept); |
481 } |
634 } |
482 break; |
635 break; |
483 |
636 |
484 case PhoneInCallCmdSwap: { |
637 case PhoneInCallCmdSwap: { |
485 action = new PhoneAction; |
638 action = new PhoneAction; |
486 action->setIcon(HbIcon("qtg_mono_swap")); |
639 action->setIcon(HbIcon("qtg_mono_replace_call")); |
|
640 action->setDisabled(disabled); |
487 action->setCommand(EPhoneInCallCmdSwap); |
641 action->setCommand(EPhoneInCallCmdSwap); |
488 } |
642 } |
489 break; |
643 break; |
490 |
644 case PhoneCallComingCmdSoftReject: { |
|
645 action = new PhoneAction; |
|
646 action->setIcon(HbIcon("qtg_mono_send")); |
|
647 action->setDisabled(disabled); |
|
648 action->setCommand(EPhoneCallComingCmdSoftReject); |
|
649 } |
|
650 break; |
|
651 case PhoneCallComingCmdSilent: { |
|
652 action = new PhoneAction; |
|
653 action->setIcon(HbIcon("qtg_mono_speaker_off")); |
|
654 action->setDisabled(disabled); |
|
655 action->setCommand(EPhoneCallComingCmdSilent); |
|
656 } |
|
657 break; |
|
658 case PhoneInCallCmdOpenDialer: { |
|
659 action = new PhoneAction; |
|
660 action->setIcon(HbIcon("qtg_mono_dialer")); |
|
661 action->setDisabled(disabled); |
|
662 action->setCommand(EPhoneInCallCmdDialer); |
|
663 } |
|
664 break; |
|
665 case PhoneInCallCmdMute: { |
|
666 action = new PhoneAction; |
|
667 action->setIcon(HbIcon("qtg_mono_mic_mute")); |
|
668 action->setDisabled(disabled); |
|
669 action->setCommand(EPhoneInCallCmdMute); |
|
670 } |
|
671 break; |
|
672 case PhoneInCallCmdUnmute: { |
|
673 action = new PhoneAction; |
|
674 action->setIcon(HbIcon("qtg_mono_mic_unmute")); |
|
675 action->setDisabled(disabled); |
|
676 action->setCommand(EPhoneInCallCmdUnmute); |
|
677 } |
|
678 break; |
|
679 case PhoneInCallCmdActivateIhf: { |
|
680 action = new PhoneAction; |
|
681 action->setIcon(HbIcon("qtg_mono_speaker")); |
|
682 action->setDisabled(disabled); |
|
683 action->setCommand(EPhoneInCallCmdActivateIhf); |
|
684 } |
|
685 break; |
|
686 case PhoneInCallCmdDeactivateIhf: { |
|
687 action = new PhoneAction; |
|
688 action->setIcon(HbIcon("qtg_mono_mobile")); |
|
689 action->setDisabled(disabled); |
|
690 action->setCommand(EPhoneInCallCmdDeactivateIhf); |
|
691 } |
|
692 break; |
|
693 case PhoneInCallCmdOpenContacts: { |
|
694 action = new PhoneAction; |
|
695 action->setIcon(HbIcon("qtg_mono_contacts")); |
|
696 action->setDisabled(disabled); |
|
697 action->setCommand(EPhoneInCallCmdContacts); |
|
698 } |
|
699 break; |
|
700 case PhoneInCallCmdBtHandsfree: { |
|
701 action = new PhoneAction; |
|
702 action->setIcon(HbIcon("qtg_mono_bluetooth_headset")); |
|
703 action->setDisabled(disabled); |
|
704 action->setCommand(EPhoneInCallCmdBtHandsfree); |
|
705 } |
|
706 break; |
|
707 case PhoneInCallCmdHandset: { |
|
708 action = new PhoneAction; |
|
709 action->setIcon(HbIcon("qtg_mono_mobile")); |
|
710 action->setDisabled(disabled); |
|
711 action->setCommand(EPhoneInCallCmdHandset); |
|
712 } |
|
713 break; |
491 default: |
714 default: |
492 break; |
715 break; |
493 } |
716 } |
494 |
717 |
495 return action; |
718 return action; |