Exemplo n.º 1
0
static KineticStatus KineticClient_CreateOperation(
    KineticOperation** operation,
    KineticSessionHandle handle)
{
    if (handle == KINETIC_HANDLE_INVALID) {
        LOG0("Specified session has invalid handle value");
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    KineticConnection* connection = KineticConnection_FromHandle(handle);
    if (connection == NULL) {
        LOG0("Specified session is not associated with a connection");
        return KINETIC_STATUS_SESSION_INVALID;
    }

    LOGF1("\n"
         "--------------------------------------------------\n"
         "Building new operation on connection @ 0x%llX", connection);

    *operation = KineticAllocator_NewOperation(connection);
    if (*operation == NULL) {
        return KINETIC_STATUS_MEMORY_ERROR;
    }
    if ((*operation)->request == NULL) {
        return KINETIC_STATUS_NO_PDUS_AVAVILABLE;
    }

    return KINETIC_STATUS_SUCCESS;
}
Exemplo n.º 2
0
void CMLauncherAppUi::PlaylistTransferCompleteL()
{
	LOG(ELogGeneral,1,"PlaylistTransferCompleteL: start");

	iActiveViews&=~EFiletransferViewActive;
	if(iCurrentView==iFiletransferView)
	{
		//we need to switch to a diferent vierw, e.g. list view
		LOG0("Activating list view");
		SwitchViewL(iListView);
		LOG0("List view activated");
	}/*
	else
	{
		//no need to switch view, but we must take care of the navi menu (may need replacing with exit)
		ChangeExitWithNaviL(-1);
	};*/

	Clean(ETrue);//this function performs asynchronously

    //update the view
    if(iDirection==EDirectionReceiving)
    	UpdateView();

	LOG(ELogGeneral,-1,"PlaylistTransferCompleteL: end");
};
Exemplo n.º 3
0
/** @brief Log a message from the Python.
 *
 * In AQUAgpusph the Python stdout and stderr are redirected to this function,
 * such that:
 *     - stdout messages will be logged with level 0
 *     - stderr messages will be logged with level 3
 * @param self Module.
 * @param args Positional arguments.
 * @param keywds Keyword arguments.
 * @return Computed value, NULL if errors have been detected.
 */
static PyObject* logMsg(PyObject *self, PyObject *args, PyObject *keywds)
{
    int level;
    const char* msg;

    static char *kwlist[] = {"log_level", "message", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, keywds, "is", kwlist,
                                     &level, &msg)){
        return NULL;
    }

    switch(level) {
        case 0:
            LOG0(Aqua::L_DEBUG, msg); break;
        case 1:
            LOG0(Aqua::L_INFO, msg); break;
        case 2:
            LOG0(Aqua::L_WARNING, msg); break;
        case 3:
            LOG0(Aqua::L_ERROR, msg); break;            
    }

    Py_RETURN_NONE;
}
Exemplo n.º 4
0
void KineticController_HandleUnexpectedResponse(void *msg,
        int64_t seq_id,
        void *bus_udata,
        void *socket_udata)
{
    KineticResponse * response = msg;
    KineticSession* session = socket_udata;
    bool connetionInfoReceived = false;
    char const * statusTag = "[PDU RX STATUS]";
    char const * unexpectedTag = "[PDU RX UNEXPECTED]";
    char const * logTag = unexpectedTag;
    int logAtLevel, protoLogAtLevel;

    (void)bus_udata;

    // Handle unsolicited status PDUs
    if (response->proto->authtype == COM__SEAGATE__KINETIC__PROTO__MESSAGE__AUTH_TYPE__UNSOLICITEDSTATUS) {
        int64_t connectionID = KineticResponse_GetConnectionID(response);
        if (connectionID != 0)
        {
            // Store connectionID from unsolicited status message in the session for future requests
            KineticSession_SetConnectionID(session, connectionID);
            LOGF2("Extracted connection ID from unsolicited status PDU (id=%lld)", connectionID);
            connetionInfoReceived = true;
            logTag = statusTag;
            logAtLevel = 2;
            protoLogAtLevel = 3;
        }
        else {
            LOG0("WARNING: Unsolicited status received. Connection being terminated by remote!");
            logTag = statusTag;
            logAtLevel = 0;
            protoLogAtLevel = 0;
            KineticStatus status = KineticResponse_GetStatus(response);
            KineticSession_SetTerminationStatus(session, status);
        }
    }
    else {
        LOG0("WARNING: Received unexpected response!");
        logTag = unexpectedTag;
        logAtLevel = 0;
        protoLogAtLevel = 0;
    }

    KineticLogger_LogPrintf(logAtLevel, "%s pdu: %p, session: %p, bus: %p, "
                            "fd: %6d, seq: %8lld, protoLen: %8u, valueLen: %8u",
                            logTag,
                            (void*)response, (void*)session,
                            (void*)session->messageBus,
                            session->socket, (long long)seq_id,
                            KineticResponse_GetProtobufLength(response),
                            KineticResponse_GetValueLength(response));
    KineticLogger_LogProtobuf(protoLogAtLevel, response->proto);

    KineticAllocator_FreeKineticResponse(response);

    if (connetionInfoReceived) {
        KineticResourceWaiter_SetAvailable(&session->connectionReady);
    }
}
Exemplo n.º 5
0
KineticStatus KineticSession_Create(KineticSession * const session, KineticClient * const client)
{
    if (session == NULL) {
        LOG0("Session is NULL");
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    if (client == NULL) {
        LOG0("Client is NULL");
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    session->connected = false;
    session->socket = KINETIC_SOCKET_INVALID;

    // initialize session send mutex
    if (pthread_mutex_init(&session->sendMutex, NULL) != 0) {
        LOG0("Failed initializing session send mutex!");
        return KINETIC_STATUS_MEMORY_ERROR;
    }

    session->outstandingOperations =
        KineticCountingSemaphore_Create(KINETIC_MAX_OUTSTANDING_OPERATIONS_PER_SESSION);
    if (session->outstandingOperations == NULL) {
        LOG0("Failed creating session counting semaphore!");
        return KINETIC_STATUS_MEMORY_ERROR;
    }

    return KINETIC_STATUS_SUCCESS;
}
Exemplo n.º 6
0
bool IODicom<T>::ReadMetaData(PGCore::BaseDataObject *oMetaDataObject, const IOParams &iParams)
{
    const std::vector<std::string>& iPaths = iParams.Source();
    if (iPaths.empty())
    {
        LOG0("IO/IODicom::ReadMetaData: Invalid input filename vector.");
        return false;
    }
    const std::string &iFileName = iPaths[0];
    if (iFileName.empty())
    {
        LOG0("IO/IODicom::ReadMetaData: Invalid input filename.");
        return false;
    }

    //this is where to read the image in
    PGCore::MetaData<T> *oMetaData = (static_cast<PGCore::MetaData< T > *>(oMetaDataObject));
    if (!oMetaData)
    {
        LOG0("IO/IOBase::ReadMetaData: Invalid output container for metadata.");
        return false;
    }

    return GetAttributes(*oMetaData, iFileName);
}
Exemplo n.º 7
0
SQLCode::SQLCode()
{
	LOG0(SourceInfo, DebugUtil::DebugSQL,"Begin build the Hash table...");

	m_pSqlFileHelper = new SQLFileHelper();

	LOG0(SourceInfo, DebugUtil::DebugSQL,"End build the Hash table...");
}
Exemplo n.º 8
0
KineticStatus KineticClient_DestroySession(KineticSession* const session)
{
    if (session == NULL) {
        LOG0("KineticSession is NULL!");
        return KINETIC_STATUS_SESSION_INVALID;
    }

    KineticStatus status = KineticSession_Disconnect(session);
    if (status != KINETIC_STATUS_SUCCESS) {LOG0("Disconnection failed!");}
    KineticSession_Destroy(session);

    return status;
}
Exemplo n.º 9
0
KineticStatus KineticSession_Connect(KineticSession * const session)
{
    if (session == NULL) {
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    // Establish the connection
    KINETIC_ASSERT(strlen(session->config.host) > 0);
    session->socket = KineticSocket_Connect(
        session->config.host, session->config.port);
    if (session->socket == KINETIC_SOCKET_DESCRIPTOR_INVALID) {
        LOG0("Session connection failed!");
        session->socket = KINETIC_SOCKET_DESCRIPTOR_INVALID;
        session->connected = false;
        return KINETIC_STATUS_CONNECTION_ERROR;
    }
    session->connected = true;

    bus_socket_t socket_type = session->config.useSsl ? BUS_SOCKET_SSL : BUS_SOCKET_PLAIN;
    session->si = calloc(1, sizeof(socket_info) + 2 * PDU_PROTO_MAX_LEN);
    if (session->si == NULL) { return KINETIC_STATUS_MEMORY_ERROR; }
    bool success = Bus_RegisterSocket(session->messageBus, socket_type, session->socket, session);
    if (!success) {
        LOG0("Failed registering connection with client!");
        goto connection_error_cleanup;
    }

    // Wait for initial unsolicited status to be received in order to obtain connection ID
    success = KineticResourceWaiter_WaitTilAvailable(&session->connectionReady, KINETIC_CONNECTION_TIMEOUT_SECS);
    if (!success) {
        LOG0("Timed out waiting for connection ID from device!");
        goto connection_error_cleanup;
    }
    LOGF1("Received connection ID %lld for session %p",
        (long long)KineticSession_GetConnectionID(session), (void*)session);

    return KINETIC_STATUS_SUCCESS;

connection_error_cleanup:

    if (session->si != NULL) {
        free(session->si);
        session->si = NULL;
    }
    if (session->socket != KINETIC_SOCKET_DESCRIPTOR_INVALID) {
        KineticSocket_Close(session->socket);
        session->socket = KINETIC_SOCKET_DESCRIPTOR_INVALID;
    }
    session->connected = false;
    return KINETIC_STATUS_CONNECTION_ERROR;
}
Exemplo n.º 10
0
        void gInitStructuredExceptionHandler()
        {
            // TODO LPP: Should we use a thread local variable to ensure we only call
            // _set_se_translator() once per thread?  Does _set_se_translator() already do this?

            static bool shouldSetSeTranslator = RunParams::getInstance().isSet(RPARAM_DEBUGLOGSTACKTRACE);
            if (shouldSetSeTranslator)
            {
                LOG0(SourceInfo, DebugUtil::DebugDebug, "gInitStructuredExceptionHandler(): calling _set_se_translator()");
                _set_se_translator( translator_func );
            }
            else
            {
                LOG0(SourceInfo, DebugUtil::DebugDebug, "gInitStructuredExceptionHandler(): NOT calling _set_se_translator()");
            }
        }
Exemplo n.º 11
0
JERRCODE CJPEGDecoder::ProcessRestart(int thread_id)
{
  IppStatus status;

#ifdef _OPENMP
  status = ippiDecodeHuffmanStateInit_JPEG_8u(m_state_t[thread_id]);
#else
  status = ippiDecodeHuffmanStateInit_JPEG_8u(m_state);
#endif
  if(ippStsNoErr != status)
  {
    LOG0("Error: ippiDecodeHuffmanStateInit_JPEG_8u() failed");
    return JPEG_ERR_INTERNAL;
  }

  for(int n = 0; n < m_jpeg_ncomp; n++)
  {
    m_ccomp[n].m_lastDC = 0;
  }

#ifdef _OPENMP
  if(m_threading_mode == JT_RSTI)
  {
    for(int n = 0; n < m_jpeg_ncomp; n++)
    {
      m_lastDC[thread_id][n] = 0;
    }
  }
#endif

  return JPEG_OK;
} // CJPEGDecoder::ProcessRestart()
Exemplo n.º 12
0
BOOL CAuthenticationPg::OnInitDialog() {
	LOG0(3, "CAuthenticationPg::OnInitDialog()");

	CPropertyPage::OnInitDialog();

	return TRUE;
}
Exemplo n.º 13
0
//---------------------------------------------------------------------------
//
//	セーブ
//
//---------------------------------------------------------------------------
int FASTCALL CRTC::Save(Fileio *fio, int ver)
{
	size_t sz;

	ASSERT(this);
	ASSERT(fio);
	LOG0(Log::Normal, "セーブ");

	// サイズをセーブ
	sz = sizeof(crtc_t);
	if (!fio->Write(&sz, sizeof(sz))) {
		return FALSE;
	}

	// 実体をセーブ
	if (!fio->Write(&crtc, (int)sz)) {
		return FALSE;
	}

	// イベントをセーブ
	if (!event.Save(fio, ver)) {
		return FALSE;
	}

	return TRUE;
}
Exemplo n.º 14
0
	bool ErosionKernel<T, U>::Initialize_()
	{
		if (m_radius<=0.0f)
		{
			return false;
		}

		// fill up the buffer here
		int i=0;

		// fill circle

		
		/*for (i=0;i<(m_dimension);i++) 
		{
			SetValue(0, i, 1);
		}*/
		
		bool res = drawCircle(m_dimension/2, m_dimension/2, m_radius, m_buffer);
		if (!res) return false;

#ifdef _DEBUG
		if (0)
		{
			LOG1("The filter coefficients are (radius: %d):", m_radius);
			for(int j=0;j<(m_dimension);j++)
			{
				LOG0("\n");
				for(i=0;i<(m_dimension);i++)
					LOG3("Kernel[%d][%d] = %f", j, i, (double)GetValue(j, i));
			}
		}
#endif
		return true;
	}
Exemplo n.º 15
0
void CPropCachingPg::UpdateControls() {
	LOG0(3, "CPropCachingPg::UpdateControls()");

	if (m_ctlSpecificCaching.GetCheck() == BST_CHECKED) {
		m_ctlStoreImages.EnableWindow();
		m_ctlCacheOnlineContent.EnableWindow();
	}
	else {
		m_ctlStoreImages.EnableWindow(FALSE);
		m_ctlCacheOnlineContent.EnableWindow(FALSE);
	}

	if (m_ctlCacheEnclosures.GetCheck() == BST_CHECKED) {
		m_ctlEnclosureLimit.EnableWindow();
		m_ctlLargerLbl.EnableWindow();
		m_ctlEnclosureLimitSpin.EnableWindow();
		m_ctlMB.EnableWindow();
		m_ctlMBLbl.EnableWindow();
	}
	else {
		m_ctlEnclosureLimit.EnableWindow(FALSE);
		m_ctlLargerLbl.EnableWindow(FALSE);
		m_ctlEnclosureLimitSpin.EnableWindow(FALSE);
		m_ctlMB.EnableWindow(FALSE);
		m_ctlMBLbl.EnableWindow(FALSE);
	}
}
Exemplo n.º 16
0
	//  0: false, not in async mode
	//  1: true
	int AsyncProcess::NotifyError(const char *iMsg/*=0*/)
	{
		if (!m_pProcess) return false;
		if (!m_pProcess->GetAsyncEnabled()) return false;
		//if (!ioAsyncLoadMT) return 0;

		EnterCriticalSection(&m_csMT);
		m_threadsRemaining--;
		LeaveCriticalSection(&m_csMT);
		
		if (m_threadsRemaining>0) 
		{
			LOG1("%d threads remaining. One of them reported error. Killing all..", m_threadsRemaining);
		} else
		{
			LOG0("A thread reported error. Killing all..");
		}

		for (int i=0; i<m_numThreadsMT; i++)
		{				
			//if (m_thread[i].IsAlive())
			{					
				m_thread[i].CloseThread();
				LOG1("Closed thread with threadHandle [%d]", m_hThreadMT[i]);
			}
		}

		return 1;
	}
Exemplo n.º 17
0
BOOL CRewriteRuleDlg::OnInitDialog() {
	LOG0(3, "CRewriteRuleDlg::OnInitDialog()");

	CCeDialog::OnInitDialog();

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}
Exemplo n.º 18
0
CRewriteRuleDlg::CRewriteRuleDlg(CWnd* pParent /*=NULL*/)
	: CCeDialog(CRewriteRuleDlg::IDD)
{
	LOG0(5, "CRewriteRuleDlg::CRewriteRuleDlg()");
	//{{AFX_DATA_INIT(CRewriteRuleDlg)
	//}}AFX_DATA_INIT
	SetMenu(IDR_DONE);
}
bool ImageEdgeDetectionBase<T, U>::Execute() {

    if (!m_iDataObject) {
        LOG0("ImageEdgeDetectionBase: Error: no input");
        return false;
    }

    // also check base image types here

    // get first image
    PGCore::Image<T> *inImage = (static_cast<PGCore::Image < T > *>(m_iDataObject));
    if (!inImage) {
        LOG0("ImageEdgeDetectionBase: Error: failure to fetch input image");
        return false;
    }

    long iRows=0, iColumns=0;
    inImage->GetDimensions(iRows, iColumns);
    if (iRows*iColumns <=0) {
        LOG0("ImageEdgeDetectionBase: Error: invalid image size");
        return false;
    }

    const T* inBuf = inImage->GetBuffer();
    if (!inBuf)
    {
        LOG0("ImageEdgeDetectionBase: Error: invalid image");
        return false;
    }

    if (m_oImageObject == NULL)
        m_oImageObject = new PGCore::Image<U>(iRows, iColumns);
    U* outBuf = m_oImageObject->GetBuffer();
    if (!outBuf)
    {
        LOG0("ImageEdgeDetectionBase: Error: invalid out image");
        return false;
    }

    bool rv = detectEdges(m_sigma, m_loTh, m_hiTh, inImage, m_oImageObject);

    m_oDataObject = (static_cast<PGCore::BaseDataObject *>(m_oImageObject));

    return rv;
}
Exemplo n.º 20
0
CString MakeOfflineUrl(const CString &strFileName) {
	LOG0(5, "MakeOfflineUrl()");

	CString strOfflineUrl;
	strOfflineUrl.Format(_T("file://localhost%s"), strFileName);
	strOfflineUrl.Replace('\\', '/');

	return strOfflineUrl;
}
Exemplo n.º 21
0
void tearDown(void)
{
    if (FileDesc >= 0) {
        LOG0("Shutting down socket...");
        KineticSocket_Close(FileDesc);
        FileDesc = 0;
    }
    KineticLogger_Close();
}
Exemplo n.º 22
0
CMLauncherAppUi::~CMLauncherAppUi()
{
	LOG(ELogGeneral,1,"CMLauncherAppUi::~CMLauncherAppUi++");
	if(iIdle)
	{
		LOG0("Canceling iIdle");
		iIdle->Cancel();
		LOG0("Deleting iIdle");
		delete iIdle;
	};
	LOG0("iIdle is deleted. Deleting iDlg*");
	delete iDlgMsg;
	delete iDlgNote;
	delete iDlgNoteString;
	LOG0("Deleting iDocHandler (should be NULL already)");
	delete iDocHandler;
	LOG(ELogGeneral,-1,"CMLauncherAppUi::~CMLauncherAppUi--");
};
Exemplo n.º 23
0
Image<T> &Image<T>::operator-=(const Image<T> &iImageObject) {	
	long iRows, iColumns;	
	iImageObject.GetDimensions(iRows, iColumns);		

	if (iRows!=m_rows || iColumns!=m_columns) {
		return *this;
	}
	
	PGCore::PixelBase<T> tPixel;
	T rangeMin = tPixel.GetMaxValue(), rangeMax = tPixel.GetMinValue();
	T irangeMin = tPixel.GetMaxValue(), irangeMax = tPixel.GetMinValue();

	GetDataRange(&rangeMin, &rangeMax);	
	if (!iImageObject.GetDataRange(&irangeMin, &irangeMax))
	{
		//iImageObject.Update();
		//if (!iImageObject.GetDataRange(&irangeMin, &irangeMax))
		{
			assert(0 && "Failed to compute range");
			LOG0("WARNING: Failed to compute range");
			return *this;
		}
	}
	
	rangeMin = Functional<T>::Min(rangeMin, irangeMin);//rangeMin<irangeMin ? rangeMin : irangeMin;
	rangeMax = Functional<T>::Max(rangeMax, irangeMax);//rangeMax>irangeMax ? rangeMax : irangeMax;
	T rangeTotal = (T)(rangeMax - rangeMin);

	if (rangeTotal<=T(0)) return *this;
	
	long double rangeOrg = (double)(255.0f);//tPixel.GetMaxValue() - tPixel.GetMinValue());

	T* iBuffer = (T*)iImageObject.GetBuffer();
	if (!iBuffer) return *this;

	long iSize = 0;
	while (iSize< m_rows*m_columns) 
	{		
		T signedDiffValue = *(m_buffer+iSize) - *(iBuffer+iSize);
		//signedDiffValue += (double)rangeTotal;
		//signedDiffValue = signedDiffValue/(2.0f*rangeTotal);
		//signedDiffValue *= rangeOrg;	
		//T diffValue = (T)Functional<T>::Abs(signedDiffValue);
		if (signedDiffValue<T(0)) signedDiffValue = -signedDiffValue;

		*(m_buffer+iSize) = signedDiffValue;
		iSize++;
	}

	//Update();

	m_rangeUpToDate = false;

	return *this;
}
Exemplo n.º 24
0
KineticStatus KineticClient_Disconnect(KineticSessionHandle* const handle)
{
    if (*handle == KINETIC_HANDLE_INVALID) {
        LOG0("Invalid KineticSessionHandle specified!");
        return KINETIC_STATUS_SESSION_INVALID;
    }
    KineticConnection* connection = KineticConnection_FromHandle(*handle);
    if (connection == NULL) {
        LOG0("Failed getting valid connection from handle!");
        return KINETIC_STATUS_CONNECTION_ERROR;
    }

    // Disconnect
    KineticStatus status = KineticConnection_Disconnect(connection);
    if (status != KINETIC_STATUS_SUCCESS) {LOG0("Disconnection failed!");}
    KineticConnection_FreeConnection(handle);
    *handle = KINETIC_HANDLE_INVALID;

    return status;
}
Exemplo n.º 25
0
/* -------------------------------------------------------------------------- */
void cutils_test_appsupport_path_Create()
{
    LOG0("---- cutils_test_appsupport_path_Create --------------------------");
    
    CFStringRef appSuppLocal = appsupport_path_Create(kLocalDomain);
    CFShow(appSuppLocal);
    //LOG_CF("app support folder (local)", appSuppLocal);
    assert(CFStringCompare(appSuppLocal, 
                           CFSTR("/Library/Application Support"), 0) == 0);
    
}
Exemplo n.º 26
0
BOOL CPropCachingPg::OnInitDialog() {
	LOG0(3, "CPropCachingPg::OnInitDialog()");

	CPropertyPage::OnInitDialog();
	
	m_ctlEnclosureLimitSpin.SendMessage(CCM_SETVERSION, COMCTL32_VERSION);
	m_ctlEnclosureLimitSpin.SetRange(0, 30000);
	UpdateControls();

	return TRUE;
}
Exemplo n.º 27
0
void CGameApp::Run(int argc,char *argv[])
{
	LOG0("TK Game Started\n------------------\n");
	int extra = 0;

	for(int a=1; a<argc; a++) 
	{
		int b=0;
		char *tmp=strdup(argv[a]);
		strupr(tmp);
		
		if((tmp[0]=='-')||(tmp[0]=='/'))
		switch(tmp[1]) 
		{
			case '1': extra |= SDL_HWACCEL;
					break;

			case '2': extra |= SDL_HWSURFACE;
					break;

			case 'W':iOptions->Data().iFullScreen=0; 
					 break;

			case 'L':b=atoi(argv[++a]);
					 if(b>0) iDebugStartLevel=b - 1;
					 break;

			default:
					error("Unknown commandline parameter!?!\n");
					break;
		}
		free(tmp);
	}
	
	iGGI->SetExtraFlags( extra );
	iGGI->SetMenuMode();
	iEventHandler->ResetStack();

	LOG0("Starting game loop\n");
	Loop();
}
Exemplo n.º 28
0
void CMLauncherAppUi::StopwatchDoneL()
{
    LOG(ELogGeneral,1,"StopwatchDone: start");

    iActiveViews&=~EStopwatchViewActive;
    if(iCurrentView==iStopwatchView)
    {
        //we need to switch to a diferent vierw, e.g. list view
        LOG0("Activating list view");
        SwitchViewL(iListView);
        LOG0("List view activated");
    }/*
    else
    {
        //no need to switch view, but we must take care of the navi menu (may need replacing with exit)
        ChangeExitWithNaviL(-1);
    };*/

    //do cleaning here

    LOG(ELogGeneral,-1,"StopwatchDone: end");
};
Exemplo n.º 29
0
void CMLauncherAppUi::CloseMusicPlayerViewL()
{
	LOG(ELogGeneral,1,"CloseMusicPlayerViewL: start");

	iActiveViews&=~EMusicPlayerViewActive;
	if(iMusicPlayerView)
		iMusicPlayerView->ClearPlaylist();
	if(iCurrentView==iMusicPlayerView)
	{
		//we need to switch to a different view, e.g. list view
		LOG0("Activating list view");
		SwitchViewL(iListView);
		LOG0("List view activated");
	}/*
	else
	{
		//no need to switch view, but we must take care of the navi menu (may need replacing with exit)
		ChangeExitWithNaviL(-1);
	};*/

	LOG(ELogGeneral,-1,"CloseMusicPlayerViewL: end");
};
Exemplo n.º 30
0
void CMusicPlayerTelObs::RunL()
{
	LOG0("CMusicPlayerTelObs::RunL line status=%d",iLineStatus.iStatus);
	if(iStatus==KErrNone)
	{
		if(iLineStatus.iStatus == CTelephony::EStatusIdle)
		{
			iMusicPlayerView.ResumePlayback();
			LOG0("CMusicPlayerTelObs::RunL: playback resumed (line status: idle)");
		}
		else if(iMusicPlayerView.iTrack)
		{
			//we have an ongoing call AND we are in playing state
			iMusicPlayerView.iTrack->iFlags|=CTrack::EKilledByTelephony;
			LOG0("CMusicPlayerTelObs::RunL: (line status changed: %d)",iLineStatus.iStatus);
		}
	}
	
	/* Request the next notification */
	iTelephony->NotifyChange( iStatus,CTelephony::EVoiceLineStatusChange,iLineStatusPckg );
	SetActive();
}