system.cpp

在手机操作系统symbina上使用的一个脚本扩展语言的代码实现,可以参考用于自己的开发

	default:
		linkBaud = EBps115200;
		break;
	case ELinkBps230400:
		linkBaud = EBps230400;
		break;
	case ELinkBps460800:
		linkBaud = EBps460800;
		break;
	case ELinkBps576000:
		linkBaud = EBps576000;
		break;
	case ELinkBps1152000:
		linkBaud = EBps1152000;
		break;
	case ELinkBps4000000:
		linkBaud = EBps4000000;
		break;
		}
	if (aLinkType == ELinkTypeCable)
		User::LeaveIfError(link.Enable(linkBaud, KPortComm0, KModuleEcuart));
	else
		User::LeaveIfError(link.Enable(linkBaud, KPortIrcomm0, KModuleIrcomm));
	CleanupStack::PopAndDestroy(); //link
	aOplAPI.Push(0.0);
#endif
	}

void CSystemOpx::RemoteLinkConfig(OplAPI& aOplAPI) const
	{
#if !defined(USE_PLP)
	User::Leave(KErrNotSupported);
#else
	TInt16 *aLinkBaud = aOplAPI.PopPtrInt16();
	TInt16 *aLinkType = aOplAPI.PopPtrInt16();

	RRemoteLink link;
	User::LeaveIfError(link.Open());
	CleanupClosePushL(link);
	TPortName port;
	TBps baud;
	User::LeaveIfError(link.Config(&baud,&port));

	if (!port.CompareF(KPortIrcomm0))
		*aLinkType=ELinkTypeIrDA;
	else if (!port.CompareF(KPortComm0))
		*aLinkType=ELinkTypeCable;
	else
		*aLinkType=ELinkTypeUnknown;
	switch (baud)
		{
	case EBps9600:
		*aLinkBaud = ELinkBps9600;
		break;
	case EBps19200:
		*aLinkBaud = ELinkBps19200;
		break;
	case EBps38400:
		*aLinkBaud = ELinkBps38400;
		break;
	case EBps57600:
		*aLinkBaud = ELinkBps57600;
		break;
	case EBps115200:
		*aLinkBaud = ELinkBps115200;
		break;
	case EBps230400:
		*aLinkBaud = ELinkBps230400;
		break;
	case EBps460800:
		*aLinkBaud = ELinkBps460800;
		break;
	case EBps576000:
		*aLinkBaud = ELinkBps576000;
		break;
	case EBps1152000:
		*aLinkBaud = ELinkBps1152000;
		break;
	case EBps4000000:
		*aLinkBaud = ELinkBps4000000;
		break;
	default:
		*aLinkBaud = ELinkBpsUnknown;
		break;
		}
	CleanupStack::PopAndDestroy(); // link
	aOplAPI.Push(0.0);
#endif
	}

void CSystemOpx::PWIsEnabled(OplAPI& aOplAPI) const
	{
	aOplAPI.Push(OpxUtil::OplBool16( Password::IsEnabled() ));
	}

void CSystemOpx::PWSetEnabled(OplAPI& aOplAPI) const
	{
	TBool enable = (aOplAPI.PopInt16() != 0);
	TPtrC passw = aOplAPI.PopString();
	Password::SetEnabled(passw, enable);
	aOplAPI.Push(0.0);
	}

void CSystemOpx::PWIsValid(OplAPI& aOplAPI) const
	{
	TPtrC passw = aOplAPI.PopString();
	aOplAPI.Push(OpxUtil::OplBool16( Password::IsValid(passw) ));
	}

void CSystemOpx::PWSet(OplAPI& aOplAPI) const
	{
	TPtrC npassw = aOplAPI.PopString();
	TPtrC opassw = aOplAPI.PopString();
	Password::Set(opassw, npassw);
	aOplAPI.Push(0.0);
	}

void CSystemOpx::Random(OplAPI& aOplAPI) const
	{ //SyRandom&:
	aOplAPI.Push(TInt32(Math::Random()));
	}

void CSystemOpx::InactivityTime(OplAPI& aOplAPI) const
	{ //SyInactivityTime&:
	TTimeIntervalSeconds inactiveTime=User::InactivityTime();
	aOplAPI.Push(TInt32(inactiveTime.Int()));
	}

void CSystemOpx::ResetInactivityTime(OplAPI& aOplAPI) const
	{ //SyResetInactivityTime:
	User::ResetInactivityTime();
	aOplAPI.Push(TReal64(0.0));
	}

