Mercurial Mercurial > oss > FCL > sf > mw > hb / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/hbcore/devicedialogbase/hbindicatorsym_p.cpp
changeset 2 06ff229162e9
parent 1 f7ac710697a9
child 5 627c4a0fd0e7
equal deleted inserted replaced
1:f7ac710697a9 2:06ff229162e9 
    40     }
 
    40     }
 
    41     TInt Start() 
    41     TInt Start() 
    42     {
 
    42     {
 
    43         TInt error = KErrNone;
 
    43         TInt error = KErrNone;
 
    44         if (!IsActive()) {
 
    44         if (!IsActive()) {
 
       
    45             // Async connect to prevent deadlock if application is started from a
 
       
    46             // device dialog server plugin.
 
    45             iStatus = KRequestPending;
 
    47             iStatus = KRequestPending;
 
    46             error = iIndicator->mHbSession.Connect(&iStatus);
 
    48             error = iIndicator->mHbSession.Connect(&iStatus);
 
    47             if (error == KErrNone) {
 
    49             if (error == KErrNone) {
 
    48                 SetActive();
 
    50                 SetActive();
 
    49             }
 
    51             }
 
    50         }
 
    52         }
 
    51         return error;
 
    53         return error;
 
    52     }
 
    54     }
 
    53     void RunL() {
 
    55     void RunL()
 
       
    56     {
 
    54         if (iStatus == KErrNone) {
 
    57         if (iStatus == KErrNone) {
 
    55             iIndicator->Start();
 
    58             iIndicator->Start();
 
    56         }
 
    59         }
 
    57     }
 
    60     }
 
    58     void DoCancel()
 
    61     void DoCancel()
 
    59     {
 
    62     {
 
    60         TRequestStatus *rs = &iStatus;
 
    63     // No Cancel() available for RSessionBase::Connect()
 
    61         User::RequestComplete(rs, KErrNone);
 
       
    62     }
 
    64     }
 
    63 private:
 
    65 private:
 
    64     HbIndicatorPrivate *iIndicator;
 
    66     HbIndicatorPrivate *iIndicator;
 
    65 };
 
    67 };
 
    66 
    68 
   119 */
 
   121 */
 
   120 void HbIndicatorPrivate::initializeL(bool forListening)
 
   122 void HbIndicatorPrivate::initializeL(bool forListening)
 
   121 {
 
   123 {
 
   122     TRACE_ENTRY
 
   124     TRACE_ENTRY
 
   123     TInt error = KErrNone;
 
   125     TInt error = KErrNone;
 
       
   126     bool asynchConnect = false;
 
   124     if (forListening) {
 
   127     if (forListening) {
 
   125         if (!iAsyncListener) {
 
   128         CreateReceiveBufferL(DefaultReceiveBufferSize);
 
   126             iAsyncListener = new (ELeave) CAsyncListener(this);
 
   129         // If device dialog server is running, connect asynchronously. This is to
 
   127         }
 
   130         // prevent a deadlock if server plugin is starting an application.
 
   128         error = iAsyncListener->Start();
 
   131         asynchConnect = RHbDeviceDialogClientSession::ServerRunning();
 
       
   132         if (asynchConnect){
 
       
   133             if (!iAsyncListener) {
 
       
   134                 iAsyncListener = new (ELeave) CAsyncListener(this);
 
       
   135             }
 
       
   136             error = iAsyncListener->Start();
 
       
   137         } else {
 
       
   138             error = mHbSession.Connect();
 
       
   139         }
 
   129     } else {
 
   140     } else {
 
   130         error = mHbSession.Connect();
 
   141         error = mHbSession.Connect();
 
   131     }
 
   142     }
 
   132 
   143 
   133     if ( error != KErrNone && error != KErrAlreadyExists) {
 
   144     if (error != KErrNone) {
 
   134         TRACE("initialize error: " << error);
 
   145         TRACE("initialize error: " << error);
 
   135         setError( HbDeviceDialogConnectError );
 
   146         setError(HbDeviceDialogConnectError);
 
   136         User::LeaveIfError( error );
 
   147         User::Leave(error);
 
   137     }
 
       
   138     else if (forListening){
 
       
   139         iBuffer = HBufC8::NewL( 256 );
 
       
   140         iDataPtr.Set( iBuffer->Des() );
 
       
   141         iDataPtr.Zero();
 
       
   142     }
 
   148     }
 
   143     iInitialized = ETrue;
 
   149     iInitialized = ETrue;
 
       
   150     if (forListening && !asynchConnect) {
 
       
   151         Start();
 
       
   152     }
 
   144     TRACE_EXIT
 
   153     TRACE_EXIT
 
   145 }
 
   154 }
 
   146 
   155 
   147 bool HbIndicatorPrivate::activate(const QString &indicatorType, const QVariant &parameter)
 
   156 bool HbIndicatorPrivate::activate(const QString &indicatorType, const QVariant &parameter)
 
   148 {
 
   157 {
 
   178 }
 
   187 }
 
   179 
   188 
   180 bool HbIndicatorPrivate::stopListen()
 
   189 bool HbIndicatorPrivate::stopListen()
 
   181 {
 
   190 {
 
   182     TRACE_ENTRY
 
   191     TRACE_ENTRY
 
   183     //close connections to server.
 
   192     // Close connections to server
 
   184     bool ok = false;
 
   193     bool ok = false;
 
   185     if (iRequesting) {
 
   194     if (iRequesting) {
 
   186         Close();
 
   195         Close();
 
   187     }
 
   196     }
 
   188     if (iInitialized) {
 
   197     if (iInitialized) {
 
   230     iLastError = HbDeviceDialogNoError;
 
   239     iLastError = HbDeviceDialogNoError;
 
   231     TInt status = iStatus.Int();
 
   240     TInt status = iStatus.Int();
 
   232     iRequesting = EFalse;
 
   241     iRequesting = EFalse;
 
   233     
   242     
   234     if (status >= 0 && iMsgType == EHbIndicatorUserActivated) {
 
   243     if (status >= 0 && iMsgType == EHbIndicatorUserActivated) {
 
   235 		iMsgType = -1;
 
   244         iMsgType = -1;
 
   236 		if (status > 0) {
 
   245         if (status > 0) {
 
   237 			delete iBuffer;
 
   246             CreateReceiveBufferL(status);
 
   238 			iBuffer = NULL;
 
   247             TInt error = mHbSession.SendSyncRequest(EHbSrvActivatedIndicatorData,
 
   239 			iBuffer = HBufC8::NewL(status);
 
   248                 iDataPtr, &iMsgTypePtr);
 
   240 			iDataPtr.Set(iBuffer->Des());
 
   249         }
 
   241 			TInt error = mHbSession.SendSyncRequest(EHbSrvActivatedIndicatorData, iDataPtr, &iMsgTypePtr);							                
   250 
   242 		}
 
   251         QByteArray resArray((const char*)iDataPtr.Ptr(), iDataPtr.Size());
 
   243 		
   252         QDataStream stream(&resArray, QIODevice::ReadOnly);
 
   244 		QByteArray resArray((const char*)iDataPtr.Ptr(), iDataPtr.Size());
 
   253         QVariant var;
 
   245 		QDataStream stream(&resArray, QIODevice::ReadOnly);
 
   254         stream >> var;
 
   246 		QVariant var;
 
   255 
   247 		stream >> var;
 
   256         if (q_ptr && q_ptr->receivers(SIGNAL(userActivated(QString, QVariantMap))) > 0) {
 
   248 		
   257             QVariantMap map = var.toMap();
 
   249 		if (q_ptr && q_ptr->receivers(SIGNAL(userActivated(QString, QVariantMap))) > 0) {
 
   258             emit q_func()->userActivated(map.value("type").toString(), map.value("data").toMap());
 
   250 			QVariantMap map = var.toMap();
 
   259         }
 
   251 			emit q_func()->userActivated(map.value("type").toString(), map.value("data").toMap());
 
       
   252 		} 			
       
   253     } else if (status >= 0) {
 
   260     } else if (status >= 0) {
 
   254         QByteArray resArray( (const char*) iDataPtr.Ptr(), iDataPtr.Size() );
 
   261         QByteArray resArray( (const char*) iDataPtr.Ptr(), iDataPtr.Size() );
 
   255         QDataStream stream( &resArray, QIODevice::ReadOnly);
 
   262         QDataStream stream( &resArray, QIODevice::ReadOnly);
 
   256 
   263 
   257         QList<IndicatorClientInfo> activatedList;
 
   264         QList<IndicatorClientInfo> activatedList;
 
   299             emit updated(updatedList);
 
   306             emit updated(updatedList);
 
   300         }
 
   307         }
 
   301 
   308 
   302         if ( status > 0 && iBuffer->Size() < status ) {
 
   309         if ( status > 0 && iBuffer->Size() < status ) {
 
   303             // Resize buffer.
 
   310             // Resize buffer.
 
   304             delete iBuffer;
 
   311             CreateReceiveBufferL(status);
 
   305             iBuffer = NULL;
 
       
   306 
       
   307             iBuffer = HBufC8::NewL( status );
 
       
   308             iDataPtr.Set( iBuffer->Des() );
 
       
   309         }
 
   312         }
 
   310     } else {
 
   313     } else {
 
   311         setError(status);
 
   314         setError(status);
 
   312     }
 
   315     }
 
   313 
   316 
   345 */
 
   348 */
 
   346 void HbIndicatorPrivate::Start()
 
   349 void HbIndicatorPrivate::Start()
 
   347 {
 
   350 {
 
   348     TRACE_ENTRY
 
   351     TRACE_ENTRY
 
   349 
   352 
   350     if ( !iRequesting && iInitialized && !IsActive() ) {
 
   353     if (!iRequesting && iInitialized && !IsActive()) {
 
   351 		if (!iBuffer) {
 
   354         if (!iBuffer) {
 
   352 			iBuffer = HBufC8::NewL( 256 );
 
   355             CreateReceiveBufferL(DefaultReceiveBufferSize);
 
   353 			iDataPtr.Set( iBuffer->Des() );
 
   356         }
 
   354 		}
 
   357         iDataPtr.Zero();
 
   355 		iDataPtr.Zero();
 
       
   356         TPckg<TInt> pckg( iMsgType );
 
   358         TPckg<TInt> pckg( iMsgType );
 
   357         iMsgTypePtr.Set( pckg ); //iMsgTypePtr is ignored in server side.
 
   359         iMsgTypePtr.Set( pckg ); //iMsgTypePtr is ignored in server side.
 
   358     
   360     
   359         mHbSession.SendASyncRequest( EHbSrvGetActivatedIndicatorsStart,
 
   361         mHbSession.SendASyncRequest( EHbSrvGetActivatedIndicatorsStart,
 
   360                 iDataPtr, iMsgTypePtr, iStatus );
 
   362             iDataPtr, iMsgTypePtr, iStatus );
 
   361         SetActive();
 
   363         SetActive();
 
   362         iRequesting = ETrue;
 
   364         iRequesting = ETrue;
 
   363     }
 
   365     }
 
   364     TRACE_EXIT
 
   366     TRACE_EXIT
 
   365 }
 
   367 }
 
   366 
   368 
   367 void HbIndicatorPrivate::Continue()
 
   369 void HbIndicatorPrivate::Continue()
 
   368 {
 
   370 {
 
   369     TRACE_ENTRY
 
   371     TRACE_ENTRY
 
   370 
   372 
   371     if ( !iRequesting && iInitialized && !IsActive() ) {
 
   373     if (!iRequesting && iInitialized && !IsActive()) {
 
   372         TPckg<TInt> pckg( iMsgType );
 
   374         TPckg<TInt> pckg( iMsgType );
 
   373         iMsgTypePtr.Set( pckg );
 
   375         iMsgTypePtr.Set( pckg );
 
   374 
   376 
   375         mHbSession.SendASyncRequest( EHbSrvGetActivatedIndicatorContinue,
 
   377         mHbSession.SendASyncRequest( EHbSrvGetActivatedIndicatorContinue,
 
   376                 iDataPtr, iMsgTypePtr, iStatus );
 
   378                 iDataPtr, iMsgTypePtr, iStatus );
 
   433     }
 
   435     }
 
   434     TRACE_EXIT
 
   436     TRACE_EXIT
 
   435     return result;
 
   437     return result;
 
   436 }
 
   438 }
 
   437 
   439 
       
   440 void HbIndicatorPrivate::CreateReceiveBufferL(int size)
 
       
   441 {
 
       
   442     delete iBuffer; iBuffer = 0;
 
       
   443     iBuffer = HBufC8::NewL(size);
 
       
   444     iDataPtr.Set(iBuffer->Des());
 
       
   445     iDataPtr.Zero();
 
       
   446 }
FCL/sf/mw/hb