phoneapp/phoneuiqtviewadapter/src/phoneindicatorcontroller.cpp
branchGCC_SURGE
changeset 51 f39ed5e045e0
parent 30 ebdbd102c78a
parent 46 bc5a64e5bc3c
equal deleted inserted replaced
40:bab96b7ed1a4 51:f39ed5e045e0
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 #include "phoneindicatorcontroller.h"
    18 #include "phoneindicatorcontroller.h"
    19 #include "phoneindicators.h"
    19 #include "phoneindicators.h"
    20 
    20 #include "qtphonelog.h"
    21 #include <QList>
    21 
    22 #include <QPair>
    22 #include <QByteArray>
       
    23 #include <hbicon.h>
    23 
    24 
    24 #ifdef Q_OS_SYMBIAN
    25 #ifdef Q_OS_SYMBIAN
    25 #include <logsmodel.h>
    26 #include <logsmodel.h>
    26 #include <logsfilter.h>
    27 #include <logsfilter.h>
    27 #include <logsdomaincrkeys.h>
    28 #include <LogsDomainCRKeys.h>
    28 #include <hbicon.h>
    29 #include <ctsydomaincrkeys.h>
    29 #endif
    30 #endif
       
    31 
       
    32 namespace PhoneIndicatorControllerKeys{
       
    33     const XQSettingsKey missedCallsSettingsKey( XQSettingsKey::TargetCentralRepository, 
       
    34         KCRUidLogs.iUid, KLogsNewMissedCalls );
       
    35 
       
    36     const XQSettingsKey unconditionalCFKey( XQSettingsKey::TargetCentralRepository, 
       
    37         KCRUidCtsyCallForwardingIndicator.iUid, KCtsyUnconditionalCFStatus );
       
    38 
       
    39     const XQSettingsKey currentCFKey( XQSettingsKey::TargetCentralRepository, 
       
    40             KCRUidCtsyCallForwardingIndicator.iUid, KCtsyCallForwardingIndicator );     
       
    41 }
       
    42 
       
    43 
    30 
    44 
    31 PhoneIndicatorController::PhoneIndicatorController(QObject *parent):
    45 PhoneIndicatorController::PhoneIndicatorController(QObject *parent):
    32     QObject(parent), m_logsModel(0), m_missedCallsFilter(0)
    46     QObject(parent), m_logsModel(0), m_missedCallsFilter(0)
    33 {
    47 {
       
    48     PHONE_TRACE
    34 #ifdef Q_OS_SYMBIAN
    49 #ifdef Q_OS_SYMBIAN
    35     m_setManager = new XQSettingsManager(this);
    50     m_setManager = new XQSettingsManager(this);
    36  
    51     connect( m_setManager, 
    37     XQSettingsKey settingsKey( XQSettingsKey::TargetCentralRepository, 
       
    38             KCRUidLogs.iUid, KLogsNewMissedCalls );
       
    39     
       
    40     bool ok = connect( m_setManager, 
       
    41             SIGNAL( valueChanged(const XQSettingsKey & ,const QVariant &)),
    52             SIGNAL( valueChanged(const XQSettingsKey & ,const QVariant &)),
    42                 this, SLOT(updateMissedCallIndicator(XQSettingsKey, 
    53                 this, SLOT(updateMissedCallIndicator(XQSettingsKey, 
    43                         QVariant)));
    54                         QVariant)));
    44     ASSERT( ok );
    55     
    45     ok = false;
    56     connect( m_setManager, 
    46     ok = m_setManager->startMonitoring( settingsKey );
    57             SIGNAL( valueChanged(const XQSettingsKey & ,const QVariant &)),
    47     ASSERT(ok);
    58                 this, SLOT(updateDivertIndicator(XQSettingsKey, 
    48     
    59                         QVariant)));
    49     qRegisterMetaType<PhoneIndicatorInfo>("PhoneIndicatorInfo");
    60     
    50 
    61     m_setManager->startMonitoring( PhoneIndicatorControllerKeys::missedCallsSettingsKey );
       
    62     m_setManager->startMonitoring( PhoneIndicatorControllerKeys::unconditionalCFKey, 
       
    63             XQSettingsManager::TypeByteArray);
       
    64     m_setManager->startMonitoring( PhoneIndicatorControllerKeys::currentCFKey,
       
    65             XQSettingsManager::TypeByteArray);
       
    66     
       
    67     qRegisterMetaType<PhoneIndicatorInfo>("PhoneIndicatorInfo");    
       
    68     QByteArray bytes = m_setManager->readItemValue(
       
    69             PhoneIndicatorControllerKeys::unconditionalCFKey).toByteArray();
       
    70     if ( m_setManager->error() == XQSettingsManager::NoError ){
       
    71         int cfStatus=0;
       
    72         memcpy(&cfStatus, bytes.data_ptr()->array, sizeof(int));
       
    73         updateDiverIndicator(cfStatus & KCFVoiceForwarded);
       
    74     }
    51 #endif
    75 #endif
    52 }
    76 }
    53 
    77 
    54 PhoneIndicatorController::~PhoneIndicatorController()
    78 PhoneIndicatorController::~PhoneIndicatorController()
    55 {   
    79 {   
    56 #ifdef Q_OS_SYMBIAN
    80 #ifdef Q_OS_SYMBIAN
       
    81     
    57     XQPublishAndSubscribeSettingsKey missedCallCountKey(
    82     XQPublishAndSubscribeSettingsKey missedCallCountKey(
    58                     (qint32)KCRUidLogs.iUid, (quint32)KLogsNewMissedCalls );
    83                     (qint32)KCRUidLogs.iUid, (quint32)KLogsNewMissedCalls );
    59     m_setManager->stopMonitoring(missedCallCountKey);
    84     m_setManager->stopMonitoring(missedCallCountKey);
    60     delete m_setManager;
    85     delete m_setManager;
    61     delete m_missedCallsFilter;
    86     delete m_missedCallsFilter;
    62     delete m_logsModel;
    87     delete m_logsModel;
    63 #endif
    88 #endif
    64 }
    89 }
    65 
    90 
    66 void PhoneIndicatorController::setActiveCallData( 
    91 void PhoneIndicatorController::setActiveCallData()
    67         const TDesC &text, const TDesC &icon )
    92 {
    68 {
    93     m_cli = hbTrId("txt_phone_dblist_ongoing_call");
    69     m_cli = QString::fromUtf16 (text.Ptr (), text.Length ());
    94     m_callImage = "qtg_mono_call";//QString::fromUtf16 (icon.Ptr (), icon.Length ());
    70     m_callImage = QString::fromUtf16 (icon.Ptr (), icon.Length ());
       
    71 }
    95 }
    72 
    96 
    73 void PhoneIndicatorController::clearActiveCallData()
    97 void PhoneIndicatorController::clearActiveCallData()
    74 {
    98 {
    75     m_cli.clear();
    99     m_cli.clear();
   101 
   125 
   102 void PhoneIndicatorController::updateMissedCallIndicator(
   126 void PhoneIndicatorController::updateMissedCallIndicator(
   103         const XQSettingsKey &key, const QVariant &value)
   127         const XQSettingsKey &key, const QVariant &value)
   104 { 
   128 { 
   105 #ifdef Q_OS_SYMBIAN
   129 #ifdef Q_OS_SYMBIAN
   106     if ( key.key() == (quint32)KLogsNewMissedCalls ){
   130 
       
   131     if (compareKeys(key, PhoneIndicatorControllerKeys::missedCallsSettingsKey) ){
   107         if ( value.toInt() == 0 ){
   132         if ( value.toInt() == 0 ){
   108             QString indicatorType(indicatorName(PhoneMissedCallIndicator));
   133             QString indicatorType(indicatorName(PhoneMissedCallIndicator));
   109             m_indicator.deactivate(indicatorType);
   134             m_indicator.deactivate(indicatorType);
   110             delete m_missedCallsFilter;
   135             delete m_missedCallsFilter;
   111             m_missedCallsFilter = NULL;
   136             m_missedCallsFilter = NULL;
   122         }
   147         }
   123     }
   148     }
   124 #endif  
   149 #endif  
   125 }
   150 }
   126 
   151 
       
   152 void PhoneIndicatorController::updateDivertIndicator(
       
   153         const XQSettingsKey &key, const QVariant &value)
       
   154 {
       
   155     PHONE_TRACE
       
   156     if ( compareKeys( key, PhoneIndicatorControllerKeys::currentCFKey ) ){
       
   157         PHONE_DEBUG("currentCfKey");
       
   158         int cfStatus = value.toByteArray().toInt();
       
   159         updateDiverIndicator( cfStatus & KCFVoiceForwarded);
       
   160     } else if (compareKeys(key, PhoneIndicatorControllerKeys::unconditionalCFKey )){        
       
   161         QByteArray bytes = value.toByteArray();
       
   162         // Convert QByteArray elements into integer
       
   163         // Conversation does not care about sign bit
       
   164         int status;
       
   165         memcpy(&status, bytes.data_ptr()->array, sizeof(int));
       
   166         updateDiverIndicator(status & KCFVoiceForwarded);
       
   167     }
       
   168 }
       
   169 
   127 void PhoneIndicatorController::setMissedallIndicatorData()
   170 void PhoneIndicatorController::setMissedallIndicatorData()
   128 {
   171 {
   129 #ifdef Q_OS_SYMBIAN
   172 #ifdef Q_OS_SYMBIAN
   130 
   173 
   131     XQSettingsKey settingsKey( XQSettingsKey::TargetCentralRepository, 
       
   132             KCRUidLogs.iUid, KLogsNewMissedCalls );
       
   133     QString indicatorType(indicatorName(PhoneMissedCallIndicator));
   174     QString indicatorType(indicatorName(PhoneMissedCallIndicator));
   134     
   175     
   135     int missedCallCount = m_setManager->readItemValue( settingsKey,
   176     int missedCallCount = m_setManager->readItemValue( 
   136             XQSettingsManager::TypeInt ).toInt();
   177             PhoneIndicatorControllerKeys::missedCallsSettingsKey,
       
   178                 XQSettingsManager::TypeInt ).toInt();
   137     
   179     
   138     if ( missedCallCount > 0 ) {
   180     if ( missedCallCount > 0 ) {
   139         QVariantMap parameters;
   181         QVariantMap parameters;
   140         QString lastMissedCallFrom;
   182         QString lastMissedCallFrom;
   141         int repeatedMissedCalls(0);
   183         int repeatedMissedCalls(0);
   168             {
   210             {
   169             parameters.insert( 
   211             parameters.insert( 
   170                     QVariant( HbIndicatorInterface::SecondaryTextRole ).toString(), 
   212                     QVariant( HbIndicatorInterface::SecondaryTextRole ).toString(), 
   171                     lastMissedCallFrom );
   213                     lastMissedCallFrom );
   172             }
   214             }
   173         
   215 
   174         // icon
       
   175         //QList<QVariant> icons = m_missedCallsFilter->data( 
       
   176         //        m_missedCallsFilter->index(0,0), 
       
   177         //        Qt::DecorationRole).value<QList<QVariant> >();
       
   178         //QString iconName = icons.first().value<HbIcon>().iconName();
       
   179         QString iconName = "qtg_mono_missed_call_unseen";
   216         QString iconName = "qtg_mono_missed_call_unseen";
   180         parameters.insert(
   217         parameters.insert(
   181                 QVariant( HbIndicatorInterface::DecorationNameRole ).toString(),
   218                 QVariant( HbIndicatorInterface::DecorationNameRole ).toString(),
   182                 iconName );
   219                 iconName );
   183         
   220         
   185     } else {
   222     } else {
   186         m_indicator.deactivate( indicatorType );
   223         m_indicator.deactivate( indicatorType );
   187     }
   224     }
   188 #endif
   225 #endif
   189 }
   226 }
       
   227 
       
   228 void PhoneIndicatorController::updateDiverIndicator(bool activeDiverts)
       
   229 {
       
   230     PHONE_TRACE
       
   231     QString indicatorType(indicatorName(PhoneDivertIndidicator));
       
   232     if(activeDiverts){
       
   233         QVariantMap parameters;
       
   234         
       
   235         // First row
       
   236        parameters.insert( 
       
   237                QVariant( HbIndicatorInterface::PrimaryTextRole ).toString(),
       
   238                hbTrId("txt_phone_dblist_active_diverts" ));
       
   239         
       
   240         QString iconName = "qtg_mono_call_diverted";
       
   241         parameters.insert(
       
   242                 QVariant( HbIndicatorInterface::DecorationNameRole ).toString(),
       
   243                 iconName );
       
   244         
       
   245         m_indicator.activate( indicatorType, parameters );
       
   246     }else{
       
   247         m_indicator.deactivate( indicatorType );
       
   248     }        
       
   249 }
       
   250 
       
   251 bool PhoneIndicatorController::compareKeys(
       
   252         const XQSettingsKey &first, const XQSettingsKey &second)
       
   253 {   
       
   254     PHONE_TRACE
       
   255     return ( first.key() == second.key() && first.uid() == second.uid() );
       
   256 }