bjackview.cpp

手机文件浏览器 Here are the sources to SMan v1.2c 1.2 is a major jump from v1.1. You will see this from the

#include "bjackview.h"
#include "dialogs.h"
#include "sman.h"
#include <sman.rsg>

/*************************************************************
*
* BJack view
*
**************************************************************/

CSMan2BJackView::CSMan2BJackView(CConfig *cData)  : CViewBase(cData)
{
}

TBool CSMan2BJackView::ViewScreenModeCompatible(TInt aScreenMode)
{
	return (aScreenMode == 0);
}

TVwsViewIdAndMessage CSMan2BJackView::ViewScreenDeviceChangedL()
{
	return TVwsViewIdAndMessage(TVwsViewId(KUidSMan2App, KUidFlipclosedView));
}

void CSMan2BJackView::ViewDeactivated()
{
	activateCount--;
	if (activateCount <= 0)
	{
		MakeVisible(EFalse);
		static_cast<CEikAppUi*>(iEikonEnv->AppUi())->RemoveFromStack(this);
	}
}

void CSMan2BJackView::ViewActivatedL(const TVwsViewId& /*aPrevViewId*/, TUid /*aCustomMessageId*/, const TDesC8& /*aCustomMessage*/)
{
	if (activateCount <= 0)
	{
		doViewActivated();
		// Did the log get rerouted?
		if (oScanner->logHelper->logTextBox != bluejackLog)
		{
			oScanner->logHelper->logTextBox = bluejackLog;
			oScanner->logHelper->updateLog(NULL, 0, CLogger::logAll);
		}
	}
}

TVwsViewId CSMan2BJackView::ViewId() const
{
	return TVwsViewId(KUidSMan2App, KUidBJackView);
}

TKeyResponse CSMan2BJackView::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)
{
	if (aType == EEventKey)
	{
		if (aKeyEvent.iCode == EQuartzKeyTwoWayDown)
		{
			bluejackLog->MoveDisplayL(TCursorPosition::EFLineDown);
			bluejackLog->UpdateScrollBarsL();
			return EKeyWasConsumed;
		}
		else if (aKeyEvent.iCode == EQuartzKeyTwoWayUp)
		{
			bluejackLog->MoveDisplayL(TCursorPosition::EFLineUp);
			bluejackLog->UpdateScrollBarsL();
			return EKeyWasConsumed;
		}
	}
	return bluejackLog->OfferKeyEventL(aKeyEvent, aType);
}

CSMan2BJackView::~CSMan2BJackView()
{
	delete oScanner;
}

void CSMan2BJackView::ConstructL(const TRect& aRect)
{
	CreateWindowL();
	SetExtent(aRect.iTl, aRect.Size());

	bluejackLog = new (ELeave) CEikGlobalTextEditor;
	bluejackLog->ConstructL(this, 18, MAX_LOG_LINES * MAX_LOG_LINE_SIZE, CEikEdwin::EReadOnly, EGulFontControlAll, EGulAllFonts);
	bluejackLog->SetExtent(TPoint(0, 0), TSize(Size().iWidth, Size().iHeight - EQikToolbarHeight - 10)); 
	bluejackLog->CreateScrollBarFrameL();
	bluejackLog->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EAuto, CEikScrollBarFrame::EAuto);
	controlsArray->AppendL(bluejackLog);

	TFileName appPath;
	
	appPath.Copy(appPathNoExt);
	appPath.SetLength(appPath.Length() - 5);

	oScanner = new (ELeave) CScanner(&appPath, configData);

	TCharFormat charFormat;
	TCharFormatMask charFormatMask;

	charFormat.iFontPresentation.iTextColor = KRgbDarkBlue;
	charFormatMask.SetAttrib(EAttColor);
	bluejackLog->ApplyCharFormatL(charFormat, charFormatMask);

	viewId = CSMan2AppUi::EViewBJack;
	bjackIconPosition = TPoint(2, bluejackLog->Position().iY + bluejackLog->Size().iHeight + 2);
	initBJackIcon();

	MakeVisible(EFalse);
	SetZoomLevel(configData->zoomBJack);

	CParaFormat paraFormat;
	TParaFormatMask paraFormatMask;

	paraFormat.iLineSpacingControl = CParaFormat::ELineSpacingAtLeastInTwips;
	paraFormatMask.SetAttrib(EAttLineSpacingControl);
	bluejackLog->ApplyParaFormatL(&paraFormat, paraFormatMask);
	ActivateL();
}