void CSystemOpx::MemoryInformation(OplAPI& aOplAPI) const
	{ //SyMemoryInfo:
	TMemoryInfoV1Buf buf;
	User::LeaveIfError(UserHal::MemoryInfo(buf));
	TMemoryInfoV1 info=buf();
	TAny *pFreeRam = aOplAPI.PopPtrInt32();
	TAny *pMaxFreeRam = aOplAPI.PopPtrInt32();
	TAny *pRom = aOplAPI.PopPtrInt32();
	TAny *pRam = aOplAPI.PopPtrInt32();
	aOplAPI.PutLong(pRam, info.iTotalRamInBytes);
	aOplAPI.PutLong(pRom, info.iTotalRomInBytes);
	aOplAPI.PutLong(pMaxFreeRam, info.iMaxFreeRamInBytes);
	aOplAPI.PutLong(pFreeRam, info.iFreeRamInBytes);
	aOplAPI.Push(0.0);
	}

void CSystemOpx::DefaultDocumentFolder(OplAPI& aOplAPI) const
	{ //SyDefaultDocumentFolder$:
	TFileName defaultFolder;
	CDictionaryStore* store=CDictionaryFileStore::SystemLC(aOplAPI.DbManager()->FsSession());
	if (store->IsPresentL(KUidGlobalDefaultDocumentDirectory))
		{
		RDictionaryReadStream stream;
		stream.OpenLC(*store,KUidGlobalDefaultDocumentDirectory);
		stream >> defaultFolder;
		CleanupStack::PopAndDestroy(); //stream
		}
	else
		defaultFolder.Zero();
	CleanupStack::PopAndDestroy(); //store

	if (defaultFolder.Length()>KOplMaxStringLength)
		User::Leave(KOplErrStrTooLong);
	aOplAPI.PushL(defaultFolder);
	}


void CSystemOpx::GetPhoneInfo(OplAPI& aOplAPI) const
	{ // SyGetPhoneInfo$:(aInfoId%)
#if !defined(USE_ETEL)
	aOplAPI.PopInt16();
	User::Leave(KOplErrNotSupported);
#else
	TPhoneInfoQuery aQuery=(TPhoneInfoQuery)(aOplAPI.PopInt16());

	RTelServer server;
	User::LeaveIfError(server.Connect());
	CleanupClosePushL(server);

	_LIT(KModuleName,"PHONETSY");
   	User::LeaveIfError(server.LoadPhoneModule(KModuleName));

	RBasicGsmPhone gsmPhone;
	_LIT(KPhoneName,"Linda");
	User::LeaveIfError(gsmPhone.Open(server,KPhoneName));
	CleanupClosePushL(gsmPhone);
	RBasicGsmPhone::TId id;
	User::LeaveIfError(gsmPhone.GetGsmPhoneId(id));
	CleanupStack::PopAndDestroy(); // gsmPhone
	
	User::LeaveIfError(server.UnloadPhoneModule(KModuleName));
	CleanupStack::PopAndDestroy(); // server
	
	switch (aQuery)
		{
	case TPhoneManufacturer:
		aOplAPI.PushL(id.iManufacturerId);
		break;
	case TPhoneModelId:
		aOplAPI.PushL(id.iModelId);
		break;
	case TPhoneRevisionId:
		aOplAPI.PushL(id.iRevisionId);
		break;
	case TPhoneSerialNumber:
		aOplAPI.PushL(id.iSerialNumber);
		break;
	default:
		User::Leave(KOplErrInvalidArgs);
		}
#endif
	}

CTlsDataOPXSystem::CTlsDataOPXSystem(OplAPI& aOplAPI)
	:COpxBase(aOplAPI)
	{
	}

CTlsDataOPXSystem* CTlsDataOPXSystem::NewL(OplAPI& aOplAPI)
	{
	CTlsDataOPXSystem* This=new(ELeave) CTlsDataOPXSystem(aOplAPI);
	CleanupStack::PushL(This);
	This->ConstructL();
	CleanupStack::Pop();
	return This;
	}

void CTlsDataOPXSystem::ConstructL()
	{
	iSystemHandle= new(ELeave) CSystemOpx;
	} 

CTlsDataOPXSystem::~CTlsDataOPXSystem()
	{
	delete iSystemHandle;
	Dll::FreeTls();
	}