void CSMan2BJackView::SetZoomLevel(TInt zoomLevel)
{
	TInt lineSpaceTwips[3] = {150, 200, 300};
	TCharFormat charFormat;
	TCharFormatMask charFormatMask;
	
	CParaFormat paraFormat;
	TParaFormatMask paraFormatMask;

	charFormat.iFontSpec.iHeight = ((zoomLevel - ZOOM_INCREMENT) / ZOOM_INCREMENT) * 150 + 100;
	charFormatMask.SetAttrib(EAttFontHeight);
	bluejackLog->ApplyCharFormatL(charFormat, charFormatMask);
	
	paraFormat.iLineSpacingInTwips = lineSpaceTwips[(zoomLevel / ZOOM_INCREMENT) - 1];
	paraFormatMask.SetAttrib(EAttLineSpacing);
	bluejackLog->ApplyParaFormatL(&paraFormat, paraFormatMask);
	configData->zoomBJack = zoomLevel;
}

void CSMan2BJackView::HandleControlEventL(CCoeControl* /*aControl*/, TCoeEvent /*aEventType*/)
{
}

/*************************************************************
*
* Logging class
*
**************************************************************/

CLogger::CLogger(CConfig *cData)
{
	configData = cData;
	logFilename.Copy(CEikonEnv::Static()->EikAppUi()->Application()->AppFullName());
	logFilename.SetLength(logFilename.Length() - 3);
	logFilename.Append(_L("log.txt"));
}

CLogger::~CLogger()
{
}

void CLogger::updateLog(const TDesC *dialogLine, const TInt numExtraLines, TUint logType)
{
	if ((configData->logFlags & logType) == 0)
		return;

	TBuf<MAX_LOG_LINE_SIZE * MAX_LOG_LINES> tempLine;
	TTime tTime;

	if (dialogLine != NULL)
	{
		tTime.HomeTime();
		tTime.FormatL(tempLine, _L("%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%:3%+B  "));
		tempLine.Append(*dialogLine);
		
		if (*localAutoSave)
		{
			TBuf<MAX_LOG_LINE_SIZE * MAX_LOG_LINES> fileOutput;
			
			fileOutput.Copy(tempLine);
			fileOutput.Append(_L("\r\n"));
			for (int i = 0; i < numExtraLines;i ++)
				fileOutput.Append(_L("\r\n"));
			if (!saveLog(EFalse, &fileOutput))
				CEikonEnv::Static()->InfoMsgWithAlignment(TGulAlignment(EHRightVCenter), R_TBUF_BJACKERRSAVELOG);
		}
		tempLine.Append(CEditableText::ELineBreak);
		tempLine.Append(CEditableText::ELineBreak);

		// Are we overflowing the buffer?
		if ((logBuffer->Length() + tempLine.Length()) >= (MAX_LOG_LINES * MAX_LOG_LINE_SIZE))
		{
			// Yes. Delete the older characters
			logBuffer->Delete(0, tempLine.Length());
		}
		logBuffer->Append(tempLine);
	}
	if (logTarget == logToDialog)
	{
		if (logDialog != NULL)
		{
			CEikGlobalTextEditor *logEditor;
			logEditor = STATIC_CAST(CEikGlobalTextEditor*, logDialog->Control(controlId));
			logEditor->SetTextL(logBuffer);
			logEditor->SetCursorPosL(logEditor->TextLength(), 0);
			logEditor->DrawDeferred();
		}
	} 
	else if (logTarget == logToTextEditor)
	{
		//logTextBox->InsertDeleteCharsL(logTextBox->TextLength(), tempLine, TCursorSelection(0, 0));
		logTextBox->SetTextL(logBuffer);
		logTextBox->SetCursorPosL(logTextBox->TextLength(), 0);
		logTextBox->DrawDeferred();
	}
}

TBool CLogger::saveLog(TBool overwrite, TDesC *buffer)
{
	RFile outStream;
	TBuf8<((MAX_LOG_LINES + 1) * MAX_LOG_LINE_SIZE) * 2> buffer8bit;
	TInt openResult;

	// Use copy to convert from unicode to non-unicode
	buffer8bit.Copy(*buffer);

	if (overwrite)
		openResult = outStream.Replace(CEikonEnv::Static()->FsSession(), logFilename, EFileWrite);
	else
	{
		if ((openResult = outStream.Open(CEikonEnv::Static()->FsSession(), logFilename, EFileWrite)) != KErrNone)
			openResult = outStream.Replace(CEikonEnv::Static()->FsSession(), logFilename, EFileWrite);
	}
		
	if (openResult == KErrNone)
	{
		TInt aPos;
		
		aPos = 0;
		outStream.Seek(ESeekEnd, aPos);
		outStream.Write(buffer8bit);
		outStream.Close();
		return ETrue;
	}
	else
		return EFalse;
}

/*************************************************************
*
* Scanner class
*
**************************************************************/

CScanner::~CScanner()
{
	if (hostResolverOpen)
	{
		hostResolver.Close();
		hostResolverOpen = EFalse;
	}
	if (socketServOpen)
	{
		socketServ.Close();
		socketServOpen = EFalse;
	}
	delete logHelper;
	delete myVibra;
	
	if (audioPlayerUtil)
	{
		audioPlayerUtil->Stop();
		delete audioPlayerUtil;
	}
}

CScanner::CScanner(TFileName *appPath, CConfig *cData) : CTimer(EPriorityNormal)
{	
	configData = cData;
	audioPlayerUtil = NULL;
	
	vCardNames[0].Copy(*appPath);
	vCardNames[0].Append(_L("SMAN.VCF"));

	scannerStatus = isIdle;
	hostResolverOpen = EFalse;
	socketServOpen = EFalse;

	myVibra = CVibration::NewL(NULL);
	
	logHelper = new (ELeave) CLogger(cData);
	logHelper->logBuffer = &logBuffer;
	logHelper->logTarget = CLogger::logToTextEditor;
	logHelper->logTextBox = static_cast<CSMan2AppUi*>(CEikonEnv::Static()->AppUi())->iBJackView->bluejackLog;

	socketServ.Connect();
	socketServOpen = ETrue;
	// L2CAP, SDP, RFCOMM, BTLinkManager
	if ((socketServ.FindProtocol(_L("BTLinkManager"), protoDesc)) != KErrNone)
	{
		socketServ.Close();
		socketServOpen = EFalse;
		CEikonEnv::Static()->InfoMsg(R_TBUF_BJACKBTLINKMISSING);
		User::Leave(0);
	}
	CTimer::ConstructL();
	CActiveScheduler::Add(this);
}

TBool CScanner::initFile(void)
{
	if (obexFile)
	{
		delete obexFile;
		obexFile = NULL;
	}
	obexFile = CObexFileObject::NewL(TPtrC(NULL, 0));
	TInt err;
	TRAP(err, obexFile->InitFromFileL(vCardNames[0]));
	if (err)
	{
		//TBuf<50> txt;
		//CEikonEnv::Static()->ReadResource(txt, R_TBUF_BJACKERRVCARD);
		HBufC* dataBuffer = CEikonEnv::Static()->AllocReadResourceL(R_TBUF_BJACKERRVCARD);
		logHelper->updateLog(dataBuffer, 0, CLogger::logAll);
		delete dataBuffer;
		
		return EFalse;
	}
	return ETrue;
}

void CScanner::doRealScan(void)
{
	//TBuf<50> txt;
	//CEikonEnv::Static()->ReadResource(txt, R_TBUF_BJACKSCANNING);
	HBufC* dataBuffer = CEikonEnv::Static()->AllocReadResourceL(R_TBUF_BJACKSCANNING);
	logHelper->updateLog(dataBuffer, 0, CLogger::logScanning);
	delete dataBuffer;

	// Check if user switched off bluetooth
	if (hostResolverOpen)
		hostResolver.Close(); //++++++++++++++++++
	if (hostResolver.Open(socketServ, protoDesc.iAddrFamily, protoDesc.iProtocol) != KErrNone)
	{
		HBufC* dataBuffer = CEikonEnv::Static()->AllocReadResourceL(R_TBUF_BJACKBTDISABLED);
		//TBuf<50> txt;		
		//CEikonEnv::Static()->ReadResource(txt, R_TBUF_BJACKBTDISABLED);
		hostResolverOpen = EFalse;
		CEikonEnv::Static()->InfoMsg(*dataBuffer);
		logHelper->updateLog(dataBuffer, 0, CLogger::logAll);
		delete dataBuffer;
		
		scannerStatus = isIdle;
		return;
	}
	static_cast<CSMan2AppUi*>(CEikonEnv::Static()->EikAppUi())->updateBJackIcon(ETrue);
	hostResolverOpen = ETrue;
	if (obexClient)
	{
		delete obexClient;
		obexClient = NULL;
	}
	if (initFile())
	{
		// Start the discovery inquiry
		sockAddr.SetIAC(KGIAC);
		sockAddr.SetAction(resolveAction);
		iStatus = KRequestPending;
		scannerStatus = isInquiring;
		hostResolver.GetByAddress(sockAddr, nameEntry, iStatus);
		SetActive();
	}
	else
		stopScan();
	SetToolbarButtonState();
}