void CTlsDataOPXSystem::RunL(TInt aProcNum)
	// Run a language extension procedure
	{
	switch (aProcNum)
		{
	case EGetHAL:
		iSystemHandle->GetHAL(iOplAPI);
		break;
	case ESetHAL:
		iSystemHandle->SetHAL(iOplAPI);
		break;

	case EGetTimer:
		iSystemHandle->GetTimer(iOplAPI);
		break;
	case ESetTimer:
		iSystemHandle->SetTimer(iOplAPI);
		break;
	case EResetTimer:
		iSystemHandle->ResetTimer(iOplAPI);
		break;

	case EIsReadOnly:
		iSystemHandle->IsReadOnly(iOplAPI);
		break;
	case EIsHidden:
		iSystemHandle->IsHidden(iOplAPI);
		break;
	case EIsSystem:
		iSystemHandle->IsSystem(iOplAPI);
		break;
	case ESetReadOnly:
		iSystemHandle->SetReadOnly(iOplAPI);
		break;
	case ESetHiddenFile:
		iSystemHandle->SetHiddenFile(iOplAPI);
		break;
	case ESetSystemFile:
		iSystemHandle->SetSystemFile(iOplAPI);
		break;
	case EVolumeSize:
		iSystemHandle->VolumeSize(iOplAPI);
		break;
	case EVolumeSpaceFree:
		iSystemHandle->VolumeSpaceFree(iOplAPI);
		break;
	case EVolumeUniqueID:
		iSystemHandle->VolumeUniqueID(iOplAPI);
		break;
	case EMediaType:
		iSystemHandle->MediaType(iOplAPI);
		break;
	case EFileSize:
		iSystemHandle->FileSize(iOplAPI);
		break;
	case EIsDirectory:
		iSystemHandle->IsDirectory(iOplAPI);
		break;
	case EVolumeName:
		iSystemHandle->VolumeName(iOplAPI);
		break;
	case EUniqueFilename:
		iSystemHandle->UniqueFilename(iOplAPI);
		break;
	case EIsPathVisible:
		iSystemHandle->IsPathVisible(iOplAPI);
		break;

	case ELogonToThread:
		iSystemHandle->LogonToThread(iOplAPI);
		break;
	case ERunApp:
		iSystemHandle->RunApp(iOplAPI);
		break;
	case ERunExe:
		iSystemHandle->RunExe(iOplAPI);
		break;
	case ERunExeWithCommandLine:
		iSystemHandle->RunExeWithCommandLine(iOplAPI);
		break;
	case ERunDocument:
		iSystemHandle->RunDocument(iOplAPI);
		break;
	case ETerminateCurrentProcess:
		iSystemHandle->TerminateCurrentProcess(iOplAPI);
		break;
	case ETerminateProcess:
		iSystemHandle->TerminateProcess(iOplAPI);
		break;
	case EKillCurrentProcess:
		iSystemHandle->KillCurrentProcess(iOplAPI);
		break;
	case EKillProcess:
		iSystemHandle->KillProcess(iOplAPI);
		break;
	case EEndTask:
		iSystemHandle->EndTask(iOplAPI);
		break;
	case EKillTask:
		iSystemHandle->KillTask(iOplAPI);
		break;
	case ESetComputeMode:
		iSystemHandle->SetComputeMode(iOplAPI);
		break;
	case EThreadIdFromOpenDoc:
		iSystemHandle->ThreadIdFromOpenDoc(iOplAPI);
		break;
	case EThreadIdFromAppUid:
		iSystemHandle->ThreadIdFromAppUid(iOplAPI);
		break;
	case EThreadIdFromCaption:
		iSystemHandle->ThreadIdFromCaption(iOplAPI);
		break;
	case ESetBackground:
		iSystemHandle->SetBackground(iOplAPI);
		break;
	case ESetForeground:
		iSystemHandle->SetForeground(iOplAPI);
		break;
	case ESetForegroundByThread:
		iSystemHandle->SetForegroundByThread(iOplAPI);
		break;
	case ESetBackgroundByThread:
		iSystemHandle->SetBackgroundByThread(iOplAPI);
		break;
	case ENextWindowGroupName:
		iSystemHandle->NextWindowGroupName(iOplAPI);
		break;
	case ENextWindowId:
		iSystemHandle->NextWindowId(iOplAPI);
		break;
	case ESendSwitchFilesMessageToApp:
		iSystemHandle->SendSwitchFilesMessageToApp(iOplAPI);
		break;
	case ESendKeyEventToApp:
		iSystemHandle->SendKeyEventToApp(iOplAPI);
		break;
	case ECaptureKey:
		iSystemHandle->CaptureKey(iOplAPI);
		break;
	case ECancelCaptureKey:
		iSystemHandle->CancelCaptureKey(iOplAPI);
		break;
	case EClaimPointerGrab:
		iSystemHandle->ClaimPointerGrab(iOplAPI);
		break;
	case ESetPointerGrabOn:
		iSystemHandle->SetPointerGrabOn(iOplAPI);
		break;
	case ESetPointerCapture:
		iSystemHandle->SetPointerCapture(iOplAPI);
		break;

	case ELoadRsc:
		iSystemHandle->LoadRsc(iOplAPI);
		break;
	case EUnLoadRsc:
		iSystemHandle->UnLoadRsc(iOplAPI);
		break;
	case EReadRsc:
		iSystemHandle->ReadRsc(iOplAPI);
		break;
	case EReadRscLong:
		iSystemHandle->ReadRscLong(iOplAPI);
		break;

	case EFileOpenDialog:
		iSystemHandle->FileOpenDialog(iOplAPI);
		break;
	case EFileCreateDialog:
		iSystemHandle->FileCreateDialog(iOplAPI);
		break;
	case EFileSaveAsDialog:
		iSystemHandle->FileSaveAsDialog(iOplAPI);
		break;

	case EROMVersionMajor:
		iSystemHandle->ROMVersionMajor(iOplAPI);
		break;
	case EROMVersionMinor:
		iSystemHandle->ROMVersionMinor(iOplAPI);
		break;
	case EROMVersionBuild:
		iSystemHandle->ROMVersionBuild(iOplAPI);
		break;
	case EOSVersionMajor:
		iSystemHandle->OSVersionMajor(iOplAPI);
		break;
	case EOSVersionMinor:
		iSystemHandle->OSVersionMinor(iOplAPI);
		break;
	case EOSVersionBuild:
		iSystemHandle->OSVersionBuild(iOplAPI);
		break;

	case EPWIsEnabled:
		iSystemHandle->PWIsEnabled(iOplAPI);
		break;
	case EPWSetEnabled:
		iSystemHandle->PWSetEnabled(iOplAPI);
		break;
	case EPWIsValid:
		iSystemHandle->PWIsValid(iOplAPI);
		break;
	case EPWSet:
		iSystemHandle->PWSet(iOplAPI);
		break;

	case ERemoteLinkStatus:
		iSystemHandle->RemoteLinkStatus(iOplAPI);
		break;
	case ERemoteLinkDisable:
		iSystemHandle->RemoteLinkDisable(iOplAPI);
		break;
	case ERemoteLinkEnable:
		iSystemHandle->RemoteLinkEnable(iOplAPI);
		break;
	case ERemoteLinkEnableWithOptions:
		iSystemHandle->RemoteLinkEnableWithOptions(iOplAPI);
		break;
	case ERemoteLinkConfig:
		iSystemHandle->RemoteLinkConfig(iOplAPI);
		break;

	case EDisplayTaskList:
		iSystemHandle->DisplayTaskList(iOplAPI);
		break;
	case EUidCheckSum:
		iSystemHandle->UidCheckSum(iOplAPI);
		break;
	case EMod:
		iSystemHandle->Mod(iOplAPI);
		break;
	case EXOR:
		iSystemHandle->XOR(iOplAPI);
		break;
	case ELanguageIndex:
		iSystemHandle->LanguageIndex(iOplAPI);
		break;
	case EGetOPXVersion:
		iSystemHandle->GetOPXVersion(iOplAPI);
		break;

	case ERandom:
		iSystemHandle->Random(iOplAPI);
		break;

	case EInactivityTime:
		iSystemHandle->InactivityTime(iOplAPI);
		break;
	case EResetInactivityTime:
		iSystemHandle->ResetInactivityTime(iOplAPI);
		break;

	case ESetSoundEnabled:
		iSystemHandle->SetSoundEnabled(iOplAPI);
		break;
	case ESetSoundDriverEnabled:
		iSystemHandle->SetSoundDriverEnabled(iOplAPI);
		break;

	case EMemoryInformation:
		iSystemHandle->MemoryInformation(iOplAPI);
		break;
	case EDefaultDocumentFolder:
		iSystemHandle->DefaultDocumentFolder(iOplAPI);
		break;
	case EGetPhoneInfo:
		iSystemHandle->GetPhoneInfo(iOplAPI);
		break;
	default:
		User::Leave(KOplErrOpxProcNotFound);
		}
	}

//
// OPX loading interface
//
TBool CTlsDataOPXSystem::CheckVersion(TInt aVersion)
	// To check whether the opx is a compatible version
	// *** Change as required ***
	{
	if ((aVersion & 0xff00)>(KSystemOpxVersion & 0xff00)) // Major version must be <= OPX's version
		return EFalse;	// Bad version
	else
		return ETrue;	// OK
	}

EXPORT_C COpxBase* NewOpxL(OplAPI& aOplAPI)
	// Creates a COpxBase instance as required by the OPL runtime
	// This object is to be stored in the OPX's TLS as shown below
	{
	CTlsDataOPXSystem* tls=((CTlsDataOPXSystem*)Dll::Tls());
	if (tls==NULL)
		{
		tls=CTlsDataOPXSystem::NewL(aOplAPI);
		User::LeaveIfError(Dll::SetTls(tls));
		}
	return (COpxBase *)tls;
	}

EXPORT_C TUint Version()
	{
	return KSystemOpxVersion;
	}

GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
	//
	// DLL entry point
	//
	{
	return(KErrNone);
	}