void CScanner::timeoutAbort(void)
{
	if (obexClient)
	{
		//obexClient->Abort();
		delete obexClient;
		obexClient = NULL;
	}

	if (IsActive())
		Cancel();

	if (scannerStatus != isShutdown)
	{
		startRestTime.HomeTime();
		currentNoDevicePause = STACK_COOLOFF_COUNTDOWN;
		firstRest = ETrue;
		rest();
	}
	else
		stopScan();
}

void CScanner::startScan(void)
{	
	logHelper->localAutoSave = &(configData->autoSave);
	localShowSysMsg = &(configData->showBluejackSysMsg);
	localProxSweepOnce = &(configData->proxSweepOnce);
	localNoDeviceAttempts = &(configData->noDeviceAttempts);
	localNoDevicePause = &(configData->noDevicePause);
	localVibrate = &(configData->vibraNotify);
	localAudioFile = &(configData->audioFileName);
	currentNoDeviceAttempts = 0;
	currentDeviceIndex = MAX_BTDEV_ADDR;
	for (int i = 0 ; i < MAX_BTDEV_ADDR; i++)
	{
		btDevice[i].isBluejacked = statusNoDevice;
		btDevice[i].btDevAddr[0] = 0;
		btDevice[i].btDevAddr[1] = 0;
		btDevice[i].btDevAddr[2] = 0;
		btDevice[i].btDevAddr[3] = 0;
		btDevice[i].btDevAddr[4] = 0;
		btDevice[i].btDevAddr[5] = 0;
		btDevice[i].obexPort = -1;										
	}
	if (configData->resolveName)
		resolveAction = KHostResInquiry + KHostResName;
	else
		resolveAction = KHostResInquiry;
		
	if (scannerBehaviour == behaviourBluejackOne)
	{
		forcedFlagTrue = ETrue;
		localProxSweepOnce = &forcedFlagTrue;
		//logHelper->localAutoSave = &forcedFlagTrue;

		if (selectDevice() == KErrNone)
		{
			// Skip scanning. Bluejack immediately
			static_cast<CSMan2AppUi*>(CEikonEnv::Static()->EikAppUi())->updateBJackIcon(ETrue);
			currentDeviceIndex = -1;
			CEikonEnv::Static()->InfoMsg(R_TBUF_BJACKSCANNERSTARTED);
			if (initFile())
				bluejackNextDevice();
			else
				stopScan();
		}
	}
	else
	{
		CEikonEnv::Static()->InfoMsg(R_TBUF_BJACKSCANNERSTARTED);
		doRealScan();
	}
}

void CScanner::stopScan(void)
{
	if (IsActive())
	{
		if (scannerStatus == isRest)
		{
			Cancel();
			After(1);
		}
		scannerStatus = isShutdown;
		CEikonEnv::Static()->InfoMsg(R_TBUF_BJACKSCANNERTERMINATING);
	}
	else
	{
		timeoutCounter.stopTimer();
		if (obexFile)
		{
			delete obexFile;
			obexFile = NULL;
		}
		if (obexClient)
		{
			delete obexClient;
			obexClient = NULL;
		}
		
		scannerStatus = isIdle;
		if (hostResolverOpen)
		{
			hostResolver.Close();
			hostResolverOpen = EFalse;
		}
		HBufC* dataBuffer = CEikonEnv::Static()->AllocReadResourceL(R_TBUF_BJACKSCANNERTERMINATED);
		logHelper->updateLog(dataBuffer, 2, CLogger::logScanning);
		CEikonEnv::Static()->InfoMsg(*dataBuffer);
		delete dataBuffer;
		static_cast<CSMan2AppUi*>(CEikonEnv::Static()->EikAppUi())->updateBJackIcon(EFalse);
		SetToolbarButtonState();
		
		if (audioPlayerUtil)
			audioPlayerUtil->Stop();
	}
}

void CScanner::logWithLookup(TPtrC theText, TUint logType)
{		
	if (resolveAction == KHostResInquiry